Java 单元测试框架 Junit5 使用全解析 (全网最前沿教程)

junit 5相比junit 4更现代化，具备模块化架构和更强扩展性。1. 使用maven或gradle添加junit jupiter依赖；2. 利用@test、@beforeeach等注解编写测试类；3. 使用@displayname提升可读性；4. 参数化测试支持@valuesource、@csvsource、@methodsource；5. 嵌套测试通过@nested组织测试结构；6. 动态测试（@testfactory）实现运行时生成用例；7. @tag用于标记测试分类以便选择性执行。

JUnit 5，在我看来，它不仅仅是Java单元测试框架的一次版本迭代，更是一次理念上的革新。它彻底改变了我们编写和组织测试的方式，让现代Java项目的测试变得更加灵活、强大和易于维护。如果你还在用JUnit 4，那么是时候升级了，因为JUnit 5带来的体验提升，是实实在在的。

解决方案

要开始使用JUnit 5，首先得把它请进你的项目里。无论是Maven还是Gradle，添加相应的依赖是第一步。我个人更倾向于使用Maven，因为它的配置相对直观一些。

<!-- Maven 配置示例 -->
<dependencies>
    <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>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-params</artifactId>
        <version>5.10.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

搞定依赖，我们就可以开始写第一个JUnit 5测试了。最基础的测试，用@Test注解标记一个方法就行。但JUnit 5的强大之处远不止于此，它提供了更丰富的注解来描述测试的生命周期和意图。

立即学习“Java免费学习笔记（深入）”；

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

@DisplayName("我的第一个JUnit 5测试类")
class CalculatorTest {

    private Calculator calculator; // 假设有一个Calculator类

    @BeforeEach
    void setup() {
        // 每个测试方法执行前都会运行
        calculator = new Calculator();
        System.out.println("准备计算器...");
    }

    @AfterEach
    void teardown() {
        // 每个测试方法执行后都会运行
        calculator = null;
        System.out.println("清理计算器...");
    }

    @Test
    @DisplayName("测试加法操作，确保结果正确")
    void testAddition() {
        assertEquals(5, calculator.add(2, 3), "2加3应该等于5");
        assertNotEquals(6, calculator.add(2, 3), "2加3不应该等于6");
    }

    @Test
    @DisplayName("测试除以零的情况，预期抛出异常")
    void testDivisionByZero() {
        Exception exception = assertThrows(ArithmeticException.class, () ->
            calculator.divide(10, 0)
        );
        assertEquals("/ by zero", exception.getMessage());
    }

    // 假设的Calculator类
    static class Calculator {
        int add(int a, int b) {
            return a + b;
        }
        double divide(int a, int b) {
            if (b == 0) {
                throw new ArithmeticException("/ by zero");
            }
            return (double) a / b;
        }
    }
}

可以看到，@DisplayName让测试方法和类名变得可读性极强，这在测试报告中尤其有用。@BeforeEach和@AfterEach则提供了精细的测试生命周期控制，确保每个测试都在一个干净的环境中运行。断言方面，Assertions类提供了大量静态方法，涵盖了各种判断场景，比如assertEquals、assertThrows等，用起来非常顺手。

为什么选择JUnit 5而不是JUnit 4？它的核心优势在哪里？

说实话，当我第一次接触JUnit 5的时候，最直观的感受就是它变得“现代化”了。JUnit 4虽然经典，但总感觉有些地方显得笨重，特别是它的Runner机制和对Java 8新特性的支持。JUnit 5则完全不同，它从设计之初就考虑到了现代Java的开发范式，比如Lambda表达式、Stream API等。

它最大的优势在于其模块化架构，这被称为JUnit Platform、JUnit Jupiter和JUnit Vintage。

• JUnit Platform 是运行测试的基础，它定义了TestEngine API，允许不同的测试引擎（比如JUnit Jupiter、TestNG等）在其上运行。这意味着你可以在同一个项目中，甚至同一个测试套件中，混合运行不同框架的测试，这在大型项目迁移时简直是救命稻草。
• JUnit Jupiter 是JUnit 5的编程模型和扩展模型的核心，也就是我们平时写测试时用的那些新注解（@Test、@DisplayName、@ParameterizedTest等等）和API。它对Java 8及更高版本提供了原生支持，代码写起来更简洁，更富有表现力。
• JUnit Vintage 则是一个兼容层，允许你在JUnit Platform上运行基于JUnit 3和JUnit 4编写的测试。这对于逐步迁移旧项目来说，简直是福音。

在我看来，JUnit 5最让我惊喜的是它的扩展模型。它彻底取代了JUnit 4中略显僵硬的Runner和Rule。现在，你可以通过实现各种接口（比如ParameterResolver、BeforeEachCallback等）来创建自己的扩展，并通过@ExtendWith注解轻松应用。这使得JUnit 5与Spring、Mockito等其他框架的集成变得异常流畅和自然，不再需要那些复杂的配置或特定的Runner。比如，Spring Boot的测试直接用@ExtendWith(SpringExtension.class)就能搞定，比JUnit 4时代方便太多了。

