Junit5使用教程(5)

第五部分：JUnit 5 高级特性

1. JUnit 5 测试生命周期

测试生命周期是 JUnit 5 的核心概念之一，它定义了测试类和方法从初始化到清理的完整流程。理解生命周期能帮助开发者合理管理资源、编写高效且可维护的测试代码。

一、生命周期阶段概述

JUnit 5 的测试生命周期分为以下阶段：

1. 测试类初始化
   • 执行 @BeforeAll 方法（仅一次）。
2. 测试方法执行
   • 对每个测试方法依次执行：
     @BeforeEach → @Test（或动态测试） → @AfterEach。
3. 测试类清理
   • 执行 @AfterAll 方法（仅一次）。

二、生命周期注解详解

示例：

import org.junit.jupiter.api.*;

class LifecycleExampleTest {
    
    @BeforeAll
    static void initAll() {
        System.out.println("全局初始化（仅一次）");
    }

    @BeforeEach
    void init() {
        System.out.println("测试初始化（每个测试前执行）");
    }

    @Test
    void test1() {
        System.out.println("执行测试1");
    }

    @Test
    void test2() {
        System.out.println("执行测试2");
    }

    @AfterEach
    void tearDown() {
        System.out.println("测试清理（每个测试后执行）");
    }

    @AfterAll
    static void tearDownAll() {
        System.out.println("全局清理（仅一次）");
    }
}

输出顺序：

全局初始化（仅一次）
测试初始化 → 执行测试1 → 测试清理
测试初始化 → 执行测试2 → 测试清理
全局清理（仅一次）

三、扩展（Extension）对生命周期的影响

JUnit 5 的扩展模型允许通过实现接口干预生命周期，例如：

• BeforeEachCallback：在 @BeforeEach 前执行。
• AfterEachCallback：在 @AfterEach 后执行。
• BeforeAllCallback：在 @BeforeAll 前执行。
• AfterAllCallback：在 @AfterAll 后执行。

示例：自定义扩展记录生命周期事件

import org.junit.jupiter.api.extension.*;

public class LifecycleLoggingExtension implements 
        BeforeAllCallback, BeforeEachCallback,
        AfterEachCallback, AfterAllCallback {

    @Override
    public void beforeAll(ExtensionContext context) {
        System.out.println("扩展：BeforeAllCallback");
    }

    @Override
    public void beforeEach(ExtensionContext context) {
        System.out.println("扩展：BeforeEachCallback");
    }

    @Override
    public void afterEach(ExtensionContext context) {
        System.out.println("扩展：AfterEachCallback");
    }

    @Override
    public void afterAll(ExtensionContext context) {
        System.out.println("扩展：AfterAllCallback");
    }
}

// 注册扩展
@ExtendWith(LifecycleLoggingExtension.class)
class ExtendedLifecycleTest {

    @Test
    void test() {
        System.out.println("执行测试");
    }
}

输出顺序：

扩展：BeforeAllCallback
扩展：BeforeEachCallback → 执行测试 → 扩展：AfterEachCallback
扩展：AfterAllCallback

四、生命周期的执行顺序规则

1. 同类型注解的执行顺序
   JUnit 不保证相同类型注解（如多个 @BeforeEach）的执行顺序，需避免依赖顺序的代码。
2. 扩展与注解的优先级
   • @BeforeAll 前：BeforeAllCallback → @BeforeAll
   • @BeforeEach 前：BeforeEachCallback → @BeforeEach
   • @AfterEach 后：@AfterEach → AfterEachCallback
   • @AfterAll 后：@AfterAll → AfterAllCallback
3. 嵌套测试的生命周期
   嵌套测试类（@Nested）拥有独立生命周期，但可以访问外部类的成员变量。

五、最佳实践

1. 轻量化 @BeforeEach/@AfterEach
   避免在此处执行耗时操作（如文件读写），以提高测试速度。
2. 静态方法的使用场景
   @BeforeAll/@AfterAll 必须声明为 static，适合初始化全局共享资源。
3. 合理使用扩展
   将通用逻辑（如数据库事务管理）封装为扩展，提升代码复用性。
