Java单元测试怎么写？新手入门指南

还在为Java单元测试发愁？本文以JUnit 5为核心，结合Mockito等工具，深入浅出地讲解了Java单元测试的编写方法和最佳实践。从依赖引入到测试框架选择，再到遵循FIRST原则、运用Given-When-Then模式组织测试逻辑，详细阐述了如何编写高质量、可维护的单元测试。针对外部依赖，提供了内存数据库H2和Testcontainers等解决方案。通过注入Clock接口，稳定处理时间依赖。避免直接测试私有方法，聚焦公共方法，提升代码可读性。掌握这些技巧，让你的Java代码拥有更强的健壮性，告别“改一处崩一片”的噩梦！

使用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里加上：

<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。它是Java世界里单元测试的绝对主力，几乎是标配。目前主流的是JUnit 5（也叫JUnit Jupiter），它比之前的JUnit 4提供了更灵活的扩展模型和更丰富的功能，比如更强大的参数化测试、动态测试等。如果你在启动一个新项目，直接上JUnit 5准没错。

但光有JUnit还不够，很多时候我们的类会有外部依赖，比如它可能需要调用一个数据库服务、一个远程API或者另一个复杂的业务组件。直接在单元测试里去初始化这些依赖，不仅会拖慢测试速度，还会让测试变得不稳定（比如网络波动）。这时候，Mockito就登场了。Mockito是一个强大的Mocking框架，它可以让你创建“假”的对象（mock对象），这些假对象可以模拟真实对象的行为，让你能够隔离被测试的单元，只关注它自身的逻辑。

举个例子，如果你的UserService需要一个UserRepository来获取用户数据，但在测试UserService的createUser方法时，你不想真的去操作数据库，就可以用Mockito来mock一个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单元测试的黄金搭档，这是我的肺腑之言。

编写高质量Java单元测试有哪些核心原则和实践？

写测试，不仅仅是让代码跑起来不报错那么简单，更重要的是要写出“好”的测试。我个人在实践中总结了几点，觉得挺有用的。

一个很重要的原则是FIRST原则：

• Fast (快速)：测试应该运行得非常快。如果你的单元测试跑起来要几分钟甚至几十分钟，那开发者就不愿意频繁运行它们，测试的价值就大打折扣。这意味着要避免真实的IO操作（数据库、网络），用Mocking来替代。
• Independent (独立)：每个测试都应该独立于其他测试。测试的顺序不应该影响结果，一个测试的失败不应该导致其他测试也失败。这要求每个测试方法在执行前都应该有一个干净的环境，并且不留下任何会影响后续测试的副作用。
• Repeatable (可重复)：在任何环境、任何时间运行测试，都应该得到相同的结果。这排除了那些依赖外部不稳定因素（如时间、随机数、网络状态）的测试。
• Self-validating (自我验证)：测试应该能够自动判断通过或失败，不需要人工检查日志或输出。断言就是为此服务的。
• Timely (及时)：在编写生产代码之前或同时编写测试（测试驱动开发TDD），而不是等功能开发完了再补测试。这有助于你更好地设计代码，因为它迫使你从可测试性的角度思考。

在实践中，我发现Given-When-Then模式非常有助于组织测试代码。

• Given (前置条件)：设置测试的初始状态，包括创建对象、配置mock行为等。
• When (执行动作)：调用被测试的方法或执行某个操作。
• Then (结果验证)：验证执行动作后的结果是否符合预期，通过断言来完成。

例如，上面testAdd方法就可以看作是：

• Given: Calculator calculator = new Calculator();
• When: int result = calculator.add(2, 3);
• Then: assertEquals(5, result, "2 + 3 应该等于 5");

此外，测试的粒度也很关键。单元测试应该只关注一个“单元”的逻辑，通常是一个方法。不要在一个单元测试里测试太多东西，那样一旦失败了，你很难快速定位问题。同时，要覆盖所有重要的路径，包括正常路径、边界条件（比如最大值、最小值、空值、空集合）和异常路径。对于那些抛出异常的情况，我们也要有专门的测试来验证异常是否被正确抛出。

最后，一个我常犯的错误（也看到很多人犯）是过度测试私有方法。私有方法是实现细节，它们的服务于公共方法。你应该通过测试公共方法来间接验证私有方法的行为，而不是直接去测试私有方法。如果你发现一个私有方法变得非常复杂，难以通过公共方法来测试，那可能意味着这个私有方法应该被抽取成一个独立的公共方法（或者一个独立的辅助类），这样它就能被直接测试了。

Java单元测试中如何处理外部依赖和复杂场景？

处理外部依赖是单元测试中最让人头疼，但也最能体现水平的地方。毕竟，真实世界的应用很少是完全独立的。

Mocking和Stubbing是核心策略。正如前面提到的Mockito，它能帮助我们模拟那些难以在测试环境中真实运行的外部服务。

• Mocking：当你需要验证一个依赖对象的方法是否被调用了，或者被调用了多少次，以及调用时传入的参数是否正确时，你会用到Mocking。比如，测试一个服务类是否正确地调用了DAO层的保存方法。
• Stubbing：当你需要一个依赖对象在被调用时返回一个特定的值，以便被测试的方法能够继续执行下去时，你会用到Stubbing。比如，模拟一个用户仓库返回一个特定的用户对象。

Mockito的when().thenReturn()就是典型的stubbing，而verify()就是mocking：

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;
        }
    }
}

对于数据库依赖，单元测试通常不直接连接真实的数据库。这会让测试变得很慢且不稳定。常用的方法是：

• 使用内存数据库：比如H2 Database或HSQLDB。它们可以在JVM内部运行，不需要外部安装，测试结束后数据自动清空。这非常适合那些只涉及简单CRUD操作的DAO层测试。
• 使用Testcontainers：这是一个更现代的解决方案，它允许你在Docker容器中启动真实的数据库实例（或者其他任何服务，比如Kafka、Redis）。这样你的测试就运行在一个与生产环境非常接近的真实数据库实例上，但又保持了测试的隔离性和可重复性。虽然它不是严格意义上的“单元”测试，但对于集成测试或需要更真实环境的测试来说，Testcontainers是个非常棒的选择。

处理时间依赖：如果你的代码依赖于当前时间（比如new Date()或System.currentTimeMillis()），这会让测试变得不可重复。你可以通过注入一个Clock接口（Java 8 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单元测试怎么写？新手入门指南》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！