🎓博主介绍：Java、Python、js全栈开发 “多面手”，精通多种编程语言和技术，痴迷于人工智能领域。秉持着对技术的热爱与执着，持续探索创新，愿在此分享交流和学习，与大家共进步。
📖DeepSeek-行业融合之万象视界(附实战案例详解100+)
📖全栈开发环境搭建运行攻略：多语言一站式指南(环境搭建+运行+调试+发布+保姆级详解)
👉感兴趣的可以先收藏起来，希望帮助更多的人

SpringBoot单元测试与集成测试实战：Mockito+Testcontainers应用

一、引言

在软件开发过程中，测试是确保代码质量和系统稳定性的关键环节。Spring Boot作为目前Java开发领域中最流行的框架之一，提供了丰富的测试支持。而Mockito和Testcontainers则是两个强大的测试工具，分别用于单元测试和集成测试。本文将详细介绍如何在Spring Boot项目中使用Mockito和Testcontainers进行单元测试和集成测试，帮助技术人员更好地掌握这两种测试技术。

二、Mockito简介

2.1 Mockito概述

Mockito是一个用于Java的开源测试框架，主要用于创建和管理模拟对象（Mock Objects）。在单元测试中，我们通常需要隔离被测试对象与外部依赖，使用Mockito可以轻松地创建模拟对象，模拟外部依赖的行为，从而专注于被测试对象的逻辑。

2.2 Mockito基本使用

以下是一个简单的Mockito示例：

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

// 定义一个接口
interface MyService {
    String doSomething();
}

public class MockitoExample {
    @Test
    public void testMockObject() {
        // 创建一个模拟对象
        MyService mockService = mock(MyService.class);

        // 定义模拟对象的行为
        when(mockService.doSomething()).thenReturn("Mocked Result");

        // 调用模拟对象的方法
        String result = mockService.doSomething();

        // 验证结果
        assertEquals("Mocked Result", result);

        // 验证方法是否被调用
        verify(mockService).doSomething();
    }
}

在这个示例中，我们首先创建了一个MyService接口的模拟对象mockService，然后使用when方法定义了doSomething方法的返回值，最后调用该方法并验证结果和方法调用情况。

三、Testcontainers简介

3.1 Testcontainers概述

Testcontainers是一个用于在测试中运行Docker容器的Java库。在集成测试中，我们经常需要与外部服务（如数据库、消息队列等）进行交互，使用Testcontainers可以方便地在测试环境中启动和管理这些外部服务的容器，确保测试环境与生产环境的一致性。

3.2 Testcontainers基本使用

以下是一个使用Testcontainers启动MySQL容器的示例：

import org.junit.jupiter.api.Test;
import org.testcontainers.containers.MySQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;

@Testcontainers
public class TestcontainersExample {
    // 启动一个MySQL容器
    @Container
    private static final MySQLContainer<?> mysqlContainer = new MySQLContainer<>("mysql:8.0")
           .withDatabaseName("testdb")
           .withUsername("testuser")
           .withPassword("testpass");

    @Test
    public void testMySQLContainer() throws Exception {
        // 获取数据库连接信息
        String jdbcUrl = mysqlContainer.getJdbcUrl();
        String username = mysqlContainer.getUsername();
        String password = mysqlContainer.getPassword();

        // 建立数据库连接
        try (Connection connection = DriverManager.getConnection(jdbcUrl, username, password);
             Statement statement = connection.createStatement()) {
            // 创建表
            statement.executeUpdate("CREATE TABLE IF NOT EXISTS test_table (id INT PRIMARY KEY, name VARCHAR(255))");
            // 插入数据
            statement.executeUpdate("INSERT INTO test_table (id, name) VALUES (1, 'Test')");
            // 查询数据
            ResultSet resultSet = statement.executeQuery("SELECT * FROM test_table");
            if (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                System.out.println("ID: " + id + ", Name: " + name);
            }
        }
    }
}

