如何在没有 equals 方法的情况下断言两个类的相等性？

这里有很多正确的答案，但我也想添加我的版本。这是基于 Assertj 的。

import static org.assertj.core.api.Assertions.assertThat;

public class TestClass {

    public void test() {
        // do the actual test
        assertThat(actualObject)
            .isEqualToComparingFieldByFieldRecursively(expectedObject);
    }
}

更新：在 assertj v3.13.2 中，此方法已弃用，正如 Woodz 在评论中指出的那样。目前的建议是

public class TestClass {

    public void test() {
        // do the actual test
        assertThat(actualObject)
            .usingRecursiveComparison()
            .isEqualTo(expectedObject);
    }

}

---

Mockito 提供反射匹配器：

对于最新版本的 Mockito，请使用：

Assert.assertTrue(new ReflectionEquals(expected, excludeFields).matches(actual));

对于旧版本，请使用：

Assert.assertThat(actual, new ReflectionEquals(expected, excludeFields));

---

我通常使用 org.apache.commons.lang3.builder.EqualsBuilder 来实现这个用例

Assert.assertTrue(EqualsBuilder.reflectionEquals(expected,actual));

---

我知道它有点旧，但我希望它有所帮助。

我遇到了和你一样的问题，所以，经过调查，我发现很少有与这个问题相似的问题，并且在找到解决方案后，我在这些问题中回答相同，因为我认为它可以帮助别人。

这个similar question的The most voted answer（不是作者选择的）是最适合您的解决方案。

基本上，它包括使用名为 Unitils 的库。

这是用途：

User user1 = new User(1, "John", "Doe");
User user2 = new User(1, "John", "Doe");
assertReflectionEquals(user1, user2);

即使类 User 没有实现 equals()，它也会通过。您可以在他们的 tutorial 中看到更多示例和一个名为 assertLenientEquals 的非常酷的断言。

---

如果您将 hamcrest 用于您的断言 (assertThat) 并且不想引入额外的测试库，那么您可以使用 SamePropertyValuesAs.samePropertyValuesAs 来断言没有被覆盖的 equals 方法的项目。

好处是您不必再引入另一个测试框架，如果您使用 EqualsBuilder.reflectionEquals() 之类的东西，它会在断言失败 (expected: field=<value> but was field=<something else>) 而不是 expected: true but was false 时给出有用的错误。

缺点是它是一个浅比较并且没有排除字段的选项（就像在 EqualsBuilder 中一样），因此您必须解决嵌套对象（例如删除它们并独立比较它们）。

最佳案例：

import static org.hamcrest.beans.SamePropertyValuesAs.samePropertyValuesAs;
...
assertThat(actual, is(samePropertyValuesAs(expected)));

丑陋的案例：

import static org.hamcrest.beans.SamePropertyValuesAs.samePropertyValuesAs;
...
SomeClass expected = buildExpected(); 
SomeClass actual = sut.doSomething();

assertThat(actual.getSubObject(), is(samePropertyValuesAs(expected.getSubObject())));    
expected.setSubObject(null);
actual.setSubObject(null);

assertThat(actual, is(samePropertyValuesAs(expected)));

所以，选择你的毒药。附加框架（例如 Unitils）、无用的错误（例如 EqualsBuilder）或浅比较（hamcrest）。

---

您可以使用 Apache commons lang ReflectionToStringBuilder

您可以一一指定要测试的属性，或者更好地排除您不想要的属性：

String s = new ReflectionToStringBuilder(o, ToStringStyle.SHORT_PREFIX_STYLE)
                .setExcludeFieldNames(new String[] { "foo", "bar" }).toString()

然后，您可以正常比较这两个字符串。关于反射缓慢的观点，我认为这只是为了测试，所以不应该那么重要。

---

由于这个问题很老，我将建议使用 JUnit 5 的另一种现代方法。

我不喜欢这种解决方案，因为如果早期断言失败，我将无法获得完整的平等图景。

在 JUnit 5 中，有一个名为 Assertions.assertAll() 的方法，它允许您将测试中的所有断言组合在一起，它将执行每个断言并在最后输出任何失败的断言。这意味着任何首先失败的断言都不会停止后面断言的执行。

assertAll("Test obj1 with obj2 equality",
    () -> assertEquals(obj1.getFieldA(), obj2.getFieldA()),
    () -> assertEquals(obj1.getFieldB(), obj2.getFieldB()),
    () -> assertEquals(obj1.getFieldC(), obj2.getFieldC()));

---

库 Hamcrest 1.3 Utility Matchers 有一个特殊的匹配器，它使用反射而不是等于。

