1. JUnit单元测试基础入门

刚学完Java基础语法的新手，第一次听说"单元测试"这个词可能会有点懵。简单来说，单元测试就像是你写代码时的小助手，专门帮你检查每个方法是否正常工作。想象你写了个计算器程序，单元测试就是自动帮你按遍所有按钮，确保1+1确实等于2而不是3。

JUnit是Java领域最流行的单元测试框架，目前主流版本是JUnit 5。先看个最简单的例子：假设我们有个字符串处理工具类，其中有个反转字符串的方法：

public class StringUtils { public static String reverse(String input) { return new StringBuilder(input).reverse().toString(); } }

对应的测试类长这样：

import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; class StringUtilsTest { @Test void testReverse() { assertEquals("cba", StringUtils.reverse("abc")); assertEquals("", StringUtils.reverse("")); } }

这里有几个关键点：

• @Test注解标记这是个测试方法
• assertEquals用来验证预期值和实际结果是否一致
• 测试方法命名通常采用测试目标_测试条件_预期结果的格式

2. 核心注解与测试生命周期

JUnit通过注解来管理测试流程，最常用的有：

import org.junit.jupiter.api.*; class LifecycleTest { @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. initAll() （仅一次）
2. 对每个测试方法：
   • init()
   • 测试方法
   • tearDown()
3. tearDownAll() （仅一次）

实际项目中，我常用@BeforeEach来初始化测试数据。比如测试用户服务时：

class UserServiceTest { private UserService userService; private User testUser; @BeforeEach void setUp() { userService = new UserService(); testUser = new User("test", "test@example.com"); userService.register(testUser); } @Test void login_withValidCredential_returnsUser() { User loggedIn = userService.login("test@example.com", "password"); assertEquals(testUser, loggedIn); } }

3. 断言与异常测试

JUnit提供了丰富的断言方法，最常用的有：

@Test void testAssertions() { // 基本断言 assertEquals(4, 2 + 2); assertNotEquals(3, 1 + 1); // 布尔断言 assertTrue("Hello".contains("ell")); assertFalse("Hello".endsWith("World")); // 空值断言 String nullStr = null; assertNull(nullStr); assertNotNull("Hello"); // 数组断言 assertArrayEquals(new int[]{1,2,3}, new int[]{1,2,3}); // 异常断言 assertThrows(ArithmeticException.class, () -> { int i = 1 / 0; }); }

测试异常情况特别重要，比如我们测试一个银行账户的取款方法：

class BankAccount { private double balance; public void withdraw(double amount) { if (amount > balance) { throw new InsufficientFundsException(); } balance -= amount; } } @Test void withdraw_amountExceedsBalance_throwsException() { BankAccount account = new BankAccount(100); assertThrows(InsufficientFundsException.class, () -> { account.withdraw(200); }); }

4. 参数化测试实战

当需要测试多组输入数据时，参数化测试能大幅减少重复代码。比如测试一个素数判断器：

class PrimeChecker { public static boolean isPrime(int n) { if (n <= 1) return false; for (int i = 2; i <= Math.sqrt(n); i++) { if (n % i == 0) return false; } return true; } }

使用@ParameterizedTest进行多数据测试：

@ParameterizedTest @ValueSource(ints = {2, 3, 5, 7, 11, 13}) void isPrime_withPrimes_returnsTrue(int number) { assertTrue(PrimeChecker.isPrime(number)); } @ParameterizedTest @ValueSource(ints = {1, 4, 6, 8, 9, 10}) void isPrime_withNonPrimes_returnsFalse(int number) { assertFalse(PrimeChecker.isPrime(number)); }

更复杂的参数组合可以用@MethodSource：

static Stream<Arguments> provideNumbers() { return Stream.of( Arguments.of(1, false), Arguments.of(2, true), Arguments.of(4, false), Arguments.of(17, true) ); } @ParameterizedTest @MethodSource("provideNumbers") void isPrime_returnsExpectedResult(int number, boolean expected) { assertEquals(expected, PrimeChecker.isPrime(number)); }

5. 测试驱动开发(TDD)实践

TDD是一种先写测试再写实现的开发现场。假设我们要开发一个FizzBuzz游戏：

1. 先写测试：

@Test void fizzBuzz_inputDivisibleBy3_returnsFizz() { assertEquals("Fizz", FizzBuzz.play(3)); assertEquals("Fizz", FizzBuzz.play(6)); } @Test void fizzBuzz_inputDivisibleBy5_returnsBuzz() { assertEquals("Buzz", FizzBuzz.play(5)); assertEquals("Buzz", FizzBuzz.play(10)); }

2. 运行测试（应该失败）
3. 写最小实现让测试通过：

class FizzBuzz { public static String play(int number) { if (number % 3 == 0) return "Fizz"; if (number % 5 == 0) return "Buzz"; return String.valueOf(number); } }

4. 添加更多测试：

@Test void fizzBuzz_inputDivisibleByBoth_returnsFizzBuzz() { assertEquals("FizzBuzz", FizzBuzz.play(15)); assertEquals("FizzBuzz", FizzBuzz.play(30)); }

5. 完善实现：

class FizzBuzz { public static String play(int number) { if (number % 15 == 0) return "FizzBuzz"; if (number % 3 == 0) return "Fizz"; if (number % 5 == 0) return "Buzz"; return String.valueOf(number); } }

6. 项目实战：电梯模拟系统测试

让我们用个完整案例把知识点串起来。假设我们要测试一个电梯控制系统：

class Elevator { private int currentFloor = 1; public void moveTo(int targetFloor) { if (targetFloor < 1 || targetFloor > 20) { throw new IllegalArgumentException("楼层无效"); } this.currentFloor = targetFloor; } public int getCurrentFloor() { return currentFloor; } }

对应的测试类：

class ElevatorTest { private Elevator elevator; @BeforeEach void setUp() { elevator = new Elevator(); } @Test void moveTo_validFloor_changesCurrentFloor() { elevator.moveTo(5); assertEquals(5, elevator.getCurrentFloor()); elevator.moveTo(10); assertEquals(10, elevator.getCurrentFloor()); } @ParameterizedTest @ValueSource(ints = {0, 21, -1}) void moveTo_invalidFloor_throwsException(int floor) { assertThrows(IllegalArgumentException.class, () -> { elevator.moveTo(floor); }); } @Test @Timeout(1) // 超时测试，1秒内必须完成 void stressTest_multipleMoves() { for (int i = 1; i <= 20; i++) { elevator.moveTo(i); assertEquals(i, elevator.getCurrentFloor()); } } }

7. 测试覆盖率与最佳实践

好的单元测试应该追求合理的覆盖率（建议80%以上）。使用JaCoCo等工具可以测量：

<!-- Maven配置示例 --> <plugin> <groupId>org.jacoco</groupId> <artifactId>jacoco-maven-plugin</artifactId> <version>0.8.7</version> <executions> <execution> <goals> <goal>prepare-agent</goal> </goals> </execution> <execution> <id>report</id> <phase>test</phase> <goals> <goal>report</goal> </goals> </execution> </executions> </plugin>

测试最佳实践：

1. 测试命名要清晰表达意图
2. 每个测试只验证一个功能点
3. 测试之间不要有依赖
4. 避免测试实现细节，关注行为
5. 定期维护测试代码

我在实际项目中发现，良好的单元测试能减少80%以上的低级bug。刚开始可能觉得写测试浪费时间，但长期来看，它能让你的代码更健壮，重构时更有信心。特别是当项目规模变大后，没有测试的代码就像走钢丝没有安全网。