使用 Junit 5 对 Spring Boot 应用进行高效单元测试

好的，没问题！作为一名略带幽默感的编程专家，我将用充满人情味的语言，为你献上一篇关于使用 JUnit 5 对 Spring Boot 应用进行高效单元测试的详尽文章。准备好了吗？让我们一起踏上这段单元测试的奇妙旅程！

Spring Boot 单元测试：别再让 Bug 躲猫猫！

各位看官，大家好！咱们今天来聊聊 Spring Boot 项目的单元测试。说实话，写代码就像盖房子，地基不牢，楼再高也摇摇欲坠。而单元测试，就是咱们代码的“地基质量检测员”，专门揪出那些藏在犄角旮旯里的 Bug。

很多小伙伴一听到“测试”俩字就头大，觉得麻烦，浪费时间。但相信我，磨刀不误砍柴工！单元测试写得好，不仅能减少 Bug，还能提升代码质量，让你在未来的开发中少踩坑。

为什么选择 JUnit 5？

在 Java 单元测试界，JUnit 可谓是老大哥级别的人物。而 JUnit 5，则是这位老大哥的最新力作，它带来了诸多令人兴奋的特性：

模块化架构： JUnit 5 采用模块化设计，将核心引擎、测试 API 和扩展 API 分离开来，更加灵活。
更强大的断言： JUnit 5 提供了更丰富的断言方法，让你的测试代码更加简洁易懂。
条件执行： 可以根据条件来决定是否执行某个测试方法，比如只有在特定环境下才执行。
参数化测试： 可以使用不同的参数多次运行同一个测试方法，省时省力。
嵌套测试： 允许你将测试类组织成层次结构，更好地组织测试代码。
扩展模型： JUnit 5 提供了强大的扩展模型，可以自定义测试行为。

总之，JUnit 5 就是单元测试界的瑞士军刀，功能强大，用起来还很顺手！

搭建 Spring Boot + JUnit 5 测试环境

首先，咱们得先搭建一个 Spring Boot 项目，并在其中引入 JUnit 5 的依赖。如果你已经有了一个 Spring Boot 项目，可以直接跳到第二步。

1. 创建 Spring Boot 项目（如果还没有）

可以使用 Spring Initializr (start.spring.io) 创建一个简单的 Spring Boot 项目。选择你喜欢的构建工具（Maven 或 Gradle），并添加一些必要的依赖，比如 spring-boot-starter-web。

2. 引入 JUnit 5 依赖

在你的 pom.xml (Maven) 或 build.gradle (Gradle) 文件中添加 JUnit 5 的依赖。

Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
    <exclusions>
        <exclusion>
            <groupId>org.junit.vintage</groupId>
            <artifactId>junit-vintage-engine</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <scope>test</scope>
</dependency>

Gradle:

dependencies {
    testImplementation('org.springframework.boot:spring-boot-starter-test') {
        exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
    }
    testImplementation 'org.junit.jupiter:junit-jupiter-api'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
}

注意：

spring-boot-starter-test 已经包含了 JUnit 5 的核心依赖，但为了更清晰地控制版本，建议显式引入 junit-jupiter-api 和 junit-jupiter-engine。
exclude group: 'org.junit.vintage', module: 'junit-vintage-engine' 用于排除 JUnit 4 的引擎，避免冲突。

JUnit 5 常用注解

JUnit 5 提供了许多注解来标记测试类和测试方法。下面是一些常用的注解：

注解	描述
`@Test`	标记一个方法为测试方法。
`@BeforeEach`	标记一个方法，在每个测试方法执行之前都会执行。类似于 JUnit 4 中的 `@Before`。
`@AfterEach`	标记一个方法，在每个测试方法执行之后都会执行。类似于 JUnit 4 中的 `@After`。
`@BeforeAll`	标记一个静态方法，在所有测试方法执行之前只执行一次。类似于 JUnit 4 中的 `@BeforeClass`。
`@AfterAll`	标记一个静态方法，在所有测试方法执行之后只执行一次。类似于 JUnit 4 中的 `@AfterClass`。
`@Disabled`	禁用一个测试类或测试方法。
`@DisplayName`	为测试类或测试方法指定一个更友好的名称，方便在测试报告中查看。
`@ParameterizedTest`	标记一个方法为参数化测试方法，可以使用不同的参数多次运行同一个测试方法。
`@ValueSource`	为参数化测试方法提供一组简单的字面量值。
`@MethodSource`	为参数化测试方法提供一个方法，该方法返回一组参数。

