Java: solution recommandée pour le clonage/copie en profondeur d'une instance

Le livre de Joshua Bloch a un chapitre entier intitulé "Item 10: Override Clone Judicieusement" dans lequel il explique pourquoi le remplacement du clone pour la plupart est une mauvaise idée car la spécification Java crée de nombreux problèmes.

Il fournit quelques alternatives:

• Utiliser un modèle d'usine à la place d'un constructeur:

       public static Yum newInstance(Yum yum);
  

• Utiliser un constructeur de copie:

       public Yum(Yum yum);
  

Toutes les classes de collection en Java prennent en charge la copie constructeur (par exemple new ArrayList (l);)

Depuis la version 2.07 Kryo prend en charge le clonage superficiel/profond :

Kryo kryo = new Kryo();
SomeClass someObject = ...
SomeClass copy1 = kryo.copy(someObject);
SomeClass copy2 = kryo.copyShallow(someObject);

Kryo est rapide, à la et de leur page, vous pouvez trouver une liste des sociétés qui l'utilisent dans la production.

Utilisez XStream toXML/fromXML en mémoire. Extrêmement rapide et existe depuis longtemps et va fort. Les objets n'ont pas besoin d'être sérialisables et vous n'avez pas use reflection (bien que XStream le fasse). XStream peut discerner les variables qui pointent vers le même objet et ne pas accidentellement faire deux copies complètes de l'instance. Beaucoup de détails comme ça ont été martelés au fil des ans. Je l'ai utilisé pour un certain nombre d'années et c'est un aller. Il est aussi facile à utiliser que vous pouvez imaginer.

new XStream().toXML(myObj)

Ou

new XStream().fromXML(myXML)

À cloner,

new XStream().fromXML(new XStream().toXML(myObj))

Plus succinctement:

XStream x = new XStream();
Object myClone = x.fromXML(x.toXML(myObj));

Dépend.

Pour la vitesse, utilisez le BRICOLAGE. Pour l'épreuve des balles, utilisez la réflexion.

BTW, la sérialisation n'est pas la même que refl, car certains objets peuvent fournir des méthodes de sérialisation surchargées (readObject/writeObject) et ils peuvent être bogués

Je recommanderais la méthode DIY qui, combinée à une bonne méthode hashCode() et equals() devrait être facile à prouver dans un test unitaire.

Je suggère de remplacer l'objet.clone (), appelez super.clone () d'abord et puis appelez ref = ref.clone () sur toutes les références que vous souhaitez avoir copiées en profondeur. C'est plus ou moins une approche Do it yourself mais nécessite un peu moins de codage.

Pour les objets compliqués et lorsque les performances ne sont pas significatives, j'utilise gson pour sérialiser l'objet json texte, puis désérialiser le texte pour obtenir un nouvel objet.

Gson qui basé sur la réflexion fonctionnera dans la plupart des cas, sauf que transient les champs ne seront pas copiés et les objets avec référence circulaire avec cause StackOverflowError.

public static <ObjectType> ObjectType Copy(ObjectType AnObject, Class<ObjectType> ClassInfo)
{
    Gson gson = new GsonBuilder().create();
    String text = gson.toJson(AnObject);
    ObjectType newObject = gson.fromJson(text, ClassInfo);
    return newObject;
}
public static void main(String[] args)
{
    MyObject anObject ...
    MyObject copyObject = Copy(o, MyObject.class);

}