assertThat(obj1, reflectEquals(obj2));

---

一些反射比较方法很浅

另一种选择是将对象转换为 json 并比较字符串。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;    
public static String getJsonString(Object obj) {
 try {
    ObjectMapper objectMapper = new ObjectMapper();
    return bjectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
     } catch (JsonProcessingException e) {
        LOGGER.error("Error parsing log entry", e);
        return null;
    }
}
...
assertEquals(getJsonString(MyexpectedObject), getJsonString(MyActualObject))

---

使用 Shazamcrest，您可以：

assertThat(obj1, sameBeanAs(obj2));

---

AssertJ 断言可用于比较没有正确覆盖 #equals 方法的值，例如：

import static org.assertj.core.api.Assertions.assertThat; 

// ...

assertThat(actual)
    .usingRecursiveComparison()
    .isEqualTo(expected);

---

逐个字段比较：

assertNotNull("Object 1 is null", obj1);
assertNotNull("Object 2 is null", obj2);
assertEquals("Field A differs", obj1.getFieldA(), obj2.getFieldA());
assertEquals("Field B differs", obj1.getFieldB(), obj2.getFieldB());
...
assertEquals("Objects are not equal.", obj1, obj2);

---

您可以使用反射来“自动化”完整的相等测试。您可以实现为单个字段编写的相等“跟踪”代码，然后使用反射在对象中的所有字段上运行该测试。

---

如果您只需要平面字段比较，您可以使用 AssertJ

Assertions.assertThat(actual)).isEqualToComparingFieldByField(expected);

---

这是一个通用的比较方法，它比较同一类的两个对象的字段值（记住那些可以通过 get 方法访问）

public static <T> void compare(T a, T b) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
    AssertionError error = null;
    Class A = a.getClass();
    Class B = a.getClass();
    for (Method mA : A.getDeclaredMethods()) {
        if (mA.getName().startsWith("get")) {
            Method mB = B.getMethod(mA.getName(),null );
            try {
                Assert.assertEquals("Not Matched = ",mA.invoke(a),mB.invoke(b));
            }catch (AssertionError e){
                if(error==null){
                    error = new AssertionError(e);
                }
                else {
                    error.addSuppressed(e);
                }
            }
        }
    }
    if(error!=null){
        throw error ;
    }
}

---

我偶然发现了一个非常相似的案例。

我想在测试中比较一个对象与另一个对象具有相同的属性值，但像 is()、refEq() 等方法无法工作，因为我的对象在其 id 属性中具有空值.

所以这是我找到的解决方案（好吧，一位同事找到了）：

import static org.apache.commons.lang.builder.CompareToBuilder.reflectionCompare;

assertThat(reflectionCompare(expectedObject, actualObject, new String[]{"fields","to","be","excluded"}), is(0));

如果从 reflectionCompare 得到的值为 0，则表示它们相等。如果是 -1 或 1，则它们在某些属性上有所不同。

---

在 AssertJ 的常见情况下，您可以创建自定义比较器策略：

assertThat(frodo).usingComparator(raceComparator).isEqualTo(sam)
assertThat(fellowshipOfTheRing).usingElementComparator(raceComparator).contains(sauron);

Using a custom comparison strategy in assertions

AssertJ examples

---

在对 Android 应用程序进行单元测试时，我遇到了完全相同的难题，而我想出的最简单的解决方案就是使用 Gson 将我的实际值和期望值对象转换为 json 并将它们作为字符串进行比较。

String actual = new Gson().toJson( myObj.getValues() );
String expected = new Gson().toJson( new MyValues(true,1) );

assertEquals(expected, actual);

与逐个字段手动比较相比，这样做的优势在于您可以比较所有您的字段，因此即使您稍后向您的类添加一个新字段，它也会被自动测试，与 if 相比您在所有字段上使用了一堆 assertEquals()，如果您向班级添加更多字段，则需要对其进行更新。

jUnit 还为您显示字符串，以便您可以直接查看它们的不同之处。但不确定 Gson 的字段排序有多可靠，这可能是一个潜在问题。

---

我尝试了所有答案，但没有什么对我真正有用。

所以我创建了自己的方法来比较简单的 java 对象而不深入嵌套结构......

如果所有字段都匹配或包含不匹配详细信息的字符串，则方法返回 null。

仅比较具有 getter 方法的属性。

如何使用

        assertNull(TestUtils.diff(obj1,obj2,ignore_field1, ignore_field2));

不匹配时的示例输出

输出显示比较对象的属性名称和各自的值

