Confronto Deep Reflective uguale a

Question

Sto provando a convalidare le routine serialize e de-serialize confrontando l'oggetto risultante con l'oggetto originale. Le routine possono serializzare classi arbitrarie e profondamente annidate e di conseguenza voglio una routine di confronto che possa essere data all'istanza originale e finale e riflettere in modo riflessivo ogni tipo di valore e confrontare i valori e immergersi iterativamente in tipi di riferimento per confrontare i valori.

Ho provato l'Apache Commons Lang EqualsBuilder.reflectionEquals(inst1, inst2) ma questo non sembra fare un confronto molto profondo, si confronta semplicemente i tipi di riferimento per l'uguaglianza, piuttosto che le immersioni più in profondità nel loro:

Il codice seguente illustra il mio problema. La prima chiamata a reflectionEquals restituisce true ma la seconda restituisce false.

Esiste una routine di libreria che chiunque potrebbe consigliare?

class dummy { 
    dummy2 nestedClass; 
} 

class dummy2 { 
    int intVal; 
} 

@Test 
public void testRefEqu() { 

    dummy inst1 = new dummy(); 
    inst1.nestedClass = new dummy2(); 
    inst1.nestedClass.intVal = 2; 
    dummy inst2 = new dummy(); 
    inst2.nestedClass = new dummy2(); 
    inst2.nestedClass.intVal = 2; 
    boolean isEqual = EqualsBuilder.reflectionEquals(inst1.nestedClass, inst2.nestedClass); 
    isEqual = EqualsBuilder.reflectionEquals(inst1, inst2); 
} 

Answer 1

Dalla risposta a questa domanda https://stackoverflow.com/a/1449051/116509 e da alcuni test preliminari, sembra che Unitils' ReflectionAssert.assertReflectionEquals fa quello che ti aspetti . (Modifica: ma potrebbe essere abbandonato, quindi potresti provare AssertJ https://joel-costigliola.github.io/assertj/assertj-core-features-highlight.html#field-by-field-recursive)

Sono molto allarmato da questo comportamento di EqualsBuilder quindi grazie per la domanda. Ci sono molte risposte su questo sito che lo raccomandano - mi chiedo se le persone che lo raccomandano si siano rese conto di farlo?

Answer 2

Implementare il metodo equals() nelle classi in questione. Gli uguali di ogni chiamata confronteranno l'uguaglianza delle classi nidificate (o, se lo desideri, confronteranno l'uguaglianza dei membri dei dati). Un metodo uguaglianza scritto correttamente porterà sempre a un confronto profondo.

Nel tuo esempio, di uguale classe dummy sarebbe qualcosa di simile:

public boolean equals(Object other) 
{ 
    if (other == this) return true; 
    if (other instanceOf dummy) 
    { 
     dummy dummyOther = (dummy)other; 
     if (nestedClass == dummyOther.nestedClass) 
     { 
      return true; 
     } 
     else if (nestedClass != null) 
     { 
      return nestedClass.equals(dummyOther); 
     } 
     else // nestedClass == null and dummyOther.nestedClass != null. 
     { 
      return false; 
     } 
    } 
    else 
    { 
     return false; 
    } 
} 

Answer 3

Un metodo sarebbe quello di confrontare gli oggetti usando il riflesso - ma questo è difficile. Un'altra strategia potrebbe essere quella di confrontare array di byte di oggetti serializzati:

class dummy implements Serializable { 
    dummy2 nestedClass; 
} 

class dummy2 implements Serializable { 
    int intVal; 
} 

@Test 
public void testRefEqu() throws IOException { 

    dummy inst1 = new dummy(); 
    inst1.nestedClass = new dummy2(); 
    inst1.nestedClass.intVal = 2; 

    dummy inst2 = new dummy(); 
    inst2.nestedClass = new dummy2(); 
    inst2.nestedClass.intVal = 2; 

    boolean isEqual1 = EqualsBuilder.reflectionEquals(inst1.nestedClass, inst2.nestedClass); 
    boolean isEqual2 = EqualsBuilder.reflectionEquals(inst1, inst2); 

    System.out.println(isEqual1); 
    System.out. println(isEqual2); 

    ByteArrayOutputStream baos1 =new ByteArrayOutputStream(); 
    ObjectOutputStream oos1 = new ObjectOutputStream(baos1); 
    oos1.writeObject(inst1); 
    oos1.close(); 

    ByteArrayOutputStream baos2 =new ByteArrayOutputStream(); 
    ObjectOutputStream oos2 = new ObjectOutputStream(baos2); 
    oos2.writeObject(inst1); 
    oos2.close(); 

    byte[] arr1 = baos1.toByteArray(); 
    byte[] arr2 = baos2.toByteArray(); 

    boolean isEqual3 = Arrays.equals(arr1, arr2); 

    System.out.println(isEqual3); 

} 

L'applicazione serializza e deserializza oggetti per cui questo approccio sembra essere la soluzione più veloce (in termini di operazioni di CPU) per il vostro problema.