在 java 单元测试中,使用 stub(桩)提供固定响应是隔离被测对象依赖项、确保测试可重复性的核心手段。具体做法是在测试类中定义一个实现目标接口的内部类或匿名类,在该实现的方法体中直接返回预设的常量值或模拟数据,然后将该实例注入到被测对象中。这样,无论底层逻辑如何变化,被测对象接收到的输入始终一致,从而能够精准验证业务逻辑分支。

UserService 依赖 UserRepository 时如何构造 Stub
当被测类 UserService 依赖接口 UserRepository 时,可以通过构造函数注入一个实现了该接口的 Stub 对象。Stub 只需关注测试所需的特定方法调用,例如根据 ID 查询用户,并返回固定的用户实体。这种硬编码的返回值消除了对数据库或外部服务的依赖,使得测试运行速度快且结果确定。

import java.util.Optional;
// 1. 定义接口
interface UserRepository {
Optional<User> findById(Long id);
}
class User {
Long id;
String name;
User(Long id, String name) { this.id = id; this.name = name; }
}
// 2. 被测类
public class UserService {
private final UserRepository userRepository;
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
public String getUserNameById(Long id) {
return userRepository.findById(id)
.map(u -> u.name)
.orElse("Unknown");
}
}
// 3. 测试类与 Stub
public class UserServiceTest {
public static void main(String[] args) {
// 创建 Stub:固定返回特定用户
UserRepository stubRepo = new UserRepository() {
@Override
public Optional<User> findById(Long id) {
if (id == 1L) {
return Optional.of(new User(1L, "Alice"));
}
return Optional.empty();
}
};
// 注入 Stub
UserService service = new UserService(stubRepo);
// 执行测试
String result = service.getUserNameById(1L);
System.out.println("Result: " + result); // 输出: Result: Alice
String notFound = service.getUserNameById(99L);
System.out.println("Not Found: " + notFound); // 输出: Not Found: Unknown
}
}上述代码展示了完整的 Stub 实现过程。通过匿名内部类实现 UserRepository,在 findById 方法中针对 ID 为 1 的情况返回预定义的 User 对象,其他情况返回空。测试运行时,UserService 完全不知道它操作的是一个 Stub,只看到固定的返回结果,从而成功验证了名称提取和默认值处理的逻辑。
立即学习“Java免费学习笔记(深入)”;
如何处理多个依赖方法的 Stub 行为
如果被测类依赖的接口包含多个方法,或者需要根据不同的输入参数返回不同的固定响应,Stub 的实现需要覆盖这些场景。通常的做法是在 Stub 的方法实现中加入条件判断,或者使用更复杂的内存数据结构来模拟持久层的行为。这确保了测试能够覆盖被测代码中的不同分支路径,如成功获取数据、数据不存在或数据格式异常等情况。

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
interface OrderServiceInterface {
boolean validateOrder(Long orderId);
double calculateDiscount(Long orderId);
}
class OrderProcessor {
private final OrderServiceInterface orderService;
public OrderProcessor(OrderServiceInterface orderService) {
this.orderService = orderService;
}
public double processOrder(Long orderId) {
if (!orderService.validateOrder(orderId)) {
return 0.0;
}
return orderService.calculateDiscount(orderId) * 100.0;
}
}
public class OrderProcessorTest {
public static void main(String[] args) {
// 创建带有状态记忆的 Stub
Map<Long, Double> discountMap = new HashMap<>();
discountMap.put(101L, 0.1);
discountMap.put(102L, 0.2);
OrderServiceInterface stub = new OrderServiceInterface() {
@Override
public boolean validateOrder(Long orderId) {
// 假设只有存在的订单才有效
return discountMap.containsKey(orderId);
}
@Override
public double calculateDiscount(Long orderId) {
return discountMap.getOrDefault(orderId, 0.0);
}
};
OrderProcessor processor = new OrderProcessor(stub);
// 测试有效订单
double res1 = processor.processOrder(101L);
System.out.println("Order 101: " + res1); // 输出: Order 101: 10.0
// 测试无效订单
double res2 = processor.processOrder(999L);
System.out.println("Order 999: " + res2); // 输出: Order 999: 0.0
}
}在这个例子中,Stub 不仅提供了固定响应,还通过内部的 discountMap 维护了简单的状态。这使得 validateOrder 和 calculateDiscount 两个方法的行为保持一致性。当 processOrder 被调用时,如果订单 ID 不在地图中,验证失败返回 0;如果存在,则计算折扣。这种基于内存数据的 Stub 方式非常适合处理具有关联逻辑的多方法依赖场景,无需外部资源即可复现复杂的业务流。
Stub 返回空值时对 Optional 的处理
在实际开发中,很多现代 Java API 使用 Optional 来避免空指针异常。当使用 Stub 模拟“未找到”的场景时,必须正确返回 Optional.empty() 而不是 null。如果被测代码期望处理 Optional,而 Stub 错误地返回了 null,会导致 NullPointerException,从而掩盖真实的业务逻辑缺陷或导致测试误报。因此,Stub 的类型签名和返回值必须严格匹配接口定义。
import java.util.Optional;
interface DataProvider {
Optional<String> getData(String key);
}
class DataConsumer {
private final DataProvider provider;
public DataConsumer(DataProvider provider) {
this.provider = provider;
}
public String consume(String key) {
return provider.getData(key)
.orElse("Default Value");
}
}
public class DataConsumerTest {
public static void main(String[] args) {
// 正确的 Stub:返回 Optional.empty()
DataProvider stub = new DataProvider() {
@Override
public Optional<String> getData(String key) {
if ("missing".equals(key)) {
return Optional.empty();
}
return Optional.of("Found Data");
}
};
DataConsumer consumer = new DataConsumer(stub);
String found = consumer.consume("key1");
System.out.println(found); // 输出: Found Data
String missing = consumer.consume("missing");
System.out.println(missing); // 输出: Default Value
}
}此段代码演示了 Optional 场景下的 Stub 编写。关键在于 getData 方法在键不存在时返回 Optional.empty()。被测类 DataConsumer 使用 orElse 方法处理这种情况。如果 Stub 错误地返回了 Optional.of(null) 或直接返回 null(如果接口允许),都会破坏测试的准确性。通过精确控制 Stub 的返回类型和内容,可以确保 orElse 分支被正确触发,验证默认值的处理逻辑。


