alert_id(1:2), city(Moscow:London)

代码（Java 8 及以上）：

 public static String diff(Object x1, Object x2, String ... ignored) throws Exception{
        final StringBuilder response = new StringBuilder();
        for (Method m:Arrays.stream(x1.getClass().getMethods()).filter(m->m.getName().startsWith("get")
        && m.getParameterCount()==0).collect(toList())){

            final String field = m.getName().substring(3).toLowerCase();
            if (Arrays.stream(ignored).map(x->x.toLowerCase()).noneMatch(ignoredField->ignoredField.equals(field))){
                Object v1 = m.invoke(x1);
                Object v2 = m.invoke(x2);
                if ( (v1!=null && !v1.equals(v2)) || (v2!=null && !v2.equals(v1))){
                    response.append(field).append("(").append(v1).append(":").append(v2).append(")").append(", ");
                }
            }
        }
        return response.length()==0?null:response.substring(0,response.length()-2);
    }

---

对于单元测试，我只是将对象序列化为 JSON 字符串并进行比较。以 Gson 为例：

import com.google.gson.GsonBuilder
import junit.framework.TestCase.assertEquals

class AssertEqualContent {
    companion object {
        val gson = GsonBuilder().create()

        fun assertEqualContent(message: String?, expected: Any?, actual: Any?) {
            assertEquals(message, gson.toJson(expected), gson.toJson(actual))
        }
    }
}

由于预期的和实际的对象应该是相同的类型，因此字段顺序将是相同的。

优点：

你会得到一个很好的字符串比较，准确地指出差异在哪里。

没有额外的库（前提是你已经有一个 JSON 库）

缺点：

不同类型的对象可能会产生相同的 JSON（但如果有，您可能会考虑为什么对相同的数据有不同的类......以及它们最终如何在测试方法中进行比较 :-)

---

您可以将发布的比较代码放入一些静态实用程序方法中吗？

public static String findDifference(Type obj1, Type obj2) {
    String difference = "";
    if (obj1.getFieldA() == null && obj2.getFieldA() != null
            || !obj1.getFieldA().equals(obj2.getFieldA())) {
        difference += "Difference at field A:" + "obj1 - "
                + obj1.getFieldA() + ", obj2 - " + obj2.getFieldA();
    }
    if (obj1.getFieldB() == null && obj2.getFieldB() != null
            || !obj1.getFieldB().equals(obj2.getFieldB())) {
        difference += "Difference at field B:" + "obj1 - "
                + obj1.getFieldB() + ", obj2 - " + obj2.getFieldB();
        // (...)
    }
    return difference;
}

你可以像这样在 JUnit 中使用这个方法：

assertEquals("对象不相等", "", findDifferences(obj1, obj));

这并不笨拙，并且可以为您提供有关差异的完整信息（如果存在差异）（通过不完全采用 assertEqual 的正常形式，但您可以获得所有信息，所以它应该是好的）。

---

从您的评论到其他答案，我不明白您想要什么。

只是为了讨论，假设该类确实覆盖了 equals 方法。

所以你的 UT 看起来像：

SomeType expected = // bla
SomeType actual = // bli

Assert.assertEquals(expected, actual). 

你完成了。此外，如果断言失败，您将无法获得“完全平等的画面”。

据我了解，您是说即使类型确实覆盖了equals，您也不会对此感兴趣，因为您想获得“完全相等的图片”。因此，扩展和覆盖 equals 也没有任何意义。

所以你必须选择：要么逐个比较属性，使用反射或硬编码检查，我建议后者。或者：比较这些对象的人类可读表示。

例如，您可以创建一个帮助类，将您希望与 XML 文档比较的类型序列化，然后比较生成的 XML！在这种情况下，您可以直观地看到什么是完全相等的，什么不是。

这种方法将使您有机会查看全貌，但它也相对繁琐（起初容易出错）。

---

您可以覆盖类的 equals 方法，例如：

@Override
public int hashCode() {
    int hash = 0;
    hash += (app != null ? app.hashCode() : 0);
    return hash;
}

@Override
public boolean equals(Object object) {
    HubRule other = (HubRule) object;

    if (this.app.equals(other.app)) {
        boolean operatorHubList = false;

        if (other.operator != null ? this.operator != null ? this.operator
                .equals(other.operator) : false : true) {
            operatorHubList = true;
        }

        if (operatorHubList) {
            return true;
        } else {
            return false;
        }
    } else {
        return false;
    }
}

好吧，如果你想比较一个类中的两个对象，你必须以某种方式实现 equals 和 hash code 方法

---