如何在Java服务单元测试中有效管理依赖？

// 服务接口
interface MyService {
    int getItem();
}

// 服务实现，依赖于Loader
@Service
class MyServiceImpl implements MyService {
    private final List<Loader> loaders; // 假设MyServiceImpl可能依赖多个Loader

    public MyServiceImpl(List<Loader> loaders) {
        this.loaders = loaders;
    }

    public int getItem() {
        // 简化逻辑，实际可能更复杂，例如根据某些条件选择Loader
        if (loaders.isEmpty()) {
            return 0; // 或者抛出异常
        }
        Loader loader = loaders.get(0); // 假设总是使用第一个Loader
        return loader.getItem();
    }
}

// Loader接口
interface Loader {
    int getItem();
}

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.x.x</version> <!-- 使用最新稳定版本 -->
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-junit-jupiter</artifactId> <!-- 如果使用JUnit 5 -->
    <version>5.x.x</version>
    <scope>test</scope>
</dependency>

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.*; // 导入Mockito的静态方法

public class MyServiceTests {

    private MyService myService;

    @Mock // 声明一个Loader接口的模拟对象
    private Loader mockLoader;

    @BeforeEach // 使用BeforeEach确保每个测试方法执行前都初始化Mocks
    void setUp() {
        // 初始化所有带有@Mock或@Spy注解的字段
        MockitoAnnotations.openMocks(this);

        // 将模拟的Loader对象注入到MyServiceImpl的构造函数中
        // 注意：这里我们创建一个只包含一个mockLoader的列表
        myService = new MyServiceImpl(List.of(mockLoader));
    }

    @Test
    void testGetItem_Success() {
        // 1. 定义模拟对象的行为
        // 当mockLoader的getItem()方法被调用时，返回预设值100
        when(mockLoader.getItem()).thenReturn(100);

        // 2. 调用被测试服务的方法
        int result = myService.getItem();

        // 3. 验证结果
        assertEquals(100, result, "getItem方法应返回100");

        // 4. 验证与模拟对象的交互
        // 验证mockLoader的getItem()方法是否被调用了1次
        verify(mockLoader, times(1)).getItem();
        // 验证没有其他不必要的交互
        verifyNoMoreInteractions(mockLoader);
    }

    @Test
    void testGetItem_NoLoaders() {
        // 为MyServiceImpl创建一个没有Loader的实例
        MyService myServiceNoLoaders = new MyServiceImpl(List.of());

        // 根据MyServiceImpl的当前逻辑，如果loaders为空，getItem()返回0
        int result = myServiceNoLoaders.getItem();

        assertEquals(0, result, "当没有Loader时，getItem方法应返回0");
    }

    // 可以在这里添加更多测试用例，例如测试Loader抛出异常的情况
    @Test
    void testGetItem_LoaderThrowsException() {
        // 模拟Loader抛出运行时异常
        when(mockLoader.getItem()).thenThrow(new RuntimeException("Loader error"));

        // 验证MyServiceImpl在Loader抛出异常时的行为
        // 预期MyServiceImpl会将异常传递出去，或者根据其内部逻辑进行处理
        // 这里我们假设它会直接抛出
        org.junit.jupiter.api.Assertions.assertThrows(RuntimeException.class, () -> {
            myService.getItem();
        }, "getItem方法应抛出RuntimeException");

        verify(mockLoader, times(1)).getItem();
    }
}