在java单元测试中，直接在私有方法内部通过new关键字创建对象，会使其难以被mock。本文将探讨为何这种模式阻碍了测试，并提供一种推荐的解决方案：通过引入可注入的工厂模式来解耦对象创建过程，从而实现对内部依赖的有效mocking，提升代码的可测试性和设计质量。
理解挑战：私有方法内部对象创建的测试困境
在Java开发中，我们经常会遇到这样的场景：一个公共方法（public method）内部调用了一个私有方法（private method），而这个私有方法又负责实例化一个具体的对象。例如：
class ParentClass {
public String method1(String argument) {
// ... 其他逻辑 ...
Obj obj1 = privateMethod(argument); // 调用私有方法
return obj1.process(); // 假设Obj有一个process方法
}
private Obj privateMethod(String argument) {
// 直接在这里创建了具体对象
ObjectNeeded2Mock obj = new ObjectNeeded2Mock(argument);
// ... 使用obj进行一些操作 ...
return obj;
}
}
class ObjectNeeded2Mock {
private String data;
public ObjectNeeded2Mock(String data) {
this.data = data;
}
public String process() {
return "Processed: " + data;
}
}当我们尝试为ParentClass的method1编写单元测试时，如果ObjectNeeded2Mock是一个复杂或外部依赖（如数据库连接、网络服务客户端等），我们希望能够Mock掉它，以隔离测试范围，确保测试的独立性和执行速度。然而，由于ObjectNeeded2Mock是在privateMethod内部通过new关键字直接实例化的，常规的Mocking框架（如Mockito）无法直接拦截或替换这个new操作。
为什么直接Mocking无效？
- 私有方法不可见性： 私有方法不属于类的公共API，外部无法直接访问或Mock。
- new关键字的特性： new关键字在Java中用于创建类的实例，它是一个语言层面的操作，而不是一个可被Mocking框架拦截的方法调用。Mocking框架通常通过代理或字节码修改来替换方法调用，但无法替换new操作。
- 紧密耦合： ParentClass与ObjectNeeded2Mock之间形成了紧密的编译时依赖，ParentClass直接控制了ObjectNeeded2Mock的生命周期，这违反了依赖倒置原则。
尝试使用@InjectMock或直接Mock ObjectNeeded2Mock并不能解决问题，因为ParentClass内部仍然会执行new ObjectNeeded2Mock()来创建真正的实例，而不是我们提供的Mock实例。
立即学习“Java免费学习笔记（深入）”；
解决方案：引入可注入的工厂模式
解决此问题的核心思想是解耦对象创建的职责。我们可以引入一个“工厂”来负责ObjectNeeded2Mock的实例化，然后将这个工厂注入到ParentClass中。这样，在测试时，我们就可以注入一个Mock的工厂，由它来返回我们预设的Mock对象。
1. 定义工厂接口
首先，为需要被Mock的对象创建一个工厂接口。
// ObjectNeeded2MockFactory.java
interface ObjectNeeded2MockFactory {
ObjectNeeded2Mock create(String argument);
}2. 实现默认工厂
提供一个默认的工厂实现，它将执行实际的对象创建逻辑。
// DefaultObjectNeeded2MockFactory.java
class DefaultObjectNeeded2MockFactory implements ObjectNeeded2MockFactory {
@Override
public ObjectNeeded2Mock create(String argument) {
return new ObjectNeeded2Mock(argument); // 实际的实例化
}
}3. 修改原始类以接受工厂
修改ParentClass，使其通过构造函数或Setter方法接收ObjectNeeded2MockFactory的实例。这样，ParentClass就不再直接负责ObjectNeeded2Mock的创建，而是委托给注入的工厂。
// ParentClass.java
class ParentClass {
private final ObjectNeeded2MockFactory factory; // 注入工厂
// 通过构造函数注入工厂，推荐方式
public ParentClass(ObjectNeeded2MockFactory factory) {
this.factory = factory;
}
public String method1(String argument) {
// ... 其他逻辑 ...
Obj obj1 = privateMethod(argument);
return obj1.process();
}
private Obj privateMethod(String argument) {
// 现在通过工厂创建对象
ObjectNeeded2Mock obj = factory.create(argument);
// ... 使用obj进行一些操作 ...
return obj;
}
}4. 编写单元测试
现在，我们可以在单元测试中轻松地Mock ObjectNeeded2MockFactory，并控制它返回的ObjectNeeded2Mock实例。
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.verify; // 用于验证方法调用
class ParentClassTest {
@Mock
private ObjectNeeded2MockFactory mockFactory; // Mock工厂
@Mock
private ObjectNeeded2Mock mockObjectNeeded2Mock; // Mock工厂将返回的对象
private ParentClass parentClass;
@BeforeEach
void setUp() {
MockitoAnnotations.openMocks(this); // 初始化所有@Mock注解的字段
parentClass = new ParentClass(mockFactory); // 将Mock工厂注入到被测试类中
}
@Test
void method1_shouldUseMockedObject_whenCalled() {
String testArgument = "testData";
String expectedProcessedResult = "Mocked Processed: " + testArgument;
// 1. 配置mockFactory的行为：当调用create方法时，返回mockObjectNeeded2Mock
when(mockFactory.create(testArgument)).thenReturn(mockObjectNeeded2Mock);
// 2. 配置mockObjectNeeded2Mock的行为：当调用process方法时，返回预期的结果
when(mockObjectNeeded2Mock.process()).thenReturn(expectedProcessedResult);
// 调用被测试的公共方法
String actualResult = parentClass.method1(testArgument);
// 验证结果
assertEquals(expectedProcessedResult, actualResult);
// 验证工厂的create方法是否被调用，且参数正确
verify(mockFactory).create(testArgument);
// 验证mockObjectNeeded2Mock的process方法是否被调用
verify(mockObjectNeeded2Mock).process();
}
}注意事项与总结
- 代码可读性与维护性： 引入工厂模式虽然增加了接口和类的数量，但它显著提升了代码的可测试性、可读性和模块化程度。它使得ParentClass不再关心ObjectNeeded2Mock的具体实现细节，只依赖于一个抽象的工厂接口，符合依赖倒置原则。
- DI框架集成： 在实际项目中，如果使用了Spring、Guice等依赖注入（DI）框架，工厂的注入会更加自动化和优雅。你只需配置DI框架，让它在生产环境中注入DefaultObjectNeeded2MockFactory，在测试环境中注入mockFactory即可。
- 避免PowerMock等工具： 虽然PowerMock等工具可能提供Mock私有方法或new操作的能力，但它们通常会带来额外的复杂性和兼容性问题，且往往掩盖了潜在的设计缺陷。通过重构代码来提高可测试性是更推荐的做法。
- 选择性应用： 并非所有在私有方法中创建的对象都需要引入工厂模式。如果被创建的对象是简单的值对象（Value Object），不包含复杂逻辑或外部依赖，且其行为在测试中不需被隔离，那么直接创建可能更简洁。此模式主要适用于需要隔离复杂依赖或外部服务的场景。
通过采用可注入的工厂模式，我们成功地将对象创建的职责与业务逻辑分离，使得原本难以测试的内部依赖变得易于Mock和控制。这不仅解决了单元测试中的具体问题，更重要的是，它促使我们编写出更健壮、更灵活、更易于维护的代码。
