使用junit 5作为核心测试框架，通过maven或gradle引入依赖；2. 配合mockito进行依赖隔离，使用@mock创建模拟对象，@injectmocks注入被测实例；3. 遵循first原则：测试需快速、独立、可重复、自我验证且及时编写；4. 采用given-when-then模式组织测试逻辑；5. 通过mocking验证方法调用，stubbing设定返回值；6. 外部依赖如数据库使用h2等内存库或testcontainers；7. 时间等动态因素通过注入clock等可控制接口实现稳定测试；8. 测试应聚焦公共方法，避免直接测试私有方法，确保高可维护性和可读性。这些实践共同保障java单元测试的有效性和代码质量。
在Java开发中，单元测试是确保代码质量和功能正确性的基石，它让开发者能独立验证程序最小可测试单元的行为。它不是什么高深的魔法，而更像是一种工程实践，让你在代码变动时心里有底，减少了“改动一处，崩溃一片”的恐惧。从我个人的经验来看，这玩意儿真能让你睡个安稳觉，尤其是在维护老旧代码或者多人协作的项目里。
要让Java代码通过单元测试来验证功能，核心在于使用合适的测试框架，并遵循一些基本原则。通常，我们用JUnit作为测试框架，配合Mockito来处理依赖。
首先，你需要将JUnit库引入你的项目。如果你用Maven，在
pom.xml
立即学习“Java免费学习笔记（深入）”；
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.10.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<version>5.10.0</version>
<scope>test</scope>
</dependency>如果是Gradle，则在
build.gradle
dependencies {
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.0'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
}接着，你需要为你要测试的类创建一个对应的测试类。比如，你有一个
Calculator
public class Calculator {
public int add(int a, int b) {
return a + b;
}
public int divide(int a, int b) {
if (b == 0) {
throw new IllegalArgumentException("Divisor cannot be zero");
}
return a / b;
}
}那么，你会在
src/test/java
CalculatorTest
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
class CalculatorTest {
@Test
@DisplayName("测试加法功能")
void testAdd() {
Calculator calculator = new Calculator();
int result = calculator.add(2, 3);
assertEquals(5, result, "2 + 3 应该等于 5"); // 验证结果是否符合预期
}
@Test
@DisplayName("测试除法功能")
void testDivide() {
Calculator calculator = new Calculator();
int result = calculator.divide(10, 2);
assertEquals(5, result, "10 / 2 应该等于 5");
}
@Test
@DisplayName("测试除数为零的异常")
void testDivideByZero() {
Calculator calculator = new Calculator();
// 验证是否抛出特定的异常
assertThrows(IllegalArgumentException.class, () -> calculator.divide(10, 0), "除数为零时应抛出 IllegalArgumentException");
}
}这里面，
@Test
assertEquals
assertThrows
谈到工具，那么我们自然会想到JUnit。它是Java世界里单元测试的绝对主力，几乎是标配。目前主流的是JUnit 5（也叫JUnit Jupiter），它比之前的JUnit 4提供了更灵活的扩展模型和更丰富的功能，比如更强大的参数化测试、动态测试等。如果你在启动一个新项目，直接上JUnit 5准没错。
但光有JUnit还不够，很多时候我们的类会有外部依赖，比如它可能需要调用一个数据库服务、一个远程API或者另一个复杂的业务组件。直接在单元测试里去初始化这些依赖，不仅会拖慢测试速度，还会让测试变得不稳定（比如网络波动）。这时候，Mockito就登场了。Mockito是一个强大的Mocking框架，它可以让你创建“假”的对象（mock对象），这些假对象可以模拟真实对象的行为，让你能够隔离被测试的单元，只关注它自身的逻辑。
举个例子，如果你的
UserService
UserRepository
UserService
createUser
UserRepository
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.assertNotNull;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class) // 启用MockitoExtension
class UserServiceTest {
@Mock // 标记这是一个mock对象
private UserRepository userRepository;
@InjectMocks // 将mock对象注入到这个实例中
private UserService userService;
@Test
void testCreateUser() {
User user = new User("testUser");
when(userRepository.save(user)).thenReturn(user); // 当调用save方法时，返回user对象
User createdUser = userService.createUser(user);
assertNotNull(createdUser);
// 进一步验证 createdUser 的属性是否符合预期
}
}
// 假设有这样的类
class User {
String name;
public User(String name) { this.name = name; }
// getters, setters...
}
interface UserRepository {
User save(User user);
}
class UserService {
private final UserRepository userRepository;
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
public User createUser(User user) {
// 业务逻辑，可能还有其他操作
return userRepository.save(user);
}
}除了JUnit和Mockito，有时你可能还会看到Hamcrest，它提供了一套更具可读性的断言匹配器，让你的测试代码读起来更像自然语言。不过，JUnit 5自带的断言已经足够强大，Hamcrest并非必需。构建工具如Maven和Gradle本身就集成了运行测试的能力，你只需要配置好，它们就能自动发现并执行你的单元测试。选择这些工具，更多是基于项目需求和团队习惯，但JUnit和Mockito是Java单元测试的黄金搭档，这是我的肺腑之言。
写测试，不仅仅是让代码跑起来不报错那么简单，更重要的是要写出“好”的测试。我个人在实践中总结了几点，觉得挺有用的。
一个很重要的原则是FIRST原则：
在实践中，我发现Given-When-Then模式非常有助于组织测试代码。
例如，上面
testAdd
Calculator calculator = new Calculator();
int result = calculator.add(2, 3);
assertEquals(5, result, "2 + 3 应该等于 5");
此外，测试的粒度也很关键。单元测试应该只关注一个“单元”的逻辑，通常是一个方法。不要在一个单元测试里测试太多东西，那样一旦失败了，你很难快速定位问题。同时，要覆盖所有重要的路径，包括正常路径、边界条件（比如最大值、最小值、空值、空集合）和异常路径。对于那些抛出异常的情况，我们也要有专门的测试来验证异常是否被正确抛出。
最后，一个我常犯的错误（也看到很多人犯）是过度测试私有方法。私有方法是实现细节，它们的服务于公共方法。你应该通过测试公共方法来间接验证私有方法的行为，而不是直接去测试私有方法。如果你发现一个私有方法变得非常复杂，难以通过公共方法来测试，那可能意味着这个私有方法应该被抽取成一个独立的公共方法（或者一个独立的辅助类），这样它就能被直接测试了。
处理外部依赖是单元测试中最让人头疼，但也最能体现水平的地方。毕竟，真实世界的应用很少是完全独立的。
Mocking和Stubbing是核心策略。正如前面提到的Mockito，它能帮助我们模拟那些难以在测试环境中真实运行的外部服务。
Mockito的
when().thenReturn()
verify()
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.*; // 导入 verify
@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
@Mock
private PaymentGateway paymentGateway; // 模拟支付网关
@Mock
private NotificationService notificationService; // 模拟通知服务
@InjectMocks
private OrderService orderService;
@Test
void testPlaceOrderSuccessfully() {
Order order = new Order("ORD123", 100.0);
// Stubbing: 当 paymentGateway.charge 被调用时，返回 true
when(paymentGateway.charge(order.getAmount())).thenReturn(true);
boolean result = orderService.placeOrder(order);
assertTrue(result);
// Mocking: 验证 paymentGateway.charge 方法是否被调用了一次
verify(paymentGateway, times(1)).charge(order.getAmount());
// Mocking: 验证 notificationService.sendSuccessNotification 方法是否被调用了一次
verify(notificationService, times(1)).sendSuccessNotification(order);
// 验证 notificationService.sendFailureNotification 方法是否从未被调用
verify(notificationService, never()).sendFailureNotification(any(Order.class));
}
@Test
void testPlaceOrderFailure() {
Order order = new Order("ORD124", 200.0);
when(paymentGateway.charge(order.getAmount())).thenReturn(false);
boolean result = orderService.placeOrder(order);
assertFalse(result);
verify(paymentGateway, times(1)).charge(order.getAmount());
verify(notificationService, times(1)).sendFailureNotification(order);
verify(notificationService, never()).sendSuccessNotification(any(Order.class));
}
}
// 假设的服务类和依赖
class Order {
String id;
double amount;
public Order(String id, double amount) { this.id = id; this.amount = amount; }
public double getAmount() { return amount; }
// getters...
}
interface PaymentGateway {
boolean charge(double amount);
}
interface NotificationService {
void sendSuccessNotification(Order order);
void sendFailureNotification(Order order);
}
class OrderService {
private final PaymentGateway paymentGateway;
private final NotificationService notificationService;
public OrderService(PaymentGateway paymentGateway, NotificationService notificationService) {
this.paymentGateway = paymentGateway;
this.notificationService = notificationService;
}
public boolean placeOrder(Order order) {
if (paymentGateway.charge(order.getAmount())) {
notificationService.sendSuccessNotification(order);
return true;
} else {
notificationService.sendFailureNotification(order);
return false;
}
}
}对于数据库依赖，单元测试通常不直接连接真实的数据库。这会让测试变得很慢且不稳定。常用的方法是：
处理时间依赖：如果你的代码依赖于当前时间（比如
new Date()
System.currentTimeMillis()
Clock
java.time.Clock
import java.time.Clock;
import java.time.Instant;
import java.time.ZoneId;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
class TimeDependentService {
private final Clock clock;
public TimeDependentService(Clock clock) {
this.clock = clock;
}
public long getCurrentTimestamp() {
return clock.millis();
}
}
class TimeDependentServiceTest {
@Test
void testGetCurrentTimestamp() {
// 创建一个固定时间的Clock
Clock fixedClock = Clock.fixed(Instant.parse("2023-10-27T10:00:00Z"), ZoneId.of("UTC"));
TimeDependentService service = new TimeDependentService(fixedClock);
long timestamp = service.getCurrentTimestamp();
assertEquals(1698391200000L, timestamp); // 2023-10-27T10:00:00Z 的毫秒时间戳
}
}总的来说，处理复杂场景的核心思想就是“隔离”。通过Mocking、Stubbing、内存数据库或者Testcontainers，我们把被测试的单元从复杂的外部环境中剥离出来，让它在一个可控、可重复、快速的环境中运行，这样才能真正做到“单元”测试。这需要一点设计上的考量，让你的代码更容易被测试，也就是常说的“可测试性”。
以上就是java代码怎样用单元测试验证功能 java代码测试编写的基础教程的详细内容，更多请关注php中文网其它相关文章！
java怎么学习？java怎么入门？java在哪学？java怎么学才快？不用担心，这里为大家提供了java速学教程(入门到精通)，有需要的小伙伴保存下载就能学习啦！
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
151
收藏
