JUnit 4 与 JUnit 5
有什么不同?
从架构、注解、断言到新特性,
用同一组测试,一次讲清楚。
≡讲稿第 1 页 · 教师提示
- 承接前两部分的安装与基础语法:这节课比较 JUnit 4 和 5。教材与老项目常见 4,新项目常见 5。
- 今天用同一组真实测试,对比架构、写法、组织能力,再讲迁移与 JUnit 6。
- 课前确认 Maven 依赖已下载。五个主演示共享同一个项目,时间紧时保留第 5、15、16 页。
今天讲这七件事
先理解架构,再比较写法,最后回到真实项目。
≡讲稿第 2 页 · 教师提示
- 七部分按“为什么改变 → 架构 → 写法 → 表达能力 → 迁移”展开。
- 架构是最本质的区别,代码变化要联系这个基础来理解。
- 五个主演示位于第 10、13、16、17、19 页,可以点页码直接跳转。
四代演进:从 JUnit 3 到 JUnit 6
每一代都在改变“怎样发现、编写与运行测试”。
JUnit 3
继承 TestCase
方法名以 test 开头
JUnit 4
引入 @Test 注解
不再强制继承父类
JUnit 5
重新设计,模块化
支持 Lambda 表达
JUnit 6
延续 Jupiter 写法
提高运行环境要求
≡讲稿第 3 页 · 教师提示
- JUnit 3 靠继承 TestCase 和 test 前缀识别测试;JUnit 4 借助 Java 5 的注解摆脱父类约束。
- JUnit 5 于 2017 年重做架构、要求 Java 8;JUnit 6 于 2025 年发布、要求 Java 17,常用 Jupiter 写法延续。
- 比较固定版本 4.13.2 与 5.14.4:后期 JUnit 4 也补了一些能力,不能把它们说成 5 独有。
为什么需要重新设计?
功能能够实现,组合与表达却越来越费力。
平台接口边界不清
IDE、构建工具依赖内部结构,框架一改,周边工具就可能受到影响。
Runner 难以组合
一个测试类只能有一个 @RunWith,Spring 与参数化 Runner 不能直接叠加。
早期模型的约束
核心模型来自 Java 5 时代,后来不断补功能,整体扩展仍受原设计限制。
复杂测试表达成本高
分组检查、参数化等能够实现,但常要借助额外 Rule 或 Runner。
≡讲稿第 4 页 · 教师提示
- API 与内部实现边界不清,IDE 和构建工具依赖内部结构,框架演进会牵动周边工具。
- 一个类只能有一个 @RunWith;Spring Runner 和参数化 Runner 不能直接叠加。Rule 可以多个。
- JUnit 4 能做参数化与汇总检查,只是额外 Runner / Rule 增加表达成本。2015 年 JUnit Lambda 众筹启动重设计。
JUnit 5 = Platform + Jupiter + Vintage
从上往下看:入口启动平台,平台调用测试引擎。
编写与运行能力
集中在同一个核心依赖
JUnit Platform
Launcher API + TestEngine SPI
Jupiter Engine
运行 JUnit 5 测试
Vintage Engine
运行 JUnit 3 / 4 测试
≡讲稿第 5 页 · 教师提示
- 这一页是全场重点。先看 JUnit 4:一个 junit:junit 核心依赖提供测试 API、Runner、Rule。
- 按箭头往下讲:IDE / 构建工具调用 Launcher API;Platform 发现测试,并通过 TestEngine SPI 调用注册的引擎。
- Jupiter 跑 JUnit 5 测试,Vintage 跑 JUnit 3 / 4 老测试,所以两代测试能共存。
- 我们说的“JUnit 5 写法”通常指 Jupiter。全新的 Jupiter 项目不必安装 Vintage。
三个模块,各管什么?
Java 包名用于 import,Maven Artifact ID 用于依赖声明。
Platform
启动与引擎接口Launcher / TestEngine
Jupiter
编写新测试的 API
及运行新测试的引擎
Vintage
兼容旧测试
让 JUnit 3 / 4 在新平台运行
| 模块 | Java 包名 · 写在 import | Maven Artifact ID · 写在 pom |
|---|---|---|
| Platform | org.junit.platform.* | junit-platform-launcher |
| Jupiter API | org.junit.jupiter.api | junit-jupiter-api |
| Jupiter Engine | org.junit.jupiter.engine | junit-jupiter-engine |
| Vintage | org.junit.vintage.engine | junit-vintage-engine |
≡讲稿第 6 页 · 教师提示
- Platform 定义启动与引擎接口;Jupiter 提供编写测试的 API 和执行引擎;Vintage 负责旧测试兼容。
- 务必区分表里的 Java 包名(import)和 Maven Artifact ID(pom.xml),它们不是同一件事。
- 用插座与插头的比喻帮助记忆:Platform 是插座,Jupiter、Vintage 是可插入的引擎。
架构如何体现在 Maven 里?
对比固定版本;演示项目另外带上 Vintage 兼容旧测试。
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>5.14.4</version>
<scope>test</scope>
</dependency>
演示项目的实际配置:BOM + Jupiter + Vintage
上方是独立依赖的标准写法。真实 pom.xml 用 org.junit:junit-bom:5.14.4 管理版本,Jupiter / Vintage 依赖继承它,所以没有单独写 version。
≡讲稿第 7 页 · 教师提示
- JUnit 4 坐标的 groupId 和 artifactId 都是 junit;JUnit 5 使用 org.junit.jupiter:junit-jupiter。
- junit-jupiter 是聚合包,包含 api、params、engine。演示项目用 BOM 统一版本,因此子依赖不再逐个写 version。
- Surefire 从 2.22.0 起原生支持 Platform;演示项目固定 3.2.5,新项目建议使用 3.x。
先看几个“表面”变化
版本变了,导入、修饰符与参数规则也要一起核对。
| 对比项 | JUnit 4 | JUnit 5 |
|---|---|---|
| 包名 | org.junit | org.junit.jupiter.api |
| 断言类 | org.junit.Assert | org.junit.jupiter.api.Assertions |
| 最低 Java | Java 5 | Java 8 |
| 类与方法修饰符 | 标准测试类、方法必须 public | 可省略 public,不能 private |
| 测试方法参数 | 标准方法不支持参数注入 | ParameterResolver 注入;内置 TestInfo / TestReporter |
| @Test 属性 | expected / timeout | 属性消失;改用 assertThrows / @Timeout |
≡讲稿第 8 页 · 教师提示
- 先核对 import:org.junit 与 org.junit.jupiter.api 是不同的 API;Assert 变成 Assertions。
- JUnit 5 可省略 public,但测试类和方法不能是 private。
- TestInfo / TestReporter 可由内置 ParameterResolver 注入;任意自定义参数仍要对应的解析器。
- @Test 的 expected / timeout 不再放在注解属性里,后面用 assertThrows 与 @Timeout 单独讲。
生命周期与注解对照
Each / All 更直白;扩展那一行是真正的模型变化。
| 对比项 | JUnit 4 | JUnit 5 |
|---|---|---|
| 标记测试方法 | @Test | @Test(换包) |
| 每个测试之前 | @Before | @BeforeEach |
| 每个测试之后 | @After | @AfterEach |
| 所有测试之前一次 | @BeforeClass | @BeforeAll |
| 所有测试之后一次 | @AfterClass | @AfterAll |
| 跳过测试 | @Ignore | @Disabled |
| 分组 / 分类 | @Category | @Tag |
| 扩展 | @RunWith / @Rule | @ExtendWith · 模型改变 |
≡讲稿第 9 页 · 教师提示
- Each 是每个测试之前 / 之后,All 是全部测试之前 / 之后,名字更直白。
- @BeforeAll / @AfterAll 默认仍必须 static;PER_CLASS 生命周期是例外。
- @RunWith / @Rule 到 @ExtendWith 是模型变化,不能简单换名字,留到第 21 页展开。
同一个测试,两种写法
都是验证 1 + 2 = 3。看三处差异,再分别运行。
import demo.Calculator;
import org.junit.*;
import static org.junit.Assert.*;
public class Calc4Test {
Calculator calc;
@Before public void init() {
calc = new Calculator();
}
@Test public void add() {
assertEquals(3, calc.add(1, 2));
}
}
import demo.Calculator;
import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.*;
class Calc5Test {
Calculator calc;
@BeforeEach void init() {
calc = new Calculator();
}
@Test void add() {
assertEquals(3, calc.add(1, 2));
}
}
new Calculator() 的实例方法。≡讲稿第 10 页 · 教师提示
- 对比相同加法测试,只看三处:import、public、@Before → @BeforeEach。断言这一行外观相同,来自不同 API。
- 分别点运行 Calc4Test 与 Calc5Test,看两边都通过。真实类使用 calc = new Calculator(),加法是实例方法。
- 共存的路径是 Platform 调用 Jupiter Engine / Vintage Engine。类名不同只是为了在同一项目中并存。
六个新注解,先认个脸
六个名字,对应后面几个可实际操作的例子。
@DisplayName给测试起可读名字,支持中文
第 17 页 ↗@Nested用非静态内部类给测试分组
第 17 页 ↗@ParameterizedTest一个方法,运行多组数据
第 19 页 ↗@RepeatedTest同一个测试,依次重复 N 次
第 20 页 ↗@Timeout超出规定时间则判定失败
第 14 页 ↗@TestFactory在运行时动态生成测试
第 20 页 ↗@ParameterizedTest 位于 org.junit.jupiter.params,由 junit-jupiter-params 提供;聚合包已包含它。≡讲稿第 11 页 · 教师提示
- 这一页是后续路线图,先认名字,不展开细节。@Timeout 在第 14 页,其余在第 17–20 页。
- @ParameterizedTest 属于单独的 params 模块,而不是 org.junit.jupiter.api;junit-jupiter 聚合包已带上它。
- 时间紧时可以快速带过这一页。
提示信息:从第一个到最后一个
名字看起来没变,三个参数的含义却可能已经变了。
assertEquals("加法结果错误", 3, calc.add(1, 2));
assertTrue("应该是正数", result > 0);
assertEquals(3, calc.add(1, 2), "加法结果错误");
// 失败时才拼接消息
assertTrue(result > 0, () -> "结果是 " + result);
assertEquals("提示", "A", actual) 只改 import 仍能编译,但在 JUnit 5 中“提示”成为 expected,“A”成为 actual,原 actual 成为消息。正确改成 assertEquals("A", actual, "提示")。本页是讲稿中的断言片段,calc 为 Calculator 实例;完整加法测试见第 10 页。
≡讲稿第 12 页 · 教师提示
- JUnit 4 把失败提示放在第一个参数,JUnit 5 放在最后一个参数。
- JUnit 5 可以传消息 Supplier:只有失败时才计算字符串,避免通过时白白拼接。
- 重点看三字符串迁移:assertEquals("提示", "A", actual) 只改 import 仍能编译,但“提示”被当作 expected。
assertAll:一次看到所有失败
改错两项期望,比较“遇错即停”和“统一报告”。
实际对象:new Person("张", "三")
浏览器模拟普通断言 · 遇错即停
assertEquals(EXPECTED_FIRST, p.getFirst());
assertEquals(EXPECTED_LAST, p.getLast());
assertAll · 全部检查
assertAll("姓名",
() -> assertEquals(EXPECTED_FIRST, p.getFirst()),
() -> assertEquals(EXPECTED_LAST, p.getLast())
);
Failures: 1,同时单独列出 Failed checks: 2。JUnit 4 也能汇总:ErrorCollector Rule(4.7 起)
先声明 @Rule ErrorCollector,再使用 checkThat。两项都错时,同样收集两个失败。
@Rule
public ErrorCollector collector = new ErrorCollector();
@Test
public void person() {
Person p = new Person("张", "三");
collector.checkThat(p.getFirst(), equalTo(EXPECTED_FIRST));
collector.checkThat(p.getLast(), equalTo(EXPECTED_LAST));
}
}
≡讲稿第 13 页 · 教师提示
- 先问:连续两个普通断言,第一个失败后第二个还会执行吗?不会,失败抛出错误,方法随即中断。
- 先用默认“张 / 三”运行通过,再把两项改成“李 / 四”,分别运行普通断言和 assertAll,看一个失败检查与两个失败检查。
- assertAll 执行独立检查,最后统一报告 MultipleFailuresError;失败检查虽有 2 个,失败的测试方法仍是 1 个。
- JUnit 4 从 4.7 起可用 ErrorCollector Rule 汇总错误。演示后点重置,恢复正确期望值。
超时与假设:两个容易踩的细节
迁移数字要换算;前提不满足,也不代表测试失败。
01 · 超时单位换算
可编辑@Timeout(1000) 默认是 1000 秒。若毫秒值不能整除 1000,用显式毫秒单位保留精度。02 · 前提条件不成立
浏览器模拟查看真实 TimeoutAssumptionTest 与两种假设写法
@Test
@Timeout(1) // 1 秒
void finishesWithinOneSecond() throws InterruptedException {
Thread.sleep(100);
}
@Test
@Timeout(value = 1000, unit = TimeUnit.MILLISECONDS) // 想写毫秒就显式指定单位
void finishesWithinOneThousandMillis() throws InterruptedException {
Thread.sleep(100);
}
@Test
void onlyOnCi() {
assumeTrue("CI".equals(System.getenv("ENV")));
assertTrue(true);
}
@Test
void partly() {
assumingThat(isWindows(), () -> {
System.out.println("只在 Windows 上执行这一段");
});
System.out.println("无论条件是否成立,这里都会继续执行");
}
private static boolean isWindows() {
return System.getProperty("os.name").startsWith("Windows");
}
}
Assume.assumeTrue(),没有 assumingThat()。跳过一个代码块,不等于跳过整个测试。≡讲稿第 14 页 · 教师提示
- 先强调单位:JUnit 4 的 1000 是毫秒,JUnit 5 @Timeout 默认是秒,直接搬数字会扩大 1000 倍。
- 正确写 @Timeout(1),或显式 TimeUnit.MILLISECONDS;不能整除 1000 的值用显式毫秒单位保留精度。
- 本机 ENV 不是 CI:onlyOnCi 会 aborted / 跳过,不是失败。assumingThat 只跳过一段 Lambda,后面的代码继续。
- JUnit 4 有 Assume.assumeTrue,但没有 assumingThat。
JUnit 4 的传统异常测试
expected 覆盖整方法;Rule 要先声明预期。
@Test(expected = ArithmeticException.class)
public void divideWithExpected() {
calc.divide(1, 0);
}
覆盖整个方法
任何一行抛出指定异常都满足要求;无法精确锁定一行,也拿不到异常对象。
@SuppressWarnings("deprecation")
@Rule
public ExpectedException thrown = ExpectedException.none();
@Test
public void divideWithRule() {
thrown.expect(ArithmeticException.class);
thrown.expectMessage("/ by zero");
calc.divide(1, 0);
}
先声明预期,再抛错
能查类型、消息和原因;要额外声明 Rule,expect 必须放在抛错代码之前。
真实 Exception4Test 的两个测试都应通过;除以 0 的消息是 "/ by zero"。
≡讲稿第 15 页 · 教师提示
- expected 属性覆盖整个方法,任何一行抛出指定异常都能满足要求;拿不到异常对象去检查消息。
- ExpectedException Rule 可检查类型、消息、原因;expect 必须写在抛错代码之前。
- 演示项目中两个传统测试都通过。ExpectedException.none() 自 4.13 起弃用,官方推荐 assertThrows,引出下一页。
异常类型:允许子类,还是完全一致?
先猜两个父类断言,再运行真实项目所对应的四个测试。
Integer.parseInt("abc")assertThrows(IllegalArgumentException.class,
() -> Integer.parseInt("abc"));
assertThrowsExactly(IllegalArgumentException.class,
() -> Integer.parseInt("abc"));
先纠错:JUnit 4.13 已有 assertThrows,查看两版真实代码
assertThrows 只检查 Lambda,并返回异常对象继续检查;核心用法相同,主要差异在 import。
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThrows;
NumberFormatException e = assertThrows(
NumberFormatException.class,
() -> Integer.parseInt("abc"));
assertEquals("For input string: \"abc\"", e.getMessage());
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
NumberFormatException e = assertThrows(
NumberFormatException.class,
() -> Integer.parseInt("abc"));
assertEquals("For input string: \"abc\"", e.getMessage());
@Tag("fail-demo") 在 mvn test 中被排除;IDEA 单跑整个类可看到它的红色报告。≡讲稿第 16 页 · 教师提示
- 先纠错:JUnit 4.13 就有 assertThrows,核心用法几乎相同,只差 import。它只检查 Lambda 并返回异常对象。
- 让学生分别预测父类版本的两个断言。parseInt("abc") 抛出 NumberFormatException,是 IllegalArgumentException 子类。
- 运行 AssertThrows5Test 整个类:3 个通过、1 个故意失败。assertThrows 允许子类,assertThrowsExactly 要求完全一致。
- assertThrowsExactly 从 5.8 起提供。exactlyParentType_fails 带 fail-demo 标签,mvn test 排除它,IDEA 单跑仍红。
测试报告,也可以像目录一样
@DisplayName 决定名字,@Nested 决定层次。
@DisplayName("计算器测试")
class CalculatorNestedTest {
Calculator calc;
@BeforeEach
void init() {
calc = new Calculator(); // 外部类的 @BeforeEach 对嵌套类里的测试同样生效
}
@Nested
@DisplayName("加法")
class Add {
@Test
@DisplayName("1 + 2 = 3")
void simple() {
assertEquals(3, calc.add(1, 2)); // 非静态内部类,可以直接用外部类的字段
}
}
@Nested
@DisplayName("除法")
class Divide {
@Test
@DisplayName("除以 0 抛异常")
void byZero() {
assertThrows(ArithmeticException.class, () -> calc.divide(1, 0));
}
}
}
测试结果树
浏览器模拟运行后展开测试树。
节点名称来自 @DisplayName。
非静态内部类直接使用外层 calc。
外层 @BeforeEach 对嵌套测试生效。
@RunWith(Enclosed.class) 组织静态内部类,但占用唯一 Runner;JUnit 5 原生支持 @Nested + @DisplayName。≡讲稿第 17 页 · 教师提示
- 名字来自 @DisplayName,层次来自 @Nested。运行后展开“计算器测试 → 加法 / 除法 → 具体测试”。
- 非静态内部类可以直接访问外层 calc;外层 @BeforeEach 对嵌套测试也生效。
- JUnit 4 也能用 Enclosed Runner 组织静态内部类,但会占用唯一 Runner,且没有原生 DisplayName。
JUnit 4 完全支持参数化
三组数据都能跑,成本在类级 Runner、数据方法和构造函数。
@RunWith(Parameterized.class)
public class AddParameterized4Test {
@Parameters(name = "{0} + {1} = {2}")
public static Collection<Object[]> data() {
return Arrays.asList(new Object[][] {
{1, 1, 2}, {2, 3, 5}, {-1, 1, 0}
});
}
private final int a, b, expected;
public AddParameterized4Test(int a, int b, int expected) {
this.a = a; this.b = b; this.expected = expected;
}
@Test public void add() {
assertEquals(expected, new Calculator().add(a, b));
}
}
JUnit 4 完全支持参数化,代价在写法。
类级别 Runner
@RunWith(Parameterized.class) 占用唯一 Runner。
静态数据方法
@Parameters 返回每一组数据。
字段 + 构造函数
通过构造函数把 a、b、expected 传进实例。
整类绑定同一套数据
类里的每个测试方法使用同一套参数。
new Calculator().add(a, b)。看看 JUnit 5 的 5 行写法 →≡讲稿第 18 页 · 教师提示
- 先明确:JUnit 4 完全支持参数化。三组数据各创建实例、各跑一遍。
- 成本来自类级 Parameterized Runner、静态数据方法、字段与构造函数,以及全类共用一套数据。
- 17 行是讲稿的教学排版口径,不计 import;这里重排空白展示真实项目代码,Calculator 调用保持实例方法。
JUnit 5 参数化:17 行 → 5 行
更关键的变化:不同方法可以使用各自的数据。
行代码 · 不计 import
从类级数据,到方法级数据
@RunWith(Parameterized.class)
public class AddParameterized4Test {
@Parameters(name = "{0} + {1} = {2}")
public static Collection<Object[]> data() {
return Arrays.asList(new Object[][] {
{1, 1, 2}, {2, 3, 5}, {-1, 1, 0}
});
}
private final int a, b, expected;
public AddParameterized4Test(int a, int b, int expected) {
this.a = a; this.b = b; this.expected = expected;
}
@Test public void add() {
assertEquals(expected, new Calculator().add(a, b));
}
}
@ParameterizedTest(name = "{0} + {1} = {2}")
@CsvSource({"1, 1, 2", "2, 3, 5", "-1, 1, 0"})
void add(int a, int b, int expected) {
assertEquals(expected, new Calculator().add(a, b));
}
@CsvSource · 逐组运行 add
| # | a | b | expected | actual | 结果 |
|---|
@ValueSource 单参数@CsvSource 多参数@CsvFileSource CSV 文件@MethodSource 方法数据@EnumSource 枚举同一类,不同方法各用各的数据:真实文件还包含平方测试
squareIsNonNegative 使用 @ValueSource(ints = {-3, 0, 4}),与 add 的 CsvSource 独立。IDEA 运行 AddParameterized5Test 整类会得到 6 条结果;本互动只演示 add。输入按 Java int 处理,溢出时期望值也按 32 位整数计算。
≡讲稿第 19 页 · 教师提示
- JUnit 5 把参数化放到方法:@ParameterizedTest + @CsvSource + 参数列表,教学示例缩成 5 行。
- 逐条运行三组 add 数据,再让学生提供 a、b,追加一组并自动计算期望。不要把 Calculator 写成静态调用。
- 同类不同方法各用各的数据;原文件还有 @ValueSource 的三组平方检查,整类运行共 6 条。
- 单参数 ValueSource,多参数 CsvSource,文件 CsvFileSource,复杂对象 MethodSource,枚举 EnumSource。
重复、动态、标签与禁用
四种组织能力,点一下看看测试报告有什么不同。
@RepeatedTest(5)
依次重复 5 次,不会自动并发。
@RepeatedTest(5)
void randomId() {
assertNotNull(UUID.randomUUID().toString());
}
@TestFactory
运行时生成平方 1、2、3 三个测试。
@TestFactory
Stream<DynamicTest> squares() {
return Stream.of(1, 2, 3)
.map(n -> dynamicTest("平方 " + n,
() -> assertEquals(n * n, calc.square(n))));
}
@Tag("fast")
分类筛选:mvn test -Dgroups=fast。
@Test
@Tag("fast")
void quick() {
assertEquals(4, calc.add(2, 2));
}
@Disabled
写明禁用原因,不执行测试主体。
@Test
@Disabled("等待修复 #12")
void broken() {
assertEquals(5, calc.add(2, 2));
}
≡讲稿第 20 页 · 教师提示
- RepeatedTest(5) 是依次重复,不会自动成为并发;观察报告按 1 到 5 依次出现。
- TestFactory 在运行时生成测试,平方例子对 1、2、3 生成 3 个动态节点。
- Tag("fast") 可用 mvn test -Dgroups=fast 筛选;对应 JUnit 4 Category。
- Disabled 应写清原因。本例等待修复 #12,所以跳过,不执行会失败的断言。
扩展模型:从 Runner + Rule 到 Extension
Runner 只能一个,Rule 可以多个;Extension 可以叠加。
// JUnit 4:一个 Runner,可有多个 Rule
@RunWith(SpringRunner.class)
public class UserServiceTest {
@Rule
public TemporaryFolder tmp = new TemporaryFolder();
}
// JUnit 5:扩展可以叠加
@ExtendWith(SpringExtension.class)
@ExtendWith(MockitoExtension.class)
class UserServiceTest {
@TempDir
Path tmp;
}
@TempDir 可替代 TemporaryFolder 的常见用途。自定义 Runner / Rule 需按行为重写,不是逐个改名。Spring / Mockito 片段来自 PPT 讲解示意,不属于演示项目;实际使用时需要对应依赖与 import。
≡讲稿第 21 页 · 教师提示
- JUnit 4 有 Runner 与 Rule 两套机制,Runner 只能一个,Rule 可以多个。
- JUnit 5 用 @ExtendWith 注册 Extension,可以叠加 SpringExtension、MockitoExtension。@TempDir 是临时目录的现成替代。
- 不能把 Rule 与 Extension 看作一一对应。自定义 Runner / Rule 要按它实际的行为重写,迁移工具也需复查。
老项目,分六步渐进迁移
让测试先共存,再逐类迁移,最后移除兼容引擎。
引入 Jupiter + Vintage
先让新旧测试在 Platform 上共存。
新测试全部用 Jupiter
从现在起,新增测试用 JUnit 5 写法。
逐类替换 import
org.junit → org.junit.jupiter.api。
改注解,核对超时单位
Before → BeforeEach;毫秒要换算为秒。
改断言与异常测试
提示挪到最后;expected / ExpectedException 改 assertThrows。
重写扩展,移除 Vintage
Runner / Rule 按行为改成 Extension;全迁完才移除兼容引擎。
≡讲稿第 22 页 · 教师提示
- 先引入 Jupiter + Vintage 让新旧共存;随后新测试用 Jupiter,逐类迁移 import。
- 再改生命周期与禁用注解,核对 timeout 单位;改断言提示顺序,expected / ExpectedException 改 assertThrows。
- 最后重写 Runner / Rule 为 Extension,全迁完才移除 Vintage。
- IDEA / OpenRewrite 可辅助,每轮都要审查差异、重新运行全部测试,并核对测试数量有没有减少。
构建成功,也可能漏跑测试
每次迁移,除了结果,还要核对 Tests run 数量。
import 混用,测试没被发现
导入了 org.junit.Test,但项目只有 Jupiter、没有 Vintage:测试可能漏跑,构建依然成功。检查 Tests run 数量。
Surefire 太旧
< 2.22.0 不原生支持 Platform,可能漏跑或显示 Tests run: 0。建议 3.x。
提示信息没有移位
三字符串断言仍能编译,但消息被当成 expected。迁移 import 后也要复查参数顺序。
@BeforeAll 忘了 static
默认必须静态;或显式使用 @TestInstance(PER_CLASS) 生命周期。
≡讲稿第 23 页 · 教师提示
- 最隐蔽的是混用 import:只有 Jupiter,没有 Vintage,却导入 org.junit.Test;旧测试不被发现,构建仍可能成功。
- 不能只看 BUILD SUCCESS,要看 Tests run 数量,特别是 0 或比以前少。Surefire < 2.22.0 也可能漏跑。
- 三字符串提示信息位置没改仍会编译;@BeforeAll 默认必须 static,或改用 @TestInstance(PER_CLASS)。
彩蛋:JUnit 6 已经来了
提高 Java 要求,统一模块版本,继续使用 Jupiter 写法。
| 6.0.0 发布 | 2025-09-30 |
|---|---|
| 最新正式版 | 6.1.3 · 2026-08-07 |
| 最低 Java | Java 17(JUnit 5 是 Java 8) |
| 模块版本号 | Platform、Jupiter、Vintage 统一版本号 |
| Vintage | 已弃用;仅在迁移期间临时使用 弃用 ≠ 删除 |
来源:JUnit 官方 Release Notes · docs.junit.org ↗。本课演示依赖仍固定 4.13.2 / 5.14.4。
≡讲稿第 24 页 · 教师提示
- 按素材的版本快照:6.0.0 在 2025-09-30 发布,6.1.3 在 2026-08-07 发布;本课程比较仍固定在 4.13.2 / 5.14.4。
- JUnit 6 最低 Java 17,Platform / Jupiter / Vintage 统一版本号,常见 Jupiter 写法延续。
- Vintage 已弃用,定位为迁移期间临时使用;弃用不等于删除。升级仍应核对 Java 与已移除的 API。
一张表,记住所有区别
区分局部调整与模型改变,避免记成“只改了名字”。
| 对比项 | JUnit 4 | JUnit 5 |
|---|---|---|
| 架构 | 单个核心依赖 junit:junit | Platform + Jupiter + Vintage |
| Java 版本 | Java 5 及以上 | Java 8 及以上 |
| 生命周期注解 | @Before / @BeforeClass | @BeforeEach / @BeforeAll |
| 断言提示信息 | 第一个参数 | 最后一个参数,可用 Lambda |
| 分组断言 | ErrorCollector Rule | 内置 assertAll |
| 超时 | @Test(timeout = …),毫秒 | @Timeout,默认秒 |
| 异常测试 | expected / ExpectedException; 4.13 起有 assertThrows | assertThrows,另有 assertThrowsExactly |
| 参数化测试 | Parameterized Runner(占用类的 Runner) | @ParameterizedTest(作用在方法上) |
| 嵌套测试 | Enclosed Runner | 原生 @Nested + @DisplayName |
| 扩展机制 | Runner + Rule(只能一个 Runner) | Extension(可叠加) |
注解改名 · 提示信息移位
模块化架构 · 类级 → 方法级参数化 · Extension
≡讲稿第 25 页 · 教师提示
- 回到第一行:模块化架构是其他变化的基础。十行总结不要只背注解名字。
- 问学生:哪些只是改名?生命周期与消息位置是局部调整;参数化从类级到方法级、扩展模型统一是真正模型变化。
- 再纠正三句话:4.13 已有 assertThrows;JUnit 4 完全支持参数化;Vintage 用于迁移,新项目不必装。
四道题,检查一下理解
四个问题,回到最容易混淆的细节。
先选答案,再点击「揭晓」。也可以直接揭晓,计入已答题数。
JUnit 5 用什么注解替代 @Before?
assertEquals(3, add(1, 2), "错误") 是哪个版本?
@Test(timeout = 1000) 迁成 @Timeout(1000),对吗?
要求异常类型完全一致,不接受子类,用哪个断言?
题干中的 add(1, 2) 是概念简写;演示项目实际使用 Calculator 实例调用。
≡讲稿第 26 页 · 教师提示
- 按题逐个让同学抢答,再选择答案并点击揭晓,不要一开始公开答案。
- Q1 BeforeEach;Q2 提示在最后所以是 5;Q3 1000 毫秒对应 Timeout(1);Q4 完全一致用 assertThrowsExactly。
- 计分按每题第一次揭晓时的选择计算,重复揭晓不会重复加分;重置后可重新进行一轮。
参考资料
JUnit 5.14.4 User Guide · 固定版本 ↗JUnit 5 User Guide · 原 PPT 参考链接 ↗本站内容与代码均来自随附素材;网页与互动可完全离线使用。参考链接需联网。
≡讲稿第 27 页 · 教师提示
- 收束一句:新项目直接用 JUnit 5 写法,老项目借 Vintage 一步步迁移。
- 邀请提问:具体项目怎样迁移、参数化怎样选数据源、异常断言怎样选。
- 参考链接保留官方固定版本文档与原 PPT 中的 User Guide;离线讲解无需访问外网。