在java单元测试中，直接mock私有方法内部通过`new`关键字创建的对象是不可行的。本文将深入探讨这一挑战，并提供一种有效的解决方案：通过引入可注入的工厂模式来解耦对象创建过程。这种方法不仅能提高代码的可测试性，还能使私有方法中的依赖易于管理和模拟，从而实现更健壮的单元测试。
理解私有方法中对象创建的测试挑战
在Java中，当一个公共方法内部调用私有方法，而该私有方法又直接通过new关键字实例化一个对象时，传统的单元测试和Mocking框架（如Mockito）会面临挑战。考虑以下场景：
// 假设这是需要测试的原始类
class ParentClass {
public ParentClass() {}
public String method1(String argument) {
// ... method1 的一些业务逻辑 ...
Obj obj1 = privateMethod(argument); // 内部调用私有方法
// ... 使用 obj1 进行更多操作 ...
return "Result from method1 based on " + obj1.getData();
}
private Obj privateMethod(String argument) {
// 这里直接创建了 ObjectNeeded2Mock 的实例
ObjectNeeded2Mock obj = new ObjectNeeded2Mock(argument);
String data = obj.performComplexOperation(); // 假设这是一个复杂或外部依赖的操作
// ... 使用 data ...
return new Obj(data); // 返回一个 Obj 实例
}
}
// 辅助类定义
class Obj {
private String data;
public Obj(String data) { this.data = data; }
public String getData() { return data; }
}
class ObjectNeeded2Mock {
private String initData;
public ObjectNeeded2Mock(String data) { this.initData = data; }
public String performComplexOperation() {
// 模拟一个复杂的、耗时的或有外部依赖的操作
System.out.println("Performing complex operation with: " + initData);
return "Processed:" + initData;
}
}在这种结构中，如果ObjectNeeded2Mock的performComplexOperation()方法包含复杂的业务逻辑、外部服务调用（如数据库、网络请求）或文件操作，那么在测试method1时，我们实际上会执行这些复杂操作。这违背了单元测试的“隔离性”原则，因为它将一个单元测试变成了集成测试，导致测试运行缓慢、不稳定且难以维护。
直接Mock ObjectNeeded2Mock是困难的，原因如下：
- 私有方法隔离性：私有方法通常不直接暴露给外部，Mocking框架难以直接干预其内部行为。
- new关键字：new关键字直接创建了具体类的实例，而不是通过依赖注入的方式获取。Mocking框架主要通过代理或子类化来工作，它们无法拦截或替换new操作符的行为（除非使用PowerMock等更高级但通常不推荐的工具）。
解决方案：引入工厂模式实现可测试性
为了解决这个问题，核心思想是解耦ParentClass与ObjectNeeded2Mock的直接创建关系。这可以通过依赖注入和工厂模式来实现。
立即学习“Java免费学习笔记（深入）”；
1. 定义工厂接口
首先，为ObjectNeeded2Mock的创建定义一个工厂接口。
interface ObjectNeeded2MockFactory {
ObjectNeeded2Mock createObjectNeeded2Mock(String argument);
}2. 实现默认工厂
提供一个默认的工厂实现，它将负责实际地实例化ObjectNeeded2Mock。
class DefaultObjectNeeded2MockFactory implements ObjectNeeded2MockFactory {
@Override
public ObjectNeeded2Mock createObjectNeeded2Mock(String argument) {
return new ObjectNeeded2Mock(argument);
}
}3. 重构ParentClass
修改ParentClass，使其通过构造函数（推荐）或Setter方法接受ObjectNeeded2MockFactory的实例。然后，在privateMethod中，不再直接使用new，而是通过注入的工厂来创建ObjectNeeded2Mock。
class ParentClass {
private final ObjectNeeded2MockFactory objectNeeded2MockFactory;
// 推荐使用构造函数注入
public ParentClass(ObjectNeeded2MockFactory objectNeeded2MockFactory) {
this.objectNeeded2MockFactory = objectNeeded2MockFactory;
}
// 提供一个默认构造函数，用于非测试环境或简化初始化
public ParentClass() {
this(new DefaultObjectNeeded2MockFactory());
}
public String method1(String argument) {
// ... method1 的一些业务逻辑 ...
Obj obj1 = privateMethod(argument);
// ... 使用 obj1 进行更多操作 ...
return "Result from method1 based on " + obj1.getData();
}
private Obj privateMethod(String argument) {
// 现在通过工厂来创建 ObjectNeeded2Mock 实例
ObjectNeeded2Mock obj = objectNeeded2MockFactory.createObjectNeeded2Mock(argument);
String data = obj.performComplexOperation();
return new Obj(data);
}
}编写单元测试
经过上述重构后，我们现在可以轻松地为ParentClass编写单元测试，并通过Mocking框架控制ObjectNeeded2Mock的行为。
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.*;
class ParentClassTest {
@Mock
private ObjectNeeded2MockFactory mockFactory; // Mock 工厂接口
@Mock
private ObjectNeeded2Mock mockObjectNeeded2Mock; // Mock 工厂将要返回的对象
@InjectMocks
private ParentClass parentClass; // 将 Mock 注入到 ParentClass 实例中
@BeforeEach
void setUp() {
MockitoAnnotations.openMocks(this); // 初始化所有 @Mock 和 @InjectMocks 注解
// 配置 mockFactory：当调用 createObjectNeeded2Mock 时，返回 mockObjectNeeded2Mock
when(mockFactory.createObjectNeeded2Mock(anyString())).thenReturn(mockObjectNeeded2Mock);
}
@Test
void testMethod1_withMockedPrivateDependency() {
// Arrange
String testArgument = "testData";
String expectedProcessedData = "MockedProcessed:testData";
// 配置 mockObjectNeeded2Mock 的行为：当调用 performComplexOperation 时，返回预期的模拟数据
when(mockObjectNeeded2Mock.performComplexOperation()).thenReturn(expectedProcessedData);
// Act
String result = parentClass.method1(testArgument);
// Assert
// 验证工厂是否被调用以创建对象
verify(mockFactory, times(1)).createObjectNeeded2Mock(testArgument);
// 验证被 Mock 的对象的 performComplexOperation 方法是否被调用
verify(mockObjectNeeded2Mock, times(1)).performComplexOperation();
// 验证 method1 的最终结果是否符合预期
assertEquals("Result from method1 based on " + expectedProcessedData, result);
}
}在这个测试中：
- 我们Mock了ObjectNeeded2MockFactory接口，而不是ObjectNeeded2Mock类本身。
- 我们配置了mockFactory，使其在被调用时返回一个预先Mock好的ObjectNeeded2Mock实例（mockObjectNeeded2Mock）。
- 然后，我们就可以像测试其他依赖一样，控制mockObjectNeeded2Mock的行为，从而隔离ParentClass的测试。
注意事项与最佳实践
- 依赖注入原则：这种解决方案体现了依赖注入（DI）的核心思想——将依赖的创建和管理从类内部转移到外部。这使得代码更加模块化、可测试和可维护。
- 构造函数注入：优先使用构造函数注入来提供工厂实例。这确保了ParentClass在创建时就拥有所有必要的依赖，避免了对象处于不完整状态。
- 避免滥用PowerMock：虽然PowerMock等工具可以提供更强大的Mocking能力，包括Mock私有方法和静态方法，但它们通常更复杂，且可能掩盖代码中存在的结构性问题（如紧耦合）。在大多数情况下，通过良好的设计和重构（如工厂模式），可以避免使用这些高级工具。
- 接口优于实现：工厂模式中，我们为工厂定义了接口。这使得ParentClass不依赖于具体的工厂实现，进一步提高了灵活性。
- 大型项目与DI框架：在大型Java项目中，可以考虑使用Spring、Guice等依赖注入框架来自动化依赖的管理和注入，从而简化工厂模式的实现和配置。
总结
当Java私有方法内部直接通过new关键字创建对象，导致单元测试困难时，直接Mock这些内部创建的对象是不可行的。最佳实践是通过引入可注入的工厂模式来解耦对象创建过程。这包括定义工厂接口、实现具体工厂，并重构原始类以接受工厂实例。通过这种方式，我们可以在单元测试中Mock工厂，进而控制被创建对象的行为，从而实现对核心业务逻辑的独立、高效测试，显著提升代码的可测试性和可维护性。
