如何测试java组合代码

在 Java 中，“组合代码”通常指通过对象组合（composition）来实现功能，而不是继承。测试组合代码的核心思想是：验证“被组合对象的行为”是否被正确调用，以及“组合对象自身逻辑”是否正确。

下面从常见测试方式 + 示例来说明。

一、组合代码示例

// 被组合的类
public class Engine {
    public String start() {
        return "Engine started";
    }
}

// 组合类
public class Car {
    private Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public String run() {
        return engine.start() + " -> Car running";
    }
}

二、测试方式一：使用真实对象（单元测试）

适合简单、无外部依赖的情况。

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class CarTest {
    @Test
    void testCarRunWithRealEngine() {
        Engine engine = new Engine();
        Car car = new Car(engine);

        assertEquals(
            "Engine started -> Car running",
            car.run()
        );
    }
}

✅ 优点：简单直接
❌ 缺点：如果 Engine 很复杂或依赖外部资源，不适合

三、测试方式二：依赖注入 + Mock（推荐）

组合代码一定是通过构造函数或 setter 注入依赖，方便测试。

使用 Mockito 示例

import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

class CarTest {
    @Test
    void testCarRunWithMockEngine() {
        Engine mockEngine = mock(Engine.class);
        when(mockEngine.start()).thenReturn("Mock engine started");

        Car car = new Car(mockEngine);
        String result = car.run();

        assertEquals("Mock engine started -> Car running", result);
        verify(mockEngine).start(); // 验证组合对象调用了 engine
    }
}

✅ 优点：

• 不依赖真实实现
• 可验证“是否调用了组合对象的方法”

四、测试方式三：验证组合逻辑（不只是调用）

如果组合类本身有逻辑：

public class Car {
    private Engine engine;
    private boolean running;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        if (!running) {
            engine.start();
            running = true;
        }
    }

    public boolean isRunning() {
        return running;
    }
}

测试：

@Test
void testStartOnlyOnce() {
    Engine mockEngine = mock(Engine.class);
    Car car = new Car(mockEngine);

    car.start();
    car.start();

    verify(mockEngine, times(1)).start();
    assertTrue(car.isRunning());
}

五、组合代码测试的核心原则

1. 组合关系必须可注入

   // ✅ 好
   public Car(Engine engine)
   
   // ❌ 不好
   public Car() {
       this.engine = new Engine();
   }
   

2. 测试组合对象，而不是依赖对象
3. Mock 只用于验证“是否正确使用依赖”
4. 真实对象用于测试业务结果

六、常见测试工具

• JUnit 5（测试框架）
• Mockito（Mock 组合依赖）
• AssertJ（更优雅的断言）

如果你有具体的组合代码结构（比如 Spring Bean、策略模式、装饰器模式），我可以帮你写针对性测试用例。