Spring Boot作为一个现代Java开发框架，通过其简化的配置和丰富的功能，极大地提升了开发效率。在数据访问层，MyBatis作为一个优秀的ORM框架，因其灵活性和易用性得到了广泛应用。本文将详细介绍如何在Spring Boot项目中集成MyBatis，涵盖基本配置、动态SQL、多数据源、分页、缓存等多个方面，旨在帮助开发者全面掌握Spring Boot与MyBatis的集成方法。

1. Spring Boot与MyBatis简介

1.1 Spring Boot简介

Spring Boot是Spring生态系统中的一部分，通过简化Spring应用程序的搭建和配置，提升了开发效率。Spring Boot提供了一系列开箱即用的默认配置，支持多种第三方库的快速集成。

1.2 MyBatis简介

MyBatis是一个优秀的持久层框架，它通过XML或注解将SQL语句与Java对象进行映射，提供了比JPA更加灵活的数据库操作方式。MyBatis支持动态SQL、缓存和插件等功能，适用于各种复杂的数据访问场景。

2. Spring Boot集成MyBatis的基本配置

2.1 创建Spring Boot项目

首先，使用Spring Initializr或其他方式创建一个Spring Boot项目，并引入必要的依赖。

  1. <!-- pom.xml -->
  2. <dependencies>
  3.     <!-- Spring Boot Starter -->
  4.     <dependency>
  5.         <groupId>org.springframework.boot</groupId>
  6.         <artifactId>spring-boot-starter</artifactId>
  7.     </dependency>
  8.     <!-- Spring Boot Starter MyBatis -->
  9.     <dependency>
  10.         <groupId>org.mybatis.spring.boot</groupId>
  11.         <artifactId>mybatis-spring-boot-starter</artifactId>
  12.         <version>2.1.4</version>
  13.     </dependency>
  14.     <!-- Spring Boot Starter DataSource -->
  15.     <dependency>
  16.         <groupId>org.springframework.boot</groupId>
  17.         <artifactId>spring-boot-starter-jdbc</artifactId>
  18.     </dependency>
  19.     <!-- MySQL Connector -->
  20.     <dependency>
  21.         <groupId>mysql</groupId>
  22.         <artifactId>mysql-connector-java</artifactId>
  23.         <scope>runtime</scope>
  24.     </dependency>
  25.     <!-- Test dependencies -->
  26.     <dependency>
  27.         <groupId>org.springframework.boot</groupId>
  28.         <artifactId>spring-boot-starter-test</artifactId>
  29.         <scope>test</scope>
  30.     </dependency>
  31. </dependencies>

2.2 配置数据源

在application.properties文件中配置数据源信息。

  1. # application.properties
  2. spring.datasource.url=jdbc:mysql://localhost:3306/mydb
  3. spring.datasource.username=root
  4. spring.datasource.password=secret
  5. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

2.3 配置MyBatis

