17370845950

在Java单元测试中，直接模拟私有方法内部通过`new`关键字创建的对象是不可行的。本文将深入探讨这一限制，并提供一种推荐的解决方案：通过引入可注入的工厂模式来解耦对象创建逻辑，从而提高代码的可测试性和灵活性，使私有方法内部依赖的对象能够被有效地模拟和测试。

理解问题：为何无法直接模拟私有方法内部创建的对象

在进行Java单元测试时，我们经常需要模拟（Mock）依赖对象，以隔离被测试单元，确保测试的独立性和可控性。然而，当一个对象在类的私有方法内部使用new关键字直接创建时，传统的模拟框架（如Mockito）会面临挑战。

考虑以下代码结构，其中ParentClass的私有方法privateMethod直接创建了ObjectNeeded2Mock的实例：

class ParentClass {

    public String method1(String... arguments) {
        // ... 其他业务逻辑
        Obj obj1 = privateMethod(arguments[0]); // 调用私有方法
        return "someResult";
    }

    private Obj privateMethod(String argument) {
        // 问题所在：ObjectNeeded2Mock 在私有方法内部直接创建
        ObjectNeeded2Mock obj = new ObjectNeeded2Mock();
        // ... 使用 obj 进行一些操作
        obj.doSomethingWith(argument);
        return new Obj(); // 简化返回
    }
}

class ObjectNeeded2Mock {
    public void doSomethingWith(String data) {
        System.out.println("Doing something with: " + data);
        // 实际业务逻辑
    }
}

class Obj {
    // 简单对象
}

在这种情况下，ParentClass的method1方法依赖于privateMethod，而privateMethod又在内部创建了ObjectNeeded2Mock的实例。尝试通过@Mock或@InjectMocks来模拟ObjectNeeded2Mock是无效的，原因如下：

1. new关键字的本质： new关键字直接在JVM层面创建对象实例，它不是一个普通的方法调用，无法被Mocking框架拦截。Mocking框架通过生成代理类并重写方法来工作，但它们无法控制new操作符的行为。
2. 私有方法的封装性： 私有方法是类的内部实现细节，不直接对外暴露。虽然可以通过反射访问私有方法，但这通常被认为是破坏封装性，且不推荐用于常规单元测试，因为它会使测试变得脆弱，紧密耦合于内部实现。
3. @InjectMocks的局限： @InjectMocks注解主要用于将@Mock或@Spy注解的依赖注入到被测试对象中。它不能模拟被测试对象自身在内部通过new创建的实例。

解决方案：引入可注入的工厂模式

解决此问题的核心思想是解耦对象创建逻辑。与其让ParentClass直接负责创建ObjectNeeded2Mock实例，不如让它通过一个外部提供的机制（一个工厂）来获取这些实例。这样，在测试时，我们可以提供一个模拟的工厂，从而控制ObjectNeeded2Mock的创建。

这种模式被称为可注入的工厂模式（Injectable Factory Pattern）。

步骤一：定义工厂接口

首先，为需要创建的对象定义一个工厂接口。

// ObjectFactory.java
interface ObjectFactory {
    ObjectNeeded2Mock createObjectNeeded2Mock();
}

步骤二：实现具体工厂

创建工厂接口的实现类，其中包含实际的new操作。

// ConcreteObjectFactory.java
class ConcreteObjectFactory implements ObjectFactory {
    @Override
    public ObjectNeeded2Mock createObjectNeeded2Mock() {
        return new ObjectNeeded2Mock();
    }
}

步骤三：修改原始类以使用工厂

修改ParentClass，使其通过构造函数（推荐）或Setter方法接收ObjectFactory实例，并在privateMethod中使用该工厂来创建ObjectNeeded2Mock。

// ParentClass.java (Refactored)
class ParentClass {
    private final ObjectFactory objectFactory; // 注入工厂

    // 通过构造函数注入工厂，这是推荐的方式
    public ParentClass(ObjectFactory objectFactory) {
        this.objectFactory = objectFactory;
    }

    public String method1(String... arguments) {
        // ... 其他业务逻辑
        Obj obj1 = privateMethod(arguments[0]);
        return "someResult";
    }

    private Obj privateMethod(String argument) {
        // 现在通过注入的工厂来创建对象
        ObjectNeeded2Mock obj = objectFactory.createObjectNeeded2Mock();
        obj.doSomethingWith(argument);
        return new Obj();
    }
}

步骤四：编写单元测试

现在，在单元测试中，我们可以轻松地模拟ObjectFactory，并控制它返回的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.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

// 假设 ObjectNeeded2Mock 和 Obj 类已定义如上

class ParentClassTest {

    @Mock
    private ObjectFactory mockObjectFactory; // 模拟工厂

    @Mock
    private ObjectNeeded2Mock mockObjectNeeded2Mock; // 模拟被创建的对象

    // 使用 @InjectMocks 自动注入 mockObjectFactory 到 ParentClass
    // 注意：@InjectMocks 会尝试通过构造函数或setter方法注入，
    // 如果 ParentClass 有一个接受 ObjectFactory 的构造函数，它会被自动调用。
    @InjectMocks
    private ParentClass parentClass;

    @BeforeEach
    void setUp() {
        // 初始化所有 @Mock 和 @InjectMocks 注解的对象
        MockitoAnnotations.openMocks(this);

        //