4. 避免状态污染
   确保每个测试方法独立，不依赖其他测试方法的状态。

六、常见问题

1. @BeforeAll 为什么必须是静态方法？
   测试类实例在每个测试方法执行前创建，@BeforeAll 在类加载时执行，需独立于实例存在。
2. 如何控制多个扩展的执行顺序？
   使用 @Order 注解指定扩展的优先级（值越小优先级越高）：

   @Order(1)
   public class ExtensionA implements BeforeEachCallback { ... }
   
   @Order(2)
   public class ExtensionB implements BeforeEachCallback { ... }
   

通过合理利用生命周期注解和扩展，可以构建结构清晰、高效可靠的测试代码，为软件质量保驾护航。

2. JUnit 5 测试执行顺序

JUnit 5 默认以非确定性顺序执行测试方法，以避免测试间的隐式依赖。但在某些场景下（如集成测试的流程验证），需要显式控制测试顺序。本章将介绍如何通过注解和自定义逻辑管理测试执行顺序。

一、默认行为

• 无序执行：默认情况下，JUnit 5 不保证测试方法的执行顺序。
• 设计原则：测试应彼此独立，避免顺序依赖。若必须控制顺序，需谨慎设计。

二、显式指定执行顺序

JUnit 5 提供 @TestMethodOrder 注解，支持以下三种内置排序策略：

三、使用示例

示例 1：按方法名称排序

import org.junit.jupiter.api.*;

@TestMethodOrder(MethodOrderer.MethodName.class)
class OrderedByNameTest {

    @Test
    void betaTest() {
        System.out.println("betaTest");
    }

    @Test
    void alphaTest() {
        System.out.println("alphaTest");
    }
}

输出：

alphaTest → betaTest

示例 2：按 @Order 注解排序

import org.junit.jupiter.api.*;

@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class OrderedByAnnotationTest {

    @Test
    @Order(3)
    void thirdTest() {
        System.out.println("thirdTest");
    }

    @Test
    @Order(1)
    void firstTest() {
        System.out.println("firstTest");
    }

    @Test
    @Order(2)
    void secondTest() {
        System.out.println("secondTest");
    }
}

输出：

firstTest → secondTest → thirdTest

示例 3：按显示名称排序

@TestMethodOrder(MethodOrderer.DisplayName.class)
class OrderedByDisplayNameTest {

    @Test
    @DisplayName("B_Test")
    void testB() {
        System.out.println("B_Test");
    }

    @Test
    @DisplayName("A_Test")
    void testA() {
        System.out.println("A_Test");
    }
}

输出：

A_Test → B_Test

四、自定义排序策略

若内置策略不满足需求，可实现 MethodOrderer 接口自定义排序逻辑。

步骤 1：实现自定义排序器

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.MethodOrdererContext;

public class CustomOrderer implements MethodOrderer {

    @Override
    public void orderMethods(MethodOrdererContext context) {
        // 按方法名的长度升序排序
        context.getMethodDescriptors().sort(
            (m1, m2) -> Integer.compare(
                m1.getMethod().getName().length(),
                m2.getMethod().getName().length()
            )
        );
    }
}

步骤 2：使用自定义排序器

@TestMethodOrder(CustomOrderer.class)
class CustomOrderTest {

    @Test
    void longNameTestMethod() {
        System.out.println("longNameTestMethod");
    }

    @Test
    void shortTest() {
        System.out.println("shortTest");
    }
}

输出：

shortTest → longNameTestMethod

五、注意事项

1. 避免测试依赖
   即使显式指定顺序，测试间仍应保持独立。依赖顺序的测试会增加维护成本。
2. 谨慎使用 @Order
   仅在集成测试或流程测试中合理使用，单元测试应避免。
3. 随机排序的调试
   使用 @TestMethodOrder(Random.class) 时，可通过配置种子复现随机顺序：

   @TestProperty(properties = "junit.jupiter.execution.order.random.seed=12345")
   

六、总结

通过合理使用执行顺序控制，可以在复杂场景中提高测试的可管理性，但仍需遵循测试独立性的核心原则。