在application.properties文件中配置MyBatis相关参数。

  1. # MyBatis configuration
  2. mybatis.mapper-locations=classpath:mapper/*.xml
  3. mybatis.type-aliases-package=com.example.model

2.4 创建数据库表

在MySQL数据库中创建一个示例表。

  1. CREATE TABLE user (
  2.     id BIGINT AUTO_INCREMENT PRIMARY KEY,
  3.     name VARCHAR(50) NOT NULL,
  4.     email VARCHAR(50) NOT NULL
  5. );

2.5 创建实体类

创建一个与数据库表对应的实体类。

  1. package com.example.model;
  3. public class User {
  4.     private Long id;
  5.     private String name;
  6.     private String email;
  8.     // Getters and setters
  9. }

2.6 创建Mapper接口和XML映射文件

创建一个Mapper接口，并在mapper目录下创建对应的XML映射文件。

  1. package com.example.mapper;
  3. import java.util.List;
  4. import com.example.model.User;
  5. import org.apache.ibatis.annotations.*;
  7. public interface UserMapper {
  8.     @Select("SELECT * FROM user WHERE id = #{id}")
  9.     User getUserById(Long id);
  11.     @Select("SELECT * FROM user")
  12.     List<User> getAllUsers();
  14.     @Insert("INSERT INTO user(name, email) VALUES(#{name}, #{email})")
  15.     @Options(useGeneratedKeys = true, keyProperty = "id")
  16.     void insertUser(User user);
  18.     @Update("UPDATE user SET name = #{name}, email = #{email} WHERE id = #{id}")
  19.     void updateUser(User user);
  21.     @Delete("DELETE FROM user WHERE id = #{id}")
  22.     void deleteUser(Long id);
  23. }

创建XML映射文件UserMapper.xml：

  1. <!-- mapper/UserMapper.xml -->
  2. <?xml version="1.0" encoding="UTF-8" ?>
  3. <!DOCTYPE mapper
  4.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  5.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  6. <mapper namespace="com.example.mapper.UserMapper">
  8.     <resultMap id="UserResultMap" type="com.example.model.User">
  9.         <id column="id" property="id" />
  10.         <result column="name" property="name" />
  11.         <result column="email" property="email" />
  12.     </resultMap>
  14.     <select id="getUserById" resultMap="UserResultMap">
  15.         SELECT * FROM user WHERE id = #{id}
  16.     </select>
  18.     <select id="getAllUsers" resultMap="UserResultMap">
  19.         SELECT * FROM user
  20.     </select>
  22.     <insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
  23.         INSERT INTO user (name, email) VALUES (#{name}, #{email})
  24.     </insert>
  26.     <update id="updateUser">
  27.         UPDATE user SET name = #{name}, email = #{email} WHERE id = #{id}
  28.     </update>
  30.     <delete id="deleteUser">
  31.         DELETE FROM user WHERE id = #{id}
  32.     </delete>
  33. </mapper>

2.7 创建Service类

创建一个Service类，用于处理业务逻辑。

  1. package com.example.service;
  3. import java.util.List;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Service;
  6. import com.example.mapper.UserMapper;
  7. import com.example.model.User;
  9. @Service
  10. public class UserService {
  12.     @Autowired
  13.     private UserMapper userMapper;
  15.     public User getUserById(Long id) {
  16.         return userMapper.getUserById(id);
  17.     }
  19.     public List<User> getAllUsers() {
  20.         return userMapper.getAllUsers();
  21.     }
  23.     public void createUser(User user) {
  24.         userMapper.insertUser(user);
  25.     }
  27.     public void updateUser(User user) {
  28.         userMapper.updateUser(user);
  29.     }
  31.     public void deleteUser(Long id) {
  32.         userMapper.deleteUser(id);
  33.     }
  34. }

2.8 创建Controller类

创建一个Controller类，用于处理HTTP请求。

  1. package com.example.controller;
  3. import java.util.List;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.web.bind.annotation.*;
  6. import com.example.model.User;
  7. import com.example.service.UserService;
  9. @RestController
  10. @RequestMapping("/users")
  11. public class UserController {
  13.     @Autowired
  14.     private UserService userService;
  16.     @GetMapping("/{id}")
  17.     public User getUserById(@PathVariable Long id) {
  18.         return userService.getUserById(id);
  19.     }
  21.     @GetMapping
  22.     public List<User> getAllUsers() {
  23.         return userService.getAllUsers();
  24.     }
  26.     @PostMapping
  27.     public void createUser(@RequestBody User user) {
  28.         userService.createUser(user);
  29.     }
  31.     @PutMapping
  32.     public void updateUser(@RequestBody User user) {
  33.         userService.updateUser(user);
  34.     }
  36.     @DeleteMapping("/{id}")
  37.     public void deleteUser(@PathVariable Long id) {
  38.         userService.deleteUser(id);
  39.     }
  40. }

3. MyBatis动态SQL

MyBatis支持使用动态SQL来构建灵活的查询语句。动态SQL可以通过XML映射文件中的<if>、<choose>、<when>、<otherwise>等标签来实现。

3.1 使用动态SQL

在UserMapper.xml中添加一个动态SQL查询示例。

  1. <!-- mapper/UserMapper.xml -->
  2. <mapper namespace="com.example.mapper.UserMapper">
  4.     <resultMap id="UserResultMap" type="com.example.model.User">
  5.         <id column="id" property="id" />
  6.         <result column="name" property="name" />
  7.         <result column="email" property="email" />
  8.     </resultMap>
  10.     <select id="getUserById" resultMap="UserResultMap">
  11.         SELECT * FROM user WHERE id = #{id}
  12.     </select>
  14.     <select id="getAllUsers" resultMap="UserResultMap">
  15.         SELECT * FROM user
  16.     </select>
  18.     <insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
  19.         INSERT INTO user (name, email) VALUES (#{name}, #{email})
  20.     </insert>
  22.     <update id="updateUser">
  23.         UPDATE user SET name = #{name}, email = #{email} WHERE id = #{id}
  24.     </update>
  26.     <delete id="deleteUser">
  27.         DELETE FROM user WHERE id = #{id}
  28.     </delete>
  30.     <!-- 动态SQL示例 -->
  31.     <select id="findUsersByNameAndEmail" resultMap="UserResultMap">
  32.         SELECT * FROM user
  33.         <where>
  34.             <if test="name
  36.  != null">
  37.                 AND name = #{name}
  38.             </if>
  39.             <if test="email != null">
  40.                 AND email = #{email}
  41.             </if>
  42.         </where>
  43.     </select>
  44. </mapper>

3.2 修改Mapper接口

在UserMapper接口中添加对应的方法。

  1. package com.example.mapper;
  3. import java.util.List;
  4. import com.example.model.User;
  5. import org.apache.ibatis.annotations.*;
  7. public interface UserMapper {
  8.     @Select("SELECT * FROM user WHERE id = #{id}")
  9.     User getUserById(Long id);
  11.     @Select("SELECT * FROM user")
  12.     List<User> getAllUsers();
  14.     @Insert("INSERT INTO user(name, email) VALUES(#{name}, #{email})")
  15.     @Options(useGeneratedKeys = true, keyProperty = "id")
  16.     void insertUser(User user);
  18.     @Update("UPDATE user SET name = #{name}, email = #{email} WHERE id = #{id}")
  19.     void updateUser(User user);
  21.     @Delete("DELETE FROM user WHERE id = #{id}")
  22.     void deleteUser(Long id);
  24.     // 动态SQL方法
  25.     List<User> findUsersByNameAndEmail(@Param("name") String name, @Param("email") String email);
  26. }

4. MyBatis分页插件

在实际应用中，分页查询是一个常见的需求。MyBatis支持通过分页插件来实现分页功能。

4.1 添加分页插件依赖

在pom.xml中添加分页插件的依赖。

  1. <!-- pom.xml -->
  2. <dependency>
  3.     <groupId>com.github.pagehelper</groupId>
  4.     <artifactId>pagehelper-spring-boot-starter</artifactId>
  5.     <version>1.2.12</version>
  6. </dependency>

4.2 配置分页插件

在application.properties中配置分页插件参数。

  1. # application.properties
  2. pagehelper.helper-dialect=mysql
  3. pagehelper.reasonable=true
  4. pagehelper.support-methods-arguments=true
  5. pagehelper.params=count=countSql

4.3 使用分页插件

在Service类中使用分页插件进行分页查询。

  1. package com.example.service;
  3. import java.util.List;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Service;
  6. import com.github.pagehelper.PageHelper;
  7. import com.github.pagehelper.PageInfo;
  8. import com.example.mapper.UserMapper;
  9. import com.example.model.User;
  11. @Service
  12. public class UserService {
  14.     @Autowired
  15.     private UserMapper userMapper;
  17.     public User getUserById(Long id) {
  18.         return userMapper.getUserById(id);
  19.     }
  21.     public List<User> getAllUsers() {
  22.         return userMapper.getAllUsers();
  23.     }
  25.     public void createUser(User user) {
  26.         userMapper.insertUser(user);
  27.     }
  29.     public void updateUser(User user) {
  30.         userMapper.updateUser(user);
  31.     }
  33.     public void deleteUser(Long id) {
  34.         userMapper.deleteUser(id);
  35.     }
  37.     // 分页查询
  38.     public PageInfo<User> getUsersByPage(int pageNum, int pageSize) {
  39.         PageHelper.startPage(pageNum, pageSize);
  40.         List<User> users = userMapper.getAllUsers();
  41.         return new PageInfo<>(users);
  42.     }
  43. }

5. MyBatis多数据源配置

在一些复杂的应用中，可能需要访问多个数据源。Spring Boot和MyBatis支持多数据源配置，下面我们将介绍如何配置和使用多数据源。

5.1 添加多数据源配置

在application.properties中配置多个数据源。

  1. # application.properties
  2. # 数据源1
  3. spring.datasource.primary.url=jdbc:mysql://localhost:3306/primarydb
  4. spring.datasource.primary.username=root
  5. spring.datasource.primary.password=secret
  6. spring.datasource.primary.driver-class-name=com.mysql.cj.jdbc.Driver
  8. # 数据源2
  9. spring.datasource.secondary.url=jdbc:mysql://localhost:3306/secondarydb
  10. spring.datasource.secondary.username=root
  11. spring.datasource.secondary.password=secret
  12. spring.datasource.secondary.driver-class-name=com.mysql.cj.jdbc.Driver

5.2 创建数据源配置类

创建一个数据源配置类，配置多个数据源。

  1. package com.example.config;
  3. import javax.sql.DataSource;
  4. import org.apache.ibatis.session.SqlSessionFactory;
  5. import org.mybatis.spring.SqlSessionFactoryBean;
  6. import org.mybatis.spring.annotation.MapperScan;
  7. import org.springframework.beans.factory.annotation.Qualifier;
  8. import org.springframework.boot.context.properties.ConfigurationProperties;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.context.annotation.Primary;
  12. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  13. import org.springframework.boot.jdbc.DataSourceBuilder;
  15. @Configuration
  16. @MapperScan(basePackages = "com.example.mapper.primary", sqlSessionFactoryRef = "primarySqlSessionFactory")
  17. public class PrimaryDataSourceConfig {
  19.     @Primary
  20.     @Bean(name = "primaryDataSource")
  21.     @ConfigurationProperties(prefix = "spring.datasource.primary")
  22.     public DataSource primaryDataSource() {
  23.         return DataSourceBuilder.create().build();
  24.     }
  26.     @Primary
  27.     @Bean(name = "primarySqlSessionFactory")
  28.     public SqlSessionFactory primarySqlSessionFactory(@Qualifier("primaryDataSource") DataSource dataSource) throws Exception {
  29.         SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
  30.         sessionFactoryBean.setDataSource(dataSource);
  31.         return sessionFactoryBean.getObject();
  32.     }
  34.     @Primary
  35.     @Bean(name = "primaryTransactionManager")
  36.     public DataSourceTransactionManager primaryTransactionManager(@Qualifier("primaryDataSource") DataSource dataSource) {
  37.         return new DataSourceTransactionManager(dataSource);
  38.     }
  39. }
  1. package com.example.config;
  3. import javax.sql.DataSource;
  4. import org.apache.ibatis.session.SqlSessionFactory;
  5. import org.mybatis.spring.SqlSessionFactoryBean;
  6. import org.mybatis.spring.annotation.MapperScan;
  7. import org.springframework.beans.factory.annotation.Qualifier;
  8. import org.springframework.boot.context.properties.ConfigurationProperties;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  12. import org.springframework.boot.jdbc.DataSourceBuilder;
  14. @Configuration
  15. @MapperScan(basePackages = "com.example.mapper.secondary", sqlSessionFactoryRef = "secondarySqlSessionFactory")
  16. public class SecondaryDataSourceConfig {
  18.     @Bean(name = "secondaryDataSource")
  19.     @ConfigurationProperties(prefix = "spring.datasource.secondary")
  20.     public DataSource secondaryDataSource() {
  21.         return DataSourceBuilder.create().build();
  22.     }
  24.     @Bean(name = "secondarySqlSessionFactory")
  25.     public SqlSessionFactory secondarySqlSessionFactory(@Qualifier("secondaryDataSource") DataSource dataSource) throws Exception {
  26.         SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
  27.         sessionFactoryBean.setDataSource(dataSource);
  28.         return sessionFactoryBean.getObject();
  29.     }
  31.     @Bean(name = "secondaryTransactionManager")
  32.     public DataSourceTransactionManager secondaryTransactionManager(@Qualifier("secondaryDataSource") DataSource dataSource) {
  33.         return new DataSourceTransactionManager(dataSource);
  34.     }
  35. }

5.3 创建Mapper接口

在com.example.mapper.primary和com.example.mapper.secondary包中创建Mapper接口。

  1. package com.example.mapper.primary;
  3. import java.util.List;
  4. import com.example.model.User;
  5. import org.apache.ibatis.annotations.*;
  7. public interface PrimaryUserMapper {
  8.     @Select("SELECT * FROM user WHERE id = #{id}")
  9.     User getUserById(Long id);
  11.     @Select("SELECT * FROM user")
  12.     List<User> getAllUsers();
  14.     @Insert("INSERT INTO user(name, email) VALUES(#{name}, #{email})")
  15.     @Options(useGeneratedKeys = true, keyProperty = "id")
  16.     void insertUser(User user);
  18.     @Update("UPDATE user SET name = #{name}, email = #{email} WHERE id = #{id}")
  19.     void updateUser(User user);
  21.     @Delete("DELETE FROM user WHERE id = #{id}")
  22.     void deleteUser(Long id);
  23. }
  1. package com.example.mapper.secondary;
  3. import java.util.List;
  4. import com.example.model.Product;
  5. import org.apache.ibatis.annotations.*;
  7. public interface SecondaryProductMapper {
  8.     @Select("SELECT * FROM product WHERE id = #{id}")
  9.     Product getProductById(Long id);
  11.     @Select("SELECT * FROM product")
  12.     List<Product> getAllProducts();
  14.     @Insert("INSERT INTO product(name, price) VALUES(#{name}, #{price})")
  15.     @Options(useGeneratedKeys = true, keyProperty = "id")
  16.     void insertProduct(Product product);
  18.     @Update("UPDATE product SET name = #{name}, price = #{price} WHERE id = #{id}")
  19.     void updateProduct(Product product);
  21.     @Delete("DELETE FROM product WHERE id = #{id}")
  22.     void deleteProduct(Long id);
  23. }

5.4 创建Service类

创建Service类，分别调用不同数据源的Mapper接口。

  1. package com.example.service;
  3. import java.util.List;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Service;
  6. import com.example.mapper.primary.PrimaryUserMapper;
  7. import com.example.mapper.secondary.SecondaryProductMapper;
  8. import com.example.model.User;
  9. import com.example.model.Product;
  11. @Service
  12. public class DataService {
  14.     @Autowired
  15.     private PrimaryUserMapper primaryUserMapper;
  17.     @Autowired
  18.     private SecondaryProductMapper secondaryProductMapper;
  20.     // User methods
  21.     public User getUserById(Long id) {
  22.         return primaryUserMapper.getUserById(id);
  23.     }
  25.     public List<User> getAllUsers() {
  26.         return primaryUserMapper.getAllUsers();
  27.     }
  29.     public void createUser(User user) {
  30.         primaryUserMapper.insertUser(user);
  31.     }
  33.     public void updateUser(User user) {
  34.         primaryUserMapper.updateUser(user);
  35.     }
  37.     public void deleteUser(Long id) {
  38.         primaryUserMapper.deleteUser(id);
  41.  }
  43.     // Product methods
  44.     public Product getProductById(Long id) {
  45.         return secondaryProductMapper.getProductById(id);
  46.     }
  48.     public List<Product> getAllProducts() {
  49.         return secondaryProductMapper.getAllProducts();
  50.     }
  52.     public void createProduct(Product product) {
  53.         secondaryProductMapper.insertProduct(product);
  54.     }
  56.     public void updateProduct(Product product) {
  57.         secondaryProductMapper.updateProduct(product);
  58.     }
  60.     public void deleteProduct(Long id) {
  61.         secondaryProductMapper.deleteProduct(id);
  62.     }
  63. }

5.5 创建Controller类

创建一个Controller类，调用Service方法处理HTTP请求。

  1. package com.example.controller;
  3. import java.util.List;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.web.bind.annotation.*;
  6. import com.example.model.User;
  7. import com.example.model.Product;
  8. import com.example.service.DataService;
  10. @RestController
  11. @RequestMapping("/data")
  12. public class DataController {
  14.     @Autowired
  15.     private DataService dataService;
  17.     // User endpoints
  18.     @GetMapping("/users/{id}")
  19.     public User getUserById(@PathVariable Long id) {
  20.         return dataService.getUserById(id);
  21.     }
  23.     @GetMapping("/users")
  24.     public List<User> getAllUsers() {
  25.         return dataService.getAllUsers();
  26.     }
  28.     @PostMapping("/users")
  29.     public void createUser(@RequestBody User user) {
  30.         dataService.createUser(user);
  31.     }
  33.     @PutMapping("/users")
  34.     public void updateUser(@RequestBody User user) {
  35.         dataService.updateUser(user);
  36.     }
  38.     @DeleteMapping("/users/{id}")
  39.     public void deleteUser(@PathVariable Long id) {
  40.         dataService.deleteUser(id);
  41.     }
  43.     // Product endpoints
  44.     @GetMapping("/products/{id}")
  45.     public Product getProductById(@PathVariable Long id) {
  46.         return dataService.getProductById(id);
  47.     }
  49.     @GetMapping("/products")
  50.     public List<Product> getAllProducts() {
  51.         return dataService.getAllProducts();
  52.     }
  54.     @PostMapping("/products")
  55.     public void createProduct(@RequestBody Product product) {
  56.         dataService.createProduct(product);
  57.     }
  59.     @PutMapping("/products")
  60.     public void updateProduct(@RequestBody Product product) {
  61.         dataService.updateProduct(product);
  62.     }
  64.     @DeleteMapping("/products/{id}")
  65.     public void deleteProduct(@PathVariable Long id) {
  66.         dataService.deleteProduct(id);
  67.     }
  68. }

6. MyBatis缓存

MyBatis支持一级缓存和二级缓存，通过配置缓存可以提高数据访问的性能。

6.1 一级缓存

MyBatis的一级缓存是SqlSession级别的缓存，默认情况下是开启的。每个SqlSession在操作过程中会缓存查询结果，直到SqlSession被关闭或清理。

6.2 二级缓存

MyBatis的二级缓存是Mapper级别的缓存，需要在Mapper映射文件中配置。

  1. <!-- mapper/UserMapper.xml -->
  2. <mapper namespace="com.example.mapper.UserMapper">
  4.     <cache/>
  6.     <resultMap id="UserResultMap" type="com.example.model.User">
  7.         <id column="id" property="id" />
  8.         <result column="name" property="name" />
  9.         <result column="email" property="email" />
  10.     </resultMap>
  12.     <select id="getUserById" resultMap="UserResultMap">
  13.         SELECT * FROM user WHERE id = #{id}
  14.     </select>
  16.     <select id="getAllUsers" resultMap="UserResultMap">
  17.         SELECT * FROM user
  18.     </select>
  20.     <insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
  21.         INSERT INTO user (name, email) VALUES (#{name}, #{email})
  22.     </insert>
  24.     <update id="updateUser">
  25.         UPDATE user SET name = #{name}, email = #{email} WHERE id = #{id}
  26.     </update>
  28.     <delete id="deleteUser">
  29.         DELETE FROM user WHERE id = #{id}
  30.     </delete>
  31. </mapper>

7. 单元测试和集成测试

为了确保MyBatis与Spring Boot集成的代码质量和可靠性，开发者应编写单元测试和集成测试。

7.1 单元测试

使用JUnit和Mockito编写Mapper接口的单元测试。

  1. package com.example.mapper;
  3. import static org.mockito.Mockito.*;
  4. import static org.junit.jupiter.api.Assertions.*;
  5. import org.junit.jupiter.api.BeforeEach;
  6. import org.junit.jupiter.api.Test;
  7. import org.mockito.InjectMocks;
  8. import org.mockito.Mock;
  9. import org.mockito.MockitoAnnotations;
  10. import com.example.model.User;
  12. public class UserMapperTest {
  14.     @InjectMocks
  15.     private UserMapper userMapper;
  17.     @Mock
  18.     private SqlSession sqlSession;
  20.     @BeforeEach
  21.     public void setUp() {
  22.         MockitoAnnotations.openMocks(this);
  23.     }
  25.     @Test
  26.     public void testGetUserById() {
  27.         User user = new User();
  28.         user.setId(1L);
  29.         user.setName("John Doe");
  30.         user.setEmail("john.doe@example.com");
  32.         when(sqlSession.selectOne("com.example.mapper.UserMapper.getUserById", 1L)).thenReturn(user);
  34.         User foundUser = userMapper.getUserById(1L);
  35.         assertEquals("John Doe", foundUser.getName());
  36.         verify(sqlSession, times(1)).selectOne("com.example.mapper.UserMapper.getUserById", 1L);
  37.     }
  38. }

7.2 集成测试

使用Spring Boot的@SpringBootTest注解编写集成测试。

  1. package com.example.service;
  3. import static org.junit.jupiter.api.Assertions.*;
  4. import org.junit.jupiter.api.Test;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.boot.test.context.SpringBootTest;
  7. import com.example.model.User;
  9. @SpringBootTest
  10. public class UserServiceIntegrationTest {
  12.     @Autowired
  13.     private UserService userService;
  15.     @Test
  16.     public void testCreateUser() {
  17.         User user = new User();
  18.         user.setName("Jane Doe");
  19.         user.setEmail("jane.doe@example.com");
  21.         userService.createUser(user);
  23.         User createdUser = userService.getUserById(user.getId());
  24.         assertNotNull(createdUser);
  25.         assertEquals("Jane Doe", createdUser.getName());
  26.     }
  27. }

8. 总结

通过本文的介绍，我们详细了解了如何在Spring Boot项目中集成MyBatis，涵盖了基本配置、动态SQL、多数据源、分页、缓存以及单元测试和集成测试等多个方面。Spring Boot与MyBatis的结合，使得我们能够灵活高效地进行数据访问和处理，提升了开发效率和代码质量。