本文深入探讨了java junit测试中，当`assertequals`方法比较看似相同的对象却断言失败的常见问题。文章详细介绍了三种有效的解决方案：正确实现对象的`equals`和`hashcode`方法、逐个字段进行断言，以及利用assertj库的`usingrecursivecomparison`进行深度比较。通过本文，读者将掌握在单元测试中准确断言对象相等性的多种策略，从而编写出更健壮、可靠的单元测试。
在Java单元测试中，我们经常需要断言一个方法返回的对象是否符合预期。JUnit的assertEquals方法是进行此类断言的常用工具。然而，许多开发者会遇到一个常见问题：即使两个对象的字符串表示（如toString()输出）看起来完全相同，assertEquals仍然报告断言失败。这通常是因为assertEquals在比较对象时，默认调用的是对象的equals()方法。如果您的自定义类没有正确实现equals()方法，它将继承Object类的默认equals()实现，该实现仅比较对象的内存地址（即是否是同一个对象引用）。
为了解决这个问题，并确保在单元测试中能够准确地断言对象相等性，有以下几种策略可供选择。
1. 正确实现对象的 equals() 和 hashCode() 方法
这是解决对象相等性断言问题的最根本和推荐的方法。当您需要根据对象的业务逻辑值来判断它们是否相等时，必须在您的自定义类中重写equals()和hashCode()方法。
1.1 equals() 方法的契约
equals()方法必须遵循以下契约：
立即学习“Java免费学习笔记（深入）”；
- 自反性 (Reflexive): 对于任何非空引用值x，x.equals(x)必须返回true。
- 对称性 (Symmetric): 对于任何非空引用值x和y，当且仅当y.equals(x)返回true时，x.equals(y)才返回true。
- 传递性 (Transitive): 对于任何非空引用值x、y和z，如果x.equals(y)返回true，并且y.equals(z)返回true，那么x.equals(z)也必须返回true。
- 一致性 (Consistent): 对于任何非空引用值x和y，只要equals比较中使用的信息没有被修改，多次调用x.equals(y)始终返回相同的结果。
- 对于null值 (Nullity): 对于任何非空引用值x，x.equals(null)必须返回false。
1.2 hashCode() 方法的契约
当您重写equals()方法时，也必须重写hashCode()方法。hashCode()方法必须遵循以下契约：
- 在应用程序执行期间，只要对象的equals比较中所用的信息没有被修改，对同一个对象多次调用hashCode方法都必须返回同一个整数。
- 如果两个对象根据equals(Object)方法是相等的，那么对这两个对象中的每个对象调用hashCode方法都必须生成相同的整数结果。
- 如果两个对象根据equals(Object)方法是不相等的，那么对这两个对象中的每个对象调用hashCode方法，不要求生成不同的整数结果。然而，为不相等的对象生成不同的整数结果可以提高哈希表的性能。
1.3 示例代码（以 Customer 类为例）
假设我们有一个Customer类：
public class Customer {
private Long id;
private String name;
private double price;
private String type;
// 构造函数、Getter和Setter方法省略
public Customer(Long id, String name, double price, String type) {
this.id = id;
this.name = name;
this.price = price;
this.type = type;
}
// 重写 equals() 方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Customer customer = (Customer) o;
return Double.compare(customer.price, price) == 0 &&
Objects.equals(id, customer.id) &&
Objects.equals(name, customer.name) &&
Objects.equals(type, customer.type);
}
// 重写 hashCode() 方法
@Override
public int hashCode() {
return Objects.hash(id, name, price, type);
}
@Override
public String toString() {
return "Customer{" +
"Id=" + id +
", Name='" + name + '\'' +
", Price=" + price +
", Type='" + type + '\'' +
'}';
}
}在实现了equals()和hashCode()之后，您的JUnit测试就可以正常工作了：
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class CustomerServiceTest {
// 假设 repo.getById(1) 返回一个 Customer 对象
// Customer test1 = repo.getById(1);
@Test
public void getCustomerById_Test() {
// 模拟实际返回的对象
Customer actualCustomer = new Customer(1L, "ABC", 350.0, "ABC");
// 预期对象
Customer expectedCustomer = new Customer(1L, "ABC", 350.0, "ABC");
// 现在 assertEquals 会正确比较对象内容
assertEquals(expectedCustomer, actualCustomer);
}
}2. 逐个字段进行断言
如果您不想或者不方便为某个类实现equals()和hashCode()（例如，这是一个第三方库的类，或者您只关心对象的部分字段），您可以选择逐个字段地进行断言。这种方法在某些特定场景下非常实用，例如，您只关心对象中的几个关键属性，而不关心所有属性。
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class CustomerServiceTest {
@Test
public void getCustomerById_FieldByField_Test() {
// 模拟实际返回的对象
Customer actualCustomer = new Customer(1L, "ABC", 350.0, "ABC");
// 逐个字段进行断言
assertEquals(1L, actualCustomer.getId());
assertEquals("ABC", actualCustomer.getName());
assertEquals(350.0, actualCustomer.getPrice(), 0.001); // 对于浮点数，建议使用delta
assertEquals("ABC", actualCustomer.getType());
}
}注意事项：
- 这种方法会增加测试代码的冗余度，如果对象有很多字段，测试代码会变得很长。
- 如果对象的结构发生变化（添加或删除字段），您可能需要更新多个断言。
- 对于浮点数比较，请务必使用带有误差范围（delta）的assertEquals重载方法，以避免浮点数精度问题。
3. 使用 AssertJ 库的 usingRecursiveComparison()
AssertJ 是一个功能强大的流式断言库，它提供了比标准JUnit断言更丰富、更易读的API。其中，usingRecursiveComparison()方法是解决对象深度比较问题的优雅方案，它可以在不修改被测试类equals()方法的情况下，对对象的字段进行递归比较。
3.1 引入 AssertJ 依赖
首先，您需要在项目的pom.xml（Maven）或build.gradle（Gradle）中添加AssertJ依赖：
Maven:
<dependency>
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
<version>3.25.3</version> <!-- 使用最新稳定版本 -->
<scope>test</scope>
</dependency>Gradle:
testImplementation 'org.assertj:assertj-core:3.25.3' // 使用最新稳定版本
3.2 使用 usingRecursiveComparison()
引入依赖后，您就可以在测试中使用usingRecursiveComparison()进行深度比较了：
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
public class CustomerServiceTest {
@Test
public void getCustomerById_AssertJRecursive_Test() {
// 模拟实际返回的对象
Customer actualCustomer = new Customer(1L, "ABC", 350.0, "ABC");
// 预期对象
Customer expectedCustomer = new Customer(1L, "ABC", 350.0, "ABC");
assertThat(actualCustomer)
.usingRecursiveComparison() // 启用递归比较
.isEqualTo(expectedCustomer);
}
}usingRecursiveComparison()方法默认会比较对象的所有字段，包括私有字段，并且会递归地比较嵌套对象。AssertJ还提供了丰富的配置选项，例如：
- ignoringFields(): 忽略某些字段的比较。
- ignoringActualFields(): 忽略实际对象的某些字段。
- ignoringExpectedFields(): 忽略预期对象的某些字段。
- ignoringFieldsOfTypes(): 忽略特定类型的字段。
- withComparatorForType(): 为特定类型指定自定义比较器。
这些选项使得usingRecursiveComparison()非常灵活，可以适应各种复杂的比较需求。
总结
在Java单元测试中，正确地断言对象相等性是编写高质量测试的关键。根据您的具体需求和场景，可以选择以下策略：
- 实现 equals() 和 hashCode()： 这是最规范和推荐的做法，尤其当对象的业务逻辑相等性需要被广泛应用时。它使得assertEquals能够自然地工作，并确保对象在集合（如HashMap、HashSet）中行为正确。
- 逐个字段断言： 当您只关心对象的部分字段，或者不想修改类的equals()方法时，这是一种直接且无需额外依赖的解决方案。但要注意代码冗余和维护成本。
- 使用 AssertJ 的 usingRecursiveComparison()： 这是一个强大的第三方库解决方案，特别适用于需要进行深度比较，但又不想或不能修改被测类equals()方法的场景。它提供了高度的灵活性和可读性。
选择哪种方法取决于项目的具体约定、团队偏好以及被测试对象的特性。理解每种方法的优缺点，将帮助您编写出更有效、更易于维护的单元测试。
