本文目录导读：
在Java中实现服务测试,通常指对业务逻辑层（Service层） 进行单元测试或集成测试，其目标是验证服务层中的方法是否按预期工作，包括数据校验、业务规则、数据库交互以及事务管理等。
以下是几种主流的实现方案和案例：
核心概念
- 单元测试：通常使用 Mock 对象（如 Mockito）来模拟依赖（如 DAO/Repository、外部API），仅测试 Service 本身的方法逻辑，速度极快，隔离性强。
- 集成测试：使用真实或内存数据库（如 H2），以及真实的依赖（如 Spring Context），测试 Service 与数据库、其他组件的交互，更接近真实环境，但速度较慢。
案例环境假设
- 框架：Spring Boot + JUnit 5 + Mockito
- 架构：Controller -> Service -> Repository
- 目标：测试
UserService.createUser(User user)方法，该方法需要校验用户名唯一性，并保存用户。
代码案例
服务层代码（待测试）
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import lombok.RequiredArgsConstructor;
@Service
@RequiredArgsConstructor
public class UserService {
private final UserRepository userRepository;
private final PasswordEncoder passwordEncoder; // 假设有密码加密
@Transactional
public User createUser(User user) throws BusinessException {
// 业务规则1：检查用户名是否已存在
if (userRepository.existsByUsername(user.getUsername())) {
throw new BusinessException("用户名已存在");
}
// 业务规则2：加密密码
user.setPassword(passwordEncoder.encode(user.getPassword()));
// 业务规则3：默认状态
user.setStatus(UserStatus.ACTIVE);
// 保存
return userRepository.save(user);
}
public User findById(Long id) {
return userRepository.findById(id)
.orElseThrow(() -> new BusinessException("用户不存在"));
}
}
单元测试（使用 Mockito 模拟依赖）
场景：测试 createUser 方法。
- 优点：速度快，不依赖数据库。
- 缺点：不能测试 SQL 映射或事务回滚。
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.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class) // 使用Mockito扩展
class UserServiceUnitTest {
@Mock // 模拟依赖
private UserRepository userRepository;
@Mock
private PasswordEncoder passwordEncoder;
@InjectMocks // 将模拟的依赖注入到UserService中
private UserService userService;
@Test
void testCreateUser_Success() {
// 1. 准备测试数据
User user = new User();
user.setUsername("test_user");
user.setPassword("raw_password");
// 2. 模拟外部行为
when(userRepository.existsByUsername("test_user")).thenReturn(false);
when(passwordEncoder.encode("raw_password")).thenReturn("encoded_password");
when(userRepository.save(any(User.class))).thenAnswer(invocation -> {
User savedUser = invocation.getArgument(0);
savedUser.setId(1L); // 模拟数据库生成ID
return savedUser;
});
// 3. 执行测试
User result = userService.createUser(user);
// 4. 验证结果
assertNotNull(result);
assertEquals("test_user", result.getUsername());
assertEquals("encoded_password", result.getPassword());
assertEquals(UserStatus.ACTIVE, result.getStatus()); // 验证默认状态
// 5. 验证交互（可选，确认方法被调用了几次）
verify(userRepository, times(1)).existsByUsername("test_user");
verify(passwordEncoder, times(1)).encode("raw_password");
verify(userRepository, times(1)).save(any(User.class));
}
@Test
void testCreateUser_DuplicateUsername() {
// 1. 准备数据
User user = new User();
user.setUsername("duplicated_user");
// 2. 模拟用户名已存在
when(userRepository.existsByUsername("duplicated_user")).thenReturn(true);
// 3. 执行并断言异常
assertThrows(BusinessException.class, () -> userService.createUser(user));
// 4. 验证save从未被调用（因为失败被拦截了）
verify(userRepository, never()).save(any(User.class));
}
}
集成测试（使用 Spring Boot + H2 数据库）
场景：需要测试 Service 与真实数据库的交互。
- 优点：更真实，可以测试 JPA 映射、事务、SQL 查询。
- 缺点：慢，需要加载 Spring 上下文。
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.transaction.annotation.Transactional;
import static org.junit.jupiter.api.Assertions.*;
@ExtendWith(SpringExtension.class)
@SpringBootTest // 启动整个Spring应用上下文
@Transactional // 测试完成后自动回滚，避免污染数据库
class UserServiceIntegrationTest {
@Autowired
private UserService userService;
@Autowired
private UserRepository userRepository; // 用于辅助验证
@Test
void testCreateUser_Integration() {
// 1. 准备数据（不使用Mock）
User user = new User();
user.setUsername("integration_user");
user.setPassword("raw_password");
// 2. 执行服务
User result = userService.createUser(user);
// 3. 验证结果
assertNotNull(result.getId()); // 数据库生成了ID
assertEquals("integration_user", result.getUsername());
// 检查密码是否真的被加密（和单元测试不同，这里检查的是真实效果）
assertNotEquals("raw_password", result.getPassword());
// 4. 验证是否真的存入了数据库
User dbUser = userRepository.findById(result.getId()).orElse(null);
assertNotNull(dbUser);
assertEquals("integration_user", dbUser.getUsername());
}
@Test
void testCreateUser_Duplicate_Integration() {
// 1. 先插入一个用户
User existingUser = new User();
existingUser.setUsername("unique_user");
existingUser.setPassword("pass");
userRepository.save(existingUser);
// 2. 尝试创建同名用户
User newUser = new User();
newUser.setUsername("unique_user"); // 重复的用户名
newUser.setPassword("pass2");
// 3. 应该抛出异常
assertThrows(BusinessException.class, () -> userService.createUser(newUser));
// 4. 验证数据库中仍然只有1条记录
assertEquals(1, userRepository.countByUsername("unique_user"));
}
}
技术对比与选择
| 特性 | 纯 Mockito 单元测试 | SpringBoot + H2 集成测试 |
|---|---|---|
| 速度 | 极快（毫秒级） | 慢（秒级，加载Spring Context） |
| 依赖 | 仅 JVM + 测试库 | 需要运行 Spring 容器 |
| 测试范围 | 仅 Service 方法内逻辑 | 从 Service -> Repository -> 数据库 |
| Mock 的必要性 | 核心手段 | 通常不需要 Mock |
| 适合场景 | 算法逻辑、条件分支、校验规则 | 数据库交互、事务管理、ORM映射 |
| 环境要求 | 无，随便跑 | 需要数据库（可以是内存库） |
最佳实践建议
-
分层测试：
- 核心业务逻辑：使用 Mockito 进行单元测试，覆盖所有 if-else 分支和异常情况。
- 数据库交互：使用 @SpringBootTest + @Transactional + H2 进行集成测试，覆盖 CRUD 操作、唯一约束、级联保存等。
-
使用
@DataJpaTest： 如果只测试 JPA 相关的 Repository 层，Spring Boot 提供了@DataJpaTest（只加载 JPA 片段，不加载整个 Service），可进一步加快集成测试速度，然后在UserService的单元测试中 Mock 这个 Repository。 -
避免过度 Mock： Service 方法只是简单调用 Repository（如
findById后直接返回），单元测试的价值不大，集成测试更能保证效果。 -
事务处理： 在集成测试中，务必加上
@Transactional，否则测试数据会留在数据库中，导致后续测试失败（除非你使用内存数据库且每次重建）。 -
测试命名： 使用清晰的命名规范，如
testMethodName_ExpectedBehavior_Condition：testCreateUser_ShouldThrowException_WhenUsernameExiststestCreateUser_ShouldReturnActiveUser_WhenDataValid
通过以上两种方式的组合,你可以全面地覆盖服务层的各种测试场景。