另外，@DisplayName注解允许你为测试类和方法提供更具描述性的名称，这在生成测试报告时，能让非技术人员也能大致理解测试的意图，这在团队协作中非常重要。我记得以前看JUnit 4的测试报告，一堆驼峰命名的方法名，简直头大。现在，清晰的中文描述，让测试报告也变得“人性化”起来。

What-the-Diff

检查请求差异，自动生成更改描述

下载

JUnit 5 中如何编写高效且可维护的参数化测试和嵌套测试？

参数化测试和嵌套测试是JUnit 5的两大杀手锏，它们能极大提升测试的效率和可维护性。我个人觉得，如果你还没用过这两个特性，那你的JUnit 5就只发挥了它一半的功力。

参数化测试（Parameterized Tests） 我以前在JUnit 4写参数化测试，总感觉有点别扭，需要一个特定的Runner，然后用静态方法返回数据。JUnit 5则把这事儿做得非常优雅。它允许你用不同的数据源来多次运行同一个测试方法，这对于测试那些输入数据多样但逻辑相似的场景特别有用。

常用的数据源注解有：

• @ValueSource: 适用于提供基本类型（String, int, long, double等）的单一参数。
• @CsvSource: 适用于提供多参数的CSV格式数据。
• @MethodSource: 这是最强大的，可以从一个静态方法中获取任意复杂的参数对象。

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;
import static org.junit.jupiter.api.Assertions.*;

import java.util.stream.Stream;

@DisplayName("参数化测试示例")
class ParameterizedTestExample {

    @ParameterizedTest
    @ValueSource(strings = {"racecar", "madam", "anna", "level"})
    @DisplayName("测试回文串检测")
    void testPalindrome(String word) {
        assertTrue(isPalindrome(word), () -> word + " 应该是回文串");
    }

    boolean isPalindrome(String text) {
        String reversedText = new StringBuilder(text).reverse().toString();
        return text.equalsIgnoreCase(reversedText);
    }

    @ParameterizedTest
    @CsvSource({
        "apple, 1, apple",
        "banana, 2, bananabanana",
        "cat, 0, ''" // 注意空字符串表示
    })
    @DisplayName("测试字符串重复拼接")
    void testStringRepeat(String text, int count, String expected) {
        assertEquals(expected, repeatString(text, count));
    }

    String repeatString(String text, int count) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < count; i++) {
            sb.append(text);
        }
        return sb.toString();
    }

    @ParameterizedTest
    @MethodSource("provideNumbersForAddition")
    @DisplayName("使用MethodSource测试加法")
    void testAdditionWithMethodSource(int a, int b, int expectedSum) {
        assertEquals(expectedSum, a + b);
    }

    private static Stream<org.junit.jupiter.params.provider.Arguments> provideNumbersForAddition() {
        return Stream.of(
            org.junit.jupiter.params.provider.Arguments.of(1, 1, 2),
            org.junit.jupiter.params.provider.Arguments.of(5, 3, 8),
            org.junit.jupiter.params.provider.Arguments.of(-1, 1, 0)
        );
    }
}

@MethodSource特别适合当你需要传递自定义对象或者数据源比较复杂的时候。它通过返回一个Stream来提供测试数据，这和Java 8的Stream API结合得天衣无缝。

嵌套测试（Nested Tests）@Nested注解允许你在一个外部测试类中定义内部测试类。这对于组织那些有共同上下文但又需要独立测试场景的测试代码非常有用。比如，你有一个用户管理模块，里面有用户注册、登录、信息修改等功能。每个功能又可能在不同状态下有不同的行为。这时，用嵌套测试来组织，会让你的测试结构清晰得像一本目录分明的书。

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

@DisplayName("用户管理模块测试")
class UserManagerTest {

    private UserManager userManager; // 假设有一个UserManager类

    @BeforeEach
    void setup() {
        userManager = new UserManager();
        System.out.println("初始化用户管理器...");
    }

    @Nested
    @DisplayName("当用户未注册时")
    class WhenUserNotRegistered {

        @Test
        @DisplayName("应该能够成功注册新用户")
        void shouldRegisterNewUser() {
            assertTrue(userManager.register("newUser", "password123"));
            assertTrue(userManager.isUserRegistered("newUser"));
        }

        @Test
        @DisplayName("尝试登录应该失败")
        void loginShouldFail() {
            assertFalse(userManager.login("nonExistent", "password"));
        }
    }

    @Nested
    @DisplayName("当用户已注册并登录时")
    class WhenUserRegisteredAndLoggedIn {

