在Java单元测试场景中，当被测试对象依赖其他组件的方法返回对象时，直接使用真实对象会导致测试耦合度高、执行不稳定，Mockito作为常用的Mock框架，能够很好地解决这个问题，通过模拟方法返回的对象，让测试聚焦于当前逻辑的正确性。
Mockito模拟方法返回对象的基础用法
Mockito提供了when(...).thenReturn(...)的语法来模拟方法的返回值，当需要模拟的方法返回的是一个自定义对象时，只需要先创建该对象的Mock或者真实实例，再将其设置为返回值即可。
假设我们有一个用户服务UserService，它依赖UserRepository的getUserById方法返回用户对象，现在要测试UserService的getUserName方法，示例代码如下：
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.Mockito.when;
import static org.junit.jupiter.api.Assertions.assertEquals;
// 用户实体类
class User {
private String id;
private String name;
public User(String id, String name) {
this.id = id;
this.name = name;
}
public String getName() {
return name;
}
}
// 用户仓储接口
interface UserRepository {
User getUserById(String id);
}
// 用户服务类
class UserService {
private UserRepository userRepository;
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
public String getUserName(String userId) {
User user = userRepository.getUserById(userId);
return user == null ? "未知用户" : user.getName();
}
}
@ExtendWith(MockitoExtension.class)
class UserServiceTest {
// 模拟UserRepository依赖
@Mock
private UserRepository userRepository;
// 将模拟的依赖注入到UserService实例中
@InjectMocks
private UserService userService;
@Test
void testGetUserName_UserExists() {
// 创建模拟返回的用户对象
User mockUser = new User("1", "张三");
// 模拟getUserById方法返回该对象
when(userRepository.getUserById("1")).thenReturn(mockUser);
String result = userService.getUserName("1");
assertEquals("张三", result);
}
@Test
void testGetUserName_UserNotExists() {
// 模拟getUserById方法返回null
when(userRepository.getUserById("2")).thenReturn(null);
String result = userService.getUserName("2");
assertEquals("未知用户", result);
}
}
重构场景下的模拟实践
当代码发生重构，比如方法的返回类型发生变化，或者依赖的获取方式调整时，对应的模拟逻辑也需要同步调整，合理的重构可以让模拟操作更简单。
返回对象类型变更的场景
如果UserRepository的getUserById方法原本返回User对象，重构后返回Optional<User>，那么模拟逻辑需要对应修改：
import java.util.Optional;
// 重构后的用户仓储接口
interface UserRepository {
Optional<User> getUserById(String id);
}
// 重构后的用户服务类
class UserService {
private UserRepository userRepository;
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
public String getUserName(String userId) {
return userRepository.getUserById(userId)
.map(User::getName)
.orElse("未知用户");
}
}
@ExtendWith(MockitoExtension.class)
class UserServiceTest {
@Mock
private UserRepository userRepository;
@InjectMocks
private UserService userService;
@Test
void testGetUserName_UserExists() {
User mockUser = new User("1", "张三");
// 模拟返回Optional包装的用户对象
when(userRepository.getUserById("1")).thenReturn(Optional.of(mockUser));
String result = userService.getUserName("1");
assertEquals("张三", result);
}
@Test
void testGetUserName_UserNotExists() {
// 模拟返回空的Optional
when(userRepository.getUserById("2")).thenReturn(Optional.empty());
String result = userService.getUserName("2");
assertEquals("未知用户", result);
}
}
提取方法后的模拟调整
如果原方法中直接调用了其他组件的方法返回对象，重构后把该调用提取为当前类的内部方法，那么模拟的时候需要使用spy来部分模拟当前对象：
import org.mockito.Spy;
import static org.mockito.Mockito.doReturn;
class UserService {
private UserRepository userRepository;
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
// 提取后的内部方法
private User fetchUser(String userId) {
return userRepository.getUserById(userId);
}
public String getUserName(String userId) {
User user = fetchUser(userId);
return user == null ? "未知用户" : user.getName();
}
}
@ExtendWith(MockitoExtension.class)
class UserServiceTest {
@Mock
private UserRepository userRepository;
// 创建spy对象，部分方法使用真实逻辑，部分方法模拟
@Spy
@InjectMocks
private UserService userService;
@Test
void testGetUserName_WithExtractedMethod() {
User mockUser = new User("1", "张三");
// 模拟内部fetchUser方法的返回值
doReturn(mockUser).when(userService).fetchUser("1");
String result = userService.getUserName("1");
assertEquals("张三", result);
}
}
依赖注入与模拟的协同实践
依赖注入是让模拟更简单的核心实践，通过构造器注入、Setter注入或者字段注入的方式暴露依赖，Mockito可以很方便地替换这些依赖为模拟对象。
构造器注入的模拟
构造器注入是最推荐的依赖注入方式，上面的示例已经展示了构造器注入的场景，测试时只需要将Mock对象传入构造器即可，不需要额外使用@InjectMocks注解：
@ExtendWith(MockitoExtension.class)
class UserServiceTest {
@Mock
private UserRepository userRepository;
private UserService userService;
@Test
void testGetUserName_ConstructorInjection() {
// 直接通过构造器传入模拟对象
userService = new UserService(userRepository);
User mockUser = new User("1", "张三");
when(userRepository.getUserById("1")).thenReturn(mockUser);
String result = userService.getUserName("1");
assertEquals("张三", result);
}
}
Setter注入的模拟
如果依赖是通过Setter方法注入的，测试时可以先创建被测试对象，再调用Setter方法传入模拟对象：
class UserService {
private UserRepository userRepository;
public void setUserRepository(UserRepository userRepository) {
this.userRepository = userRepository;
}
public String getUserName(String userId) {
User user = userRepository.getUserById(userId);
return user == null ? "未知用户" : user.getName();
}
}
@ExtendWith(MockitoExtension.class)
class UserServiceTest {
@Mock
private UserRepository userRepository;
@Test
void testGetUserName_SetterInjection() {
UserService userService = new UserService();
// 调用Setter方法注入模拟对象
userService.setUserRepository(userRepository);
User mockUser = new User("1", "张三");
when(userRepository.getUserById("1")).thenReturn(mockUser);
String result = userService.getUserName("1");
assertEquals("张三", result);
}
}
注意事项
- 模拟返回的对象如果不是Mock对象，要确保该对象的状态符合测试预期，避免真实对象的状态影响测试结果。
- 当模拟的方法有多次调用时，可以使用
thenReturn传入多个返回值，或者使用thenThrow模拟异常返回，比如when(userRepository.getUserById("1")).thenReturn(mockUser).thenThrow(new RuntimeException())。 - 不要过度模拟，如果返回的对象是简单的值对象，且没有复杂依赖，直接使用真实对象反而会让测试更清晰。