编写你的第一个单元测试

咱们来写一个简单的例子，测试一个计算器类。

1. 创建计算器类

package com.example.demo;

public class Calculator {

    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }

    public int multiply(int a, int b) {
        return a * b;
    }

    public double divide(int a, int b) {
        if (b == 0) {
            throw new IllegalArgumentException("除数不能为 0");
        }
        return (double) a / b;
    }
}

2. 创建测试类

package com.example.demo;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

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

class CalculatorTest {

    private Calculator calculator;

    @BeforeEach
    void setUp() {
        calculator = new Calculator();
    }

    @Test
    void add() {
        int result = calculator.add(1, 2);
        assertEquals(3, result, "加法运算结果不正确");
    }

    @Test
    void subtract() {
        int result = calculator.subtract(5, 2);
        assertEquals(3, result, "减法运算结果不正确");
    }

    @Test
    void multiply() {
        int result = calculator.multiply(3, 4);
        assertEquals(12, result, "乘法运算结果不正确");
    }

    @Test
    void divide() {
        double result = calculator.divide(10, 2);
        assertEquals(5.0, result, "除法运算结果不正确");
    }

    @Test
    void divideByZero() {
        assertThrows(IllegalArgumentException.class, () -> calculator.divide(10, 0), "除以 0 应该抛出异常");
    }
}

代码解释：

@BeforeEach 注解标记的 setUp() 方法会在每个测试方法执行之前执行，用于初始化 calculator 对象。
@Test 注解标记的方法是测试方法，用于测试 Calculator 类的不同方法。
assertEquals() 方法用于断言两个值是否相等。如果相等，测试通过；否则，测试失败。
assertThrows() 方法用于断言某个方法是否会抛出指定的异常。

3. 运行测试

在 IDE 中右键点击测试类，选择 "Run" 或 "Debug" 运行测试。或者使用 Maven 或 Gradle 命令运行测试：

Maven:

mvn test

Gradle:

gradle test

如果一切顺利，你应该看到测试通过的报告！

Spring Boot 单元测试进阶技巧

光会写简单的单元测试还不够，咱们还得掌握一些进阶技巧，才能更好地测试 Spring Boot 应用。

1. 测试 Spring Bean

Spring Boot 最大的特点就是依赖注入（DI）。在单元测试中，我们需要模拟 Spring 容器的行为，将依赖注入到被测试的 Bean 中。

使用 @Autowired 注入依赖

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

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

@SpringBootTest
class MyServiceTest {

    @Autowired
    private MyService myService;

    @Test
    void myMethod() {
        String result = myService.myMethod();
        assertEquals("Hello, World!", result);
    }
}

@SpringBootTest 注解用于启动 Spring Boot 上下文，让 Spring 容器管理 Bean。
@Autowired 注解用于将 MyService 注入到测试类中。

使用 Mockito 模拟依赖

有时候，我们不想启动整个 Spring 上下文，或者依赖的 Bean 难以创建。这时，可以使用 Mockito 框架来模拟依赖。

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.springframework.boot.test.context.SpringBootTest;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.when;

@SpringBootTest
class MyServiceTest {

    @Mock
    private MyRepository myRepository;

    @InjectMocks
    private MyService myService;

    @Test
    void myMethod() {
        when(myRepository.getData()).thenReturn("Mock Data");
        String result = myService.myMethod();
        assertEquals("Mock Data", result);
    }
}

