深度反射比较等于

Question

我正在尝试通过将结果对象与原始对象进行比较来验证序列化和反序列化例程。这些例程可以序列化任意和深度嵌套的类，因此我想要一个比较例程，它可以给定原始实例和最终实例，并反思性地遍历每个值类型并比较值并迭代地深入参考类型以比较值。

我已经尝试过 Apache Commons Lang EqualsBuilder.reflectionEquals(inst1, inst2) 但这似乎并没有进行非常深入的比较，它只是比较引用类型的相等性，而不是深入研究它们：

以下代码说明了我的问题。第一次调用reflectionEquals 返回真，但第二次返回假。

有没有人可以推荐的库例程？

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://assertj.github.io/doc/#assertj-core-recursive-comparison）

2021 年编辑：EqualsBuilder 现在有一个testRecursive 选项。然而，提到的单元测试库会为您提供更好的失败消息来帮助调试，因此根据上下文，它们仍然是最佳选择。

Answer 2

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

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 操作而言）。

Answer 3

您可以使用 AssertJ 的field by field recursive comparison 功能，例如：

import static org.assertj.core.api.BDDAssertions.then;

then(actualObject).usingRecursiveComparison().isEqualTo(expectedObject);

Answer 4

在相关类上实现equals() 方法。每个调用的 equals 将比较嵌套类的相等性（或者，如果您愿意，将比较数据成员的相等性）。正确编写的 equals 方法总是会导致深度比较。

在您的示例中，dummy 类等于是这样的：

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 5

我知道这是一个迟到的回复，但这可能对有需要的人有用。所以在我的项目中，我需要比较整个反序列化的值，看看它们是否正确匹配，我使用的 dep 是 Javers。它与 SpringBoot 集成良好，使用非常简单。

这是示例 impl：

@RunWith(SpringRunner.class)
public class DeserializerTest {

    private HubMessage message;
    private static final String EXPECTED_INVALID_MSG = "testInvalidMessage";
    private PlatformEventHeader msgHeaders;
    private ObjectMapper objectMapper = new ObjectMapper();
    private final DeserializerClass testDeserializerClass = new DeserializerClass();
    private String TOPIC_TEST = "testTopic";
    private static final String ACTUAL_HUBMESSAGE = "XXXStringValueofmessage";
    @Before
    public void stubSetup() throws IOException {
        // setup the message
       message = new HubMessage ();

        //setup the headers
       msgHeaders = new PlatformEventHeader();
        ...
        ...

        DomainEvent event= new DomainEvent();
        Map<String, String> msgEventObjMap = new HashMap<>();
        ...
        event.setMessage(msgEventObjMap);
        message.setEvent(event);
        message.setHeader(msgHeaders);

    }

    @Test
   public void test_deserialize_validMessage() throws JsonProcessingException {
          // My actual deserialzierClass
          HubMessage messageReceived = testDeserializerClass.deserialize(TOPIC_TEST,  
             new RecordHeaders(),ACTUAL_HUBMESSAGE .getBytes());

        Javers javers = JaversBuilder.javers().build();
        Diff diff = javers.compare((Object)objectMapper.convertValue(messageReceived, Object.class),
                (Object)objectMapper.readValue(ACTUAL_HUBMESSAGE, Object.class));
        Assert.assertEquals(diff.getChanges().size() , 0);
    }

我使用 Diff 来确定对象中是否存在任何更改。现在覆盖/使用 toString() 效率不高，因为它期望属性在 Matchers 中的预期值和实际值的顺序相同。 Unitils 解决了这个问题，这可能会给大量下载的第三方 jars 带来很多麻烦。所以更好的选择是使用Javers.io