如何在Mockito中模拟构造方法内的对象创建？

针对你遇到的类A中final类型Connection对象无法模拟的问题，这里提供几种可行的解决方案：

1. 重构代码实现依赖注入（推荐） #

直接修改类A的构造逻辑，将Connection对象的创建逻辑解耦，通过依赖注入的方式传入，这是最符合软件工程原则的方案，也让测试变得简单。

修改后的类A代码：

public class A {
    protected final Config config;
    protected final Connection connection;

    // 新增用于测试和依赖注入的构造方法
    public A(Config config, Connection connection) {
        this.config = config;
        this.connection = connection;
    }

    // 保留原有构造方法，兼容业务代码的调用逻辑
    public A(Config config) {
        this(config, new Connection("a", "b"));
    }
    
    public void someMethod() {
    }
}

测试时，直接传入Mock的Connection对象即可：

import org.junit.Test;
import static org.mockito.Mockito.*;

public class ATest {
    @Test
    public void testSomeMethod() {
        // 创建Mock对象
        Config mockConfig = mock(Config.class);
        Connection mockConnection = mock(Connection.class);

        // 实例化类A，传入Mock的Connection
        A a = new A(mockConfig, mockConnection);

        // 执行测试方法
        a.someMethod();

        // 验证Connection的方法调用（如果需要）
        // verify(mockConnection).someConnectionMethod();
    }
}

2. 使用PowerMock拦截构造方法调用（无需修改原代码） #

如果无法修改类A的源码，可以借助PowerMock来拦截new Connection("a", "b")的调用，返回Mock对象。

测试代码示例：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import static org.mockito.Mockito.mock;

@RunWith(PowerMockRunner.class)
@PrepareForTest(A.class) // 标记需要处理的类，因为它包含构造Connection的代码
public class ATest {

    @Test
    public void testSomeMethod() {
        // 创建Mock的Connection和Config
        Connection mockConnection = mock(Connection.class);
        Config mockConfig = mock(Config.class);

        // 拦截Connection的构造调用，指定参数并返回Mock对象
        PowerMockito.whenNew(Connection.class)
                    .withArguments("a", "b")
                    .thenReturn(mockConnection);

        // 实例化类A，此时构造方法中的connection会是Mock对象
        A a = new A(mockConfig);

        // 执行测试逻辑
        a.someMethod();

        // 验证Mock对象的方法调用（如有需要）
        // PowerMockito.verifyNew(Connection.class).withArguments("a", "b");
    }
}

注意：需要引入PowerMock与Mockito的整合依赖，确保版本相互兼容。

3. 子类+反射修改Final字段（不推荐） #

如果上述两种方法都无法使用，可以通过创建子类结合反射的方式修改final类型的connection字段，但这种方法属于hack手段，易受JVM版本影响，仅作为最后备选。

测试用子类代码：

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class TestableA extends A {
    public TestableA(Config config, Connection mockConnection) {
        super(config);
        try {
            // 获取父类的connection字段
            Field connectionField = A.class.getDeclaredField("connection");
            connectionField.setAccessible(true);

            // 去除final修饰符
            Field modifiersField = Field.class.getDeclaredField("modifiers");
            modifiersField.setAccessible(true);
            modifiersField.setInt(connectionField, connectionField.getModifiers() & ~Modifier.FINAL);

            // 替换为Mock对象
            connectionField.set(this, mockConnection);
        } catch (Exception e) {
            throw new RuntimeException("修改connection字段失败", e);
        }
    }
}

测试时使用这个子类：

import org.junit.Test;
import static org.mockito.Mockito.mock;

public class ATest {
    @Test
    public void testSomeMethod() {
        Config mockConfig = mock(Config.class);
        Connection mockConnection = mock(Connection.class);

        TestableA testableA = new TestableA(mockConfig, mockConnection);
        testableA.someMethod();

        // 验证逻辑
    }
}

内容的提问来源于stack exchange，提问作者Pankaj Rathi