@Mock 注解用于创建 MyRepository 的 Mock 对象。
@InjectMocks 注解用于将 MyRepository 的 Mock 对象注入到 MyService 中。
when(myRepository.getData()).thenReturn("Mock Data") 用于定义 myRepository.getData() 方法的返回值。

2. 测试 Controller

测试 Controller 主要目的是验证 API 的行为是否符合预期，比如请求参数是否正确，响应状态码是否正确，返回数据是否正确。

使用 MockMvc 模拟 HTTP 请求

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;

@SpringBootTest
@AutoConfigureMockMvc
class MyControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    void myEndpoint() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/my-endpoint")
                .contentType(MediaType.APPLICATION_JSON))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.content().string("Hello, World!"));
    }
}

@AutoConfigureMockMvc 注解用于自动配置 MockMvc 对象。
mockMvc.perform() 方法用于模拟 HTTP 请求。
MockMvcRequestBuilders.get() 方法用于创建 GET 请求。
MockMvcResultMatchers.status().isOk() 方法用于断言响应状态码是否为 200 OK。
MockMvcResultMatchers.content().string() 方法用于断言响应内容是否为 "Hello, World!"。

3. 测试 Service 层

Service 层通常包含业务逻辑，是单元测试的重点。可以使用 Mockito 模拟 Repository 层，专注于测试 Service 层的逻辑。

package com.example.demo;

import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.springframework.boot.test.context.SpringBootTest;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.when;

@SpringBootTest
class MyServiceTest {

    @Mock
    private MyRepository myRepository;

    @InjectMocks
    private MyService myService;

    @Test
    void myMethod() {
        when(myRepository.getData()).thenReturn("Mock Data");
        String result = myService.myMethod();
        assertEquals("Mock Data", result);
    }
}

4. 参数化测试

参数化测试允许你使用不同的参数多次运行同一个测试方法，可以有效地减少重复代码。

package com.example.demo;

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

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

class MyTest {

    @ParameterizedTest
    @ValueSource(strings = {"Hello", "World", "JUnit"})
    void testWithValueSource(String input) {
        assertNotNull(input);
    }
}

@ParameterizedTest 注解用于标记一个方法为参数化测试方法。
@ValueSource 注解用于提供一组简单的字面量值作为参数。

5. 使用 Hamcrest 断言

Hamcrest 是一个强大的断言库，提供了更丰富的断言方法，让你的测试代码更加易读。

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;

import org.junit.jupiter.api.Test;

class HamcrestTest {

    @Test
    void testHamcrest() {
        String text = "Hello, World!";
        assertThat(text, is("Hello, World!"));
        assertThat(text, containsString("World"));
        assertThat(text, not(isEmptyOrNullString()));
    }
}

需要引入 Hamcrest 依赖：

Maven:

<dependency>
    <groupId>org.hamcrest</groupId>
    <artifactId>hamcrest</artifactId>
    <version>2.2</version>
    <scope>test</scope>
</dependency>

Gradle:

testImplementation 'org.hamcrest:hamcrest:2.2'

最佳实践

测试驱动开发（TDD）： 先写测试，再写代码，确保代码能够通过测试。
覆盖率： 尽量提高测试覆盖率，确保代码的每个分支都被测试到。
可读性： 编写易读的测试代码，方便维护和理解。
独立性： 确保每个测试方法都是独立的，不会互相影响。
快速： 单元测试应该运行速度快，方便频繁运行。

总结

单元测试是保证代码质量的重要手段。通过 JUnit 5 和 Spring Boot 的结合，我们可以编写出高效、易维护的单元测试。记住，写测试不是负担，而是对自己的代码负责，也是对团队的负责。希望这篇文章能帮助你更好地掌握 Spring Boot 单元测试，写出更健壮的代码！

最后，祝大家编码愉快，Bug 远离！

Spring Boot 单元测试：别再让 Bug 躲猫猫！

为什么选择 JUnit 5？

搭建 Spring Boot + JUnit 5 测试环境

JUnit 5 常用注解

编写你的第一个单元测试

Spring Boot 单元测试进阶技巧

最佳实践

总结

发表回复 取消回复

发表回复取消回复