profundo de reflexión es igual a comparar

Question

Estoy tratando de validar serializar y deserializar rutinas comparando el objeto resultante con el objeto original. Las rutinas pueden serializar clases arbitrarias y profundamente anidadas y, en consecuencia, quiero una rutina de comparación a la que se le pueda dar la instancia original y final y recorrer reflexivamente cada tipo de valor y comparar los valores y bucear iterativamente en tipos de referencia para comparar valores.

He probado el Apache Commons Lang EqualsBuilder.reflectionEquals(inst1, inst2) pero esto no parece hacer una comparación muy profunda, que se limita a comparar los tipos de referencia para la igualdad en lugar de buceo más profundo en ellos:

El código siguiente ilustra mi problema. La primera llamada al reflectionEquals devuelve verdadero pero la segunda devuelve falso.

¿Existe una rutina de biblioteca alguien podría recomendar?

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

De la respuesta a esta pregunta https://stackoverflow.com/a/1449051/116509 y de algunas pruebas preliminares, parece que Unitils' ReflectionAssert.assertReflectionEquals hace lo que usted está esperando . (Editar: pero puede ser abandonado, por lo que podría intentar AssertJ https://joel-costigliola.github.io/assertj/assertj-core-features-highlight.html#field-by-field-recursive)

Estoy muy alarmado por este comportamiento de EqualsBuilder así que gracias por la pregunta. Hay bastantes respuestas en este sitio que lo recomiendan. Me pregunto si la gente que lo recomienda se dio cuenta de que lo hace.

Answer 2

Implemente el método equals() en las clases en cuestión. Los iguales de cada llamada compararán la igualdad de las clases anidadas (o, si lo prefieren, compararán la igualdad de los miembros de los datos). Un método equals correctamente escrito siempre dará como resultado una comparación profunda.

En su ejemplo, los dummy iguales clase sería algo como esto:

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 método sería comparar los objetos que utilizan la reflexión - pero esto es complicado. Otra estrategia sería la de comparar las matrices de bytes de los objetos serializados:

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); 

} 

Su aplicación serializa y deserializa objetos lo que este enfoque parece ser la solución más rápida (en términos de operaciones de la CPU) para su problema.