在这个示例中，我们使用@Testcontainers注解启用Testcontainers支持，使用@Container注解启动一个MySQL容器，并在测试方法中使用JDBC连接到该容器，执行数据库操作。

四、Spring Boot中使用Mockito进行单元测试

4.1 项目准备

首先，创建一个Spring Boot项目，并添加以下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.mockito</groupId>
        <artifactId>mockito-core</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

4.2 编写服务类

创建一个简单的服务类UserService：

import org.springframework.stereotype.Service;

@Service
public class UserService {
    public String getUserById(int id) {
        // 模拟从数据库中获取用户信息
        return "User " + id;
    }
}

4.3 编写控制器类

创建一个控制器类UserController：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/users/{id}")
    public String getUser(@PathVariable int id) {
        return userService.getUserById(id);
    }
}

4.4 编写单元测试

使用Mockito对UserController进行单元测试：

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.web.servlet.MockMvc;

import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@WebMvcTest(UserController.class)
public class UserControllerUnitTest {
    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserService userService;

    @Test
    public void testGetUser() throws Exception {
        int userId = 1;
        String expectedResult = "User " + userId;

        // 模拟UserService的行为
        when(userService.getUserById(userId)).thenReturn(expectedResult);

        // 发送HTTP请求并验证结果
        mockMvc.perform(get("/users/" + userId))
               .andExpect(status().isOk())
               .andExpect(content().string(expectedResult));
    }
}

在这个单元测试中，我们使用@WebMvcTest注解只加载UserController，使用@MockBean注解创建UserService的模拟对象，并使用when方法定义其行为，最后使用MockMvc发送HTTP请求并验证结果。

五、Spring Boot中使用Testcontainers进行集成测试

5.1 项目准备

在之前的Spring Boot项目基础上，添加Testcontainers和MySQL驱动依赖：

<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>testcontainers</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>mysql</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

5.2 配置数据源

在application.properties中配置数据源：

spring.datasource.url=jdbc:mysql://localhost:3306/testdb
spring.datasource.username=testuser
spring.datasource.password=testpass
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

5.3 编写实体类和Repository

创建一个User实体类和UserRepository接口：

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    // 构造方法、Getter和Setter省略
}

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

5.4 编写集成测试

使用Testcontainers对UserRepository进行集成测试：

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.testcontainers.containers.MySQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

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

@Testcontainers
@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
public class UserRepositoryIntegrationTest {
    @Container
    private static final MySQLContainer<?> mysqlContainer = new MySQLContainer<>("mysql:8.0")
           .withDatabaseName("testdb")
           .withUsername("testuser")
           .withPassword("testpass");

    @DynamicPropertySource
    static void setDataSourceProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", mysqlContainer::getJdbcUrl);
        registry.add("spring.datasource.username", mysqlContainer::getUsername);
        registry.add("spring.datasource.password", mysqlContainer::getPassword);
    }

    @Autowired
    private UserRepository userRepository;

    @Test
    public void testSaveAndFindUser() {
        User user = new User();
        user.setName("Test User");

        // 保存用户
        User savedUser = userRepository.save(user);

        // 查询用户
        User foundUser = userRepository.findById(savedUser.getId()).orElse(null);

        // 验证结果
        assertEquals(savedUser.getName(), foundUser.getName());
    }
}

在这个集成测试中，我们使用@Testcontainers注解启用Testcontainers支持，使用@Container注解启动一个MySQL容器，使用@DynamicPropertySource注解动态配置数据源，最后对UserRepository进行保存和查询操作并验证结果。

六、总结

本文详细介绍了在Spring Boot项目中使用Mockito和Testcontainers进行单元测试和集成测试的方法。Mockito可以帮助我们创建和管理模拟对象，隔离被测试对象与外部依赖，专注于被测试对象的逻辑；Testcontainers可以方便地在测试环境中启动和管理外部服务的容器，确保测试环境与生产环境的一致性。通过合理使用这两种工具，可以提高代码的可测试性和系统的稳定性。