Java: soluzione consigliata per la clonazione profonda / la copia di un'istanza

Mi chiedo se esiste un modo consigliato per eseguire il clone / copia di istanza in profondità in Java.

Ho in mente 3 soluzioni, ma potrei essermene perso alcune e vorrei avere la tua opinione

modifica: includi la proposta di Bohzo e affina la domanda: si tratta più della clonazione profonda che della clonazione superficiale.

Fallo da solo:

codificare manualmente le proprietà del clone dopo le proprietà e verificare che anche le istanze mutabili vengano clonate.
pro:
- controllo di ciò che verrà eseguito
-
contro esecuzione rapida :
- noioso da scrivere e mantenere
- soggetto a bug (errore copia / incolla, proprietà mancante, proprietà mutabile riassegnata)

Usa la riflessione:

Con i tuoi strumenti di riflessione o con un helper esterno (come i jakarta common-bean) è facile scrivere un metodo di copia generico che eseguirà il lavoro su una riga.
pro:
- facile da scrivere
- nessun
contro di manutenzione :
- minor controllo di ciò che accade
- bug soggetto a oggetto mutabile se lo strumento di riflessione non clona troppo gli oggetti secondari
- esecuzione più lenta

Usa framework clone:

Usa un framework che lo faccia per te, come:
commons-lang SerializationUtils
Java Deep Cloning Library
Dozer
Kryo

pro:
- lo stesso della riflessione
- maggiore controllo su ciò che sarà esattamente clonato.
contro:
- ogni istanza mutabile è completamente clonata, anche alla fine della gerarchia
- potrebbe essere molto lenta da eseguire

Utilizzare la strumentazione bytecode per scrivere clone in fase di esecuzione

javassit , BCEL o cglib potrebbero essere utilizzati per generare un cloner dedicato con la stessa velocità con cui è stata scritta una mano. Qualcuno conosce una lib usando uno di questi strumenti per questo scopo?

Cosa mi sono perso qui?
Quale consiglieresti?

Grazie.

Per la clonazione profonda (clona l'intera gerarchia di oggetti):

• commons-lang SerializationUtils - utilizzando la serializzazione - se tutte le classi sono sotto il tuo controllo e puoi forzare l'implementazione Serializable.

• Java Deep Cloning Library - using reflection - nei casi in cui le classi o gli oggetti che si desidera clonare siano fuori dal proprio controllo (una libreria di terze parti) e non è possibile implementarli Serializable, o nei casi in cui non si desidera implementare Serializable.

Per la clonazione superficiale (clona solo le proprietà di primo livello):

• commons-beanutils BeanUtils - nella maggior parte dei casi.

• Spring BeanUtils - se stai già utilizzando spring e quindi disponi di questa utility sul percorso di classe.

Ho deliberatamente omesso l'opzione "fai-da-te": le API di cui sopra forniscono un buon controllo su cosa fare e cosa non clonare (ad esempio usando transiento String[] ignoreProperties), quindi non è preferibile reinventare la ruota.

Il libro di Joshua Bloch ha un intero capitolo intitolato "Articolo 10: Sovrascrivi il clone con giudizio" in cui spiega perché ignorare il clone per la maggior parte è una cattiva idea perché le specifiche Java per esso creano molti problemi.

Fornisce alcune alternative:

• Utilizzare un modello di fabbrica al posto di un costruttore:

       public static Yum newInstance(Yum yum);

• Usa un costruttore di copie:

       public Yum(Yum yum);

Tutte le classi di raccolta in Java supportano il costruttore di copie (ad esempio new ArrayList (l);)

Dalla versione 2.07 Kryo supporta la clonazione superficiale / profonda :

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

Kryo è veloce, sulla e della loro pagina puoi trovare un elenco di aziende che lo usano nella produzione.

Utilizzare XStream toXML / fromXML in memoria. Estremamente veloce ed è in circolazione da molto tempo e sta andando forte. Gli oggetti non devono essere serializzabili e non devi usare la riflessione (anche se XStream lo fa). XStream può discernere le variabili che puntano allo stesso oggetto e non fare accidentalmente due copie complete dell'istanza. Molti dettagli del genere sono stati messi a punto nel corso degli anni. L'ho usato per un certo numero di anni ed è un tentativo. È facile da usare come puoi immaginare.

new XStream().toXML(myObj)

o

new XStream().fromXML(myXML)

Per clonare,

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

Più succintamente:

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

Per oggetti complicati e quando le prestazioni non sono significative, uso gson per serializzare l'oggetto su json text, quindi deserializzare il testo per ottenere un nuovo oggetto.

gson che in base alla riflessione funzionerà nella maggior parte dei casi, tranne per il fatto che i transientcampi non verranno copiati e gli oggetti con riferimento circolare con causa 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);

}

Dipende.

Per la velocità, usa fai-da-te. A prova di proiettile, utilizzare la riflessione.

A proposito, la serializzazione non è la stessa di refl, poiché alcuni oggetti possono fornire metodi di serializzazione sovrascritti (readObject / writeObject) e possono essere buggy

Consiglierei il modo DIY che, combinato con un buon metodo hashCode () e equals (), dovrebbe essere facile da provare in un unit test.

Suggerirei di sovrascrivere Object.clone (), chiamare prima super.clone () e poi chiamare ref = ref.clone () su tutti i riferimenti che si desidera vengano copiati in profondità. È più o meno l' approccio Fai da te ma ha bisogno di un po 'meno di codifica.

Per la clonazione profonda implementare Serializable su ogni classe che si desidera clonare in questo modo

public static class Obj implements Serializable {
    public int a, b;
    public Obj(int a, int b) {
        this.a = a;
        this.b = b;
    }
}

E quindi utilizzare questa funzione:

public static Object deepClone(Object object) {
    try {
        ByteArrayOutputStream baOs = new ByteArrayOutputStream();
        ObjectOutputStream oOs = new ObjectOutputStream(baOs);
        oOs.writeObject(object);
        ByteArrayInputStream baIs = new ByteArrayInputStream(baOs.toByteArray());
        ObjectInputStream oIs = new ObjectInputStream(baIs);
        return oIs.readObject();
    }
    catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

come questo: Obj newObject = (Obj)deepClone(oldObject);