        @BeforeEach
        void setupLoggedInUser() {
            userManager.register("existingUser", "password123");
            userManager.login("existingUser", "password123");
            System.out.println("用户 'existingUser' 已注册并登录。");
        }

        @Test
        @DisplayName("应该能够修改密码")
        void shouldChangePassword() {
            assertTrue(userManager.changePassword("existingUser", "password123", "newPassword"));
            assertTrue(userManager.login("existingUser", "newPassword"));
        }

        @Test
        @DisplayName("不正确的旧密码无法修改密码")
        void shouldNotChangePasswordWithWrongOldPassword() {
            assertFalse(userManager.changePassword("existingUser", "wrongPassword", "newPassword"));
        }
    }

    // 假设的UserManager类
    static class UserManager {
        private boolean registered = false;
        private boolean loggedIn = false;
        private String username = "";
        private String password = "";

        boolean register(String username, String password) {
            if (!registered) {
                this.username = username;
                this.password = password;
                registered = true;
                return true;
            }
            return false;
        }

        boolean isUserRegistered(String username) {
            return registered && this.username.equals(username);
        }

        boolean login(String username, String password) {
            if (registered && this.username.equals(username) && this.password.equals(password)) {
                loggedIn = true;
                return true;
            }
            return false;
        }

        boolean changePassword(String username, String oldPassword, String newPassword) {
            if (loggedIn && this.username.equals(username) && this.password.equals(oldPassword)) {
                this.password = newPassword;
                return true;
            }
            return false;
        }
    }
}

嵌套测试的好处在于，内部类可以有自己的@BeforeEach和@AfterEach方法，它们只作用于该内部类及其子内部类的测试方法。这使得每个测试上下文的设置和清理都变得非常精确和局部化，避免了不必要的全局状态干扰。在我看来，这对于编写高内聚、低耦合的测试代码至关重要。

除了基本用法，JUnit 5 还有哪些高级特性可以提升测试效率和质量？

JUnit 5的魅力远不止于此，它的一些高级特性，用好了能让你的测试工作事半功倍，甚至解决一些传统测试框架难以处理的问题。

1. 动态测试（Dynamic Tests）@TestFactory注解是一个非常有趣且强大的特性。它允许你在运行时动态生成测试用例，而不是在编译时就固定下来。这意味着你可以从外部数据源（比如数据库、文件、API响应）读取数据，然后为每一条数据生成一个独立的测试。这在处理大量相似但又无法用参数化测试简单覆盖的场景时，简直是神器。

import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.TestFactory;
import static org.junit.jupiter.api.Assertions.*;

import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.stream.Stream;

@DisplayName("动态测试示例")
class DynamicTestExample {

    @TestFactory
    @DisplayName("测试字符串长度，数据来自列表")
    Collection<DynamicTest> testStringLengthsFromList() {
        return Arrays.asList(
            DynamicTest.dynamicTest("检查 'apple' 长度为 5", () -> assertEquals(5, "apple".length())),
            DynamicTest.dynamicTest("检查 'banana' 长度为 6", () -> assertEquals(6, "banana".length())),
            DynamicTest.dynamicTest("检查 'cat' 长度为 3", () -> assertEquals(3, "cat".length()))
        );
    }

    @TestFactory
    @DisplayName("测试数字平方，数据来自流")
    Stream<DynamicTest> testSquareNumbersFromStream() {
        return Stream.of(1, 2, 3, 4)
            .map(input -> DynamicTest.dynamicTest("测试 " + input + " 的平方",
                () -> assertEquals(input * input, new Calculator().square(input))
            ));
    }

    // 假设的Calculator类
    static class Calculator {
        int square(int num) {
            return num * num;
        }
    }
}

@TestFactory方法必须返回Collection<dynamictest></dynamictest>、Stream<dynamictest></dynamictest>或Iterator<dynamictest></dynamictest>。每个DynamicTest实例都包含一个显示名称和一个可执行的Executable（通常是一个lambda表达式）。

2. 测试标签（Tagging Tests）@Tag注解允许你为测试类或测试方法打上标签。这在大型项目中非常实用，你可以根据标签来选择性地运行或排除某些测试。比如，你可以标记一些测试为"slow"（慢速测试），"integration"（集成测试），或者"UI"（UI测试）。在CI/CD管道中，你可以配置只运行"fast"标签的测试，而将"slow"测试放到夜间构建中运行。

import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class TaggedTests {

    @Test
    @Tag("fast")
    @DisplayName("一个快速的单元测试")
    void fastTest() {
        assertTrue(true);
    }

    @Test
    @Tag("slow")
    @Tag("integration")
    @DisplayName("一个耗时的集成测试")
    void slowIntegrationTest() throws InterruptedException {
        Thread.sleep(100); // 模拟耗时操作
        assertTrue(true);
    }

    @Test
    @Tag("UI")
    @DisplayName("一个UI相关的测试")
    void uiTest() {
        assertFalse(false);
    }
}