如何使用JUnit独立测试依赖Class B的Class A（含构造器依赖场景）

要独立测试Class A，核心是用Mock对象替代真实的Class B实例，彻底隔离对B的依赖，只验证Class A自身的业务逻辑。下面分两种常见场景给出具体实现：

场景1：Class A通过Setter或方法参数获取Class B实例 #

假设Class A的结构是这样的：

public class ClassA {
    private ClassB classB;

    public void setClassB(ClassB classB) {
        this.classB = classB;
    }

    public String doSomethingWithB() {
        return classB.someMethod();
    }
}

对应的JUnit测试代码（用Mockito生成Mock对象）：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class ClassATest {
    // 自动生成ClassB的Mock实例
    @Mock
    private ClassB mockClassB;

    private ClassA classA = new ClassA();

    @Test
    public void testDoSomethingWithB() {
        // 配置Mock对象的行为：调用someMethod时返回指定值
        when(mockClassB.someMethod()).thenReturn("mock_result");
        
        // 把Mock对象注入ClassA
        classA.setClassB(mockClassB);
        String result = classA.doSomethingWithB();
        
        // 验证ClassA的逻辑是否符合预期
        assertEquals("mock_result", result);
    }
}

场景2：Class A的构造器需要传入Class B实例 #

如果Class A是通过构造器注入Class B的，结构如下：

public class ClassA {
    private final ClassB classB;

    // 构造器强制注入ClassB
    public ClassA(ClassB classB) {
        this.classB = classB;
    }

    public int calculateWithB(int input) {
        int bValue = classB.getValue(input);
        return bValue * 2;
    }
}

对应的测试代码：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class ClassATest {
    @Mock
    private ClassB mockClassB;

    // 初始化ClassA时直接传入Mock对象
    private ClassA classA = new ClassA(mockClassB);

    @Test
    public void testCalculateWithB() {
        // 配置Mock：当getValue传入5时返回10
        when(mockClassB.getValue(5)).thenReturn(10);
        
        int result = classA.calculateWithB(5);
        
        // 验证ClassA的计算逻辑是否正确
        assertEquals(20, result);
    }
}

关键说明 #

• Mock对象的作用：你可以完全自定义它的方法返回值、抛出异常等行为，不用依赖Class B的真实实现，这样测试失败时能直接定位到Class A的问题，不会被B的bug干扰。
• 为什么不能用真实的Class B：如果依赖真实的B，测试就变成了集成测试，无法单独验证A的逻辑，一旦B出问题，A的测试也会失败，违背了单元测试“只测单个单元”的原则。
• 依赖准备：需要在项目中引入Mockito和JUnit的依赖，比如Maven配置：

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>4.11.0</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.9.2</version>
    <scope>test</scope>
</dependency>

内容的提问来源于stack exchange，提问作者Mahdiyar Jalili