深度反射比较等于

Question

我想通过比较生成的对象与原始对象来验证序列化和反序列化例程。例程可以序列化任意深度嵌套的类，因此我想要一个比较例程，它可以给出原始和最终实例，并反射地遍历每个值类型并比较值并迭代地跳入引用类型以比较值。

我已经试过了Apache Commons Lang中EqualsBuilder.reflectionEquals(inst1, inst2)但是这似乎并没有做了非常深刻的比较，它只是为平等而不是跳水比较引用类型深入到他们：

下面的代码说明我的问题。第一次调用reflectionEquals返回true，但第二次返回false。

是否有任何人可以推荐的图书馆常规？

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

从这个问题的答案https://stackoverflow.com/a/1449051/116509和一些初步的测试，它看起来像Unitils' ReflectionAssert.assertReflectionEquals做你期待什么。 （编辑：但可能会被放弃，所以你可以尝试AssertJ https://joel-costigliola.github.io/assertj/assertj-core-features-highlight.html#field-by-field-recursive）

我非常担心EqualsBuilder的这种行为，所以谢谢你的问题。在这个网站上有不少答案推荐它 - 我想知道推荐它的人是否意识到它是这样做的？

Answer 2

在有问题的类上实现equals()方法。每次调用的equals将比较嵌套类的等同性（或者，如果您愿意，将比较数据成员的相等性）。正确书写的等于方法总是会导致深层比较。

在您的例子中，dummy类的equals会是这样的：

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

一种方法是使用反射比较对象 - 但这很棘手。另一种策略是比较序列化对象的字节数组：

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

} 

您的应用程序序列化，因此这种做法似乎是你的问题最快的解决方法（在CPU操作方面）进行反序列化对象。