Spring Boot MyBatis 深度解析与实践

简介

在当今的 Java 开发领域，构建高效、灵活且易于维护的数据库访问层至关重要。Spring Boot 作为一款快速构建 Spring 应用的框架，极大地简化了 Spring 项目的搭建过程。而 MyBatis 是一款优秀的持久层框架，它提供了强大的 SQL 映射功能，让开发者能够灵活地操作数据库。将 Spring Boot 与 MyBatis 结合使用，可以充分发挥两者的优势，快速搭建出功能强大的数据库访问层。本文将详细介绍 Spring Boot MyBatis 的基础概念、使用方法、常见实践以及最佳实践，帮助读者深入理解并高效运用这一组合。

目录

1. Spring Boot MyBatis 基础概念
   • Spring Boot 简介
   • MyBatis 简介
   • Spring Boot 与 MyBatis 结合的优势
2. Spring Boot MyBatis 使用方法
   • 项目搭建
   • 配置 MyBatis
   • 编写数据访问层代码
   • 测试数据库访问
3. Spring Boot MyBatis 常见实践
   • 多数据源配置
   • 分页处理
   • 事务管理
4. Spring Boot MyBatis 最佳实践
   • 代码结构优化
   • SQL 性能优化
   • 缓存策略
5. 小结
6. 参考资料

Spring Boot MyBatis 基础概念

Spring Boot 简介

Spring Boot 是 Spring 框架的一个子项目，它致力于简化 Spring 应用的创建过程。通过自动配置和约定优于配置的理念，Spring Boot 让开发者能够快速搭建出生产级别的 Spring 应用，无需繁琐的 XML 配置。它内置了 Tomcat、Jetty 等服务器，支持多种开发语言，并且提供了丰富的 Starter 依赖，方便开发者快速集成各种第三方库。

MyBatis 简介

MyBatis 是一个支持普通 SQL 查询、存储过程和高级映射的持久层框架。它使用 XML 或注解来配置和映射语句，将 SQL 从 Java 代码中分离出来，提高了代码的可读性和可维护性。MyBatis 允许开发者灵活地编写 SQL 语句，支持动态 SQL，能够很好地满足复杂业务场景下的数据库操作需求。

Spring Boot 与 MyBatis 结合的优势

1. 简化配置：Spring Boot 的自动配置功能与 MyBatis 相结合，大大减少了配置文件的编写，降低了开发成本。
2. 灵活性：MyBatis 的灵活 SQL 映射功能，让开发者可以根据具体业务需求编写复杂的 SQL 语句，而 Spring Boot 提供的 IoC 和 AOP 等功能，进一步增强了应用的可扩展性。
3. 高效开发：两者结合能够快速搭建数据库访问层，提高开发效率，同时保证应用的性能和质量。

Spring Boot MyBatis 使用方法

项目搭建

1. 创建 Spring Boot 项目 使用 IDEA 或 Eclipse 等开发工具，通过 Spring Initializr 创建一个新的 Spring Boot 项目。在创建过程中，选择添加 Web、MyBatis、MySQL Driver 等依赖。

2. 添加依赖 如果手动添加依赖，在 pom.xml 文件中添加以下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.2.0</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

配置 MyBatis

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

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

1. 配置 MyBatis 在 application.properties 文件中配置 MyBatis 的相关属性：

mybatis.mapper-locations=classpath:/mapper/*.xml
mybatis.type-aliases-package=com.example.demo.entity

其中，mybatis.mapper-locations 指定了 MyBatis 映射文件的位置，mybatis.type-aliases-package 指定了实体类的包名。

编写数据访问层代码

1. 创建实体类 在 com.example.demo.entity 包下创建实体类，例如 User.java：

package com.example.demo.entity;

public class User {
    private Long id;
    private String username;
    private String password;

    // getters and setters
}

1. 创建 Mapper 接口 在 com.example.demo.mapper 包下创建 Mapper 接口，例如 UserMapper.java：

package com.example.demo.mapper;

import com.example.demo.entity.User;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
public interface UserMapper {
    List<User> findAll();
    User findById(Long id);
    void insert(User user);
    void update(User user);
    void delete(Long id);
}

1. 编写映射文件 在 resources/mapper 目录下创建 UserMapper.xml 文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.mapper.UserMapper">
    <select id="findAll" resultType="User">
        SELECT * FROM user
    </select>
    <select id="findById" resultType="User">
        SELECT * FROM user WHERE id = #{id}
    </select>
    <insert id="insert" keyProperty="id" useGeneratedKeys="true">
        INSERT INTO user (username, password) VALUES (#{username}, #{password})
    </insert>
    <update id="update">
        UPDATE user SET username = #{username}, password = #{password} WHERE id = #{id}
    </update>
    <delete id="delete">
        DELETE FROM user WHERE id = #{id}
    </delete>
</mapper>

测试数据库访问

1. 创建 Service 层 在 com.example.demo.service 包下创建 UserService.java：

package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public List<User> findAll() {
        return userMapper.findAll();
    }

    public User findById(Long id) {
        return userMapper.findById(id);
    }

    public void insert(User user) {
        userMapper.insert(user);
    }

    public void update(User user) {
        userMapper.update(user);
    }

    public void delete(Long id) {
        userMapper.delete(id);
    }
}

1. 创建 Controller 层 在 com.example.demo.controller 包下创建 UserController.java：

package com.example.demo.controller;

import com.example.demo.entity.User;
import com.example.demo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> findAll() {
        return userService.findAll();
    }

    @GetMapping("/{id}")
    public User findById(@PathVariable Long id) {
        return userService.findById(id);
    }

    @PostMapping
    public void insert(@RequestBody User user) {
        userService.insert(user);
    }

    @PutMapping
    public void update(@RequestBody User user) {
        userService.update(user);
    }

    @DeleteMapping("/{id}")
    public void delete(@PathVariable Long id) {
        userService.delete(id);
    }
}

1. 运行测试 启动 Spring Boot 应用，通过浏览器或 Postman 等工具访问接口，测试数据库的增删改查操作。

Spring Boot MyBatis 常见实践

多数据源配置

在实际项目中，可能需要连接多个数据库。可以通过以下步骤实现多数据源配置： 1. 创建数据源配置类

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = "com.example.demo.mapper.ds1", sqlSessionFactoryRef = "ds1SqlSessionFactory")
public class DataSource1Config {

    @Bean
    public DataSource ds1DataSource() {
        return DataSourceBuilder.create()
             .url("jdbc:mysql://localhost:3306/ds1")
             .driverClassName("com.mysql.cj.jdbc.Driver")
             .username("root")
             .password("root")
             .build();
    }

    @Bean
    public SqlSessionFactory ds1SqlSessionFactory(@Qualifier("ds1DataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }

    @Bean
    public DataSourceTransactionManager ds1TransactionManager(@Qualifier("ds1DataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean
    public SqlSessionTemplate ds1SqlSessionTemplate(@Qualifier("ds1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

1. 重复上述步骤配置第二个数据源

@Configuration
@MapperScan(basePackages = "com.example.demo.mapper.ds2", sqlSessionFactoryRef = "ds2SqlSessionFactory")
public class DataSource2Config {

    @Bean
    public DataSource ds2DataSource() {
        return DataSourceBuilder.create()
             .url("jdbc:mysql://localhost:3306/ds2")
             .driverClassName("com.mysql.cj.jdbc.Driver")
             .username("root")
             .password("root")
             .build();
    }

    @Bean
    public SqlSessionFactory ds2SqlSessionFactory(@Qualifier("ds2DataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }

    @Bean
    public DataSourceTransactionManager ds2TransactionManager(@Qualifier("ds2DataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean
    public SqlSessionTemplate ds2SqlSessionTemplate(@Qualifier("ds2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

分页处理

MyBatis 提供了多种分页方式，常见的有以下两种： 1. 使用 LIMIT 关键字 在 SQL 语句中直接使用 LIMIT 关键字进行分页：

<select id="findByPage" resultType="User">
    SELECT * FROM user LIMIT #{offset}, #{limit}
</select>

1. 使用分页插件 例如，使用 PageHelper 插件实现分页：
   • 添加依赖：

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>1.2.12</version>
</dependency>

- 配置插件：

pagehelper.helperDialect=mysql
pagehelper.reasonable=true
pagehelper.supportMethodsArguments=true
pagehelper.params=count=countSql

- 使用插件：

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public PageInfo<User> findByPage(int pageNum, int pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        List<User> userList = userMapper.findAll();
        return new PageInfo<>(userList);
    }
}

事务管理

在 Spring Boot 中使用 MyBatis 进行事务管理非常简单，只需在 Service 层方法上添加 @Transactional 注解即可：

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    @Transactional
    public void insertAndUpdate(User user) {
        userMapper.insert(user);
        // 假设这里有更新操作
        userMapper.update(user);
    }
}

Spring Boot MyBatis 最佳实践

代码结构优化

1. 分层架构 遵循清晰的分层架构，将 Controller、Service、Mapper 和 Entity 等层分离，各层职责明确，提高代码的可维护性和可扩展性。

2. 接口与实现分离 在 Service 层和 Mapper 层使用接口定义方法，然后提供具体的实现类，方便代码的替换和扩展。

SQL 性能优化

1. 索引优化 对频繁查询的字段添加合适的索引，提高查询效率。

2. 避免全表扫描 在编写 SQL 时，尽量避免使用 SELECT *，只查询需要的字段，减少数据传输量。

3. 批量操作 对于批量插入、更新等操作，使用 MyBatis 的批量操作功能，减少数据库交互次数。

缓存策略

1. 一级缓存 MyBatis 内置了一级缓存，在同一个 SqlSession 中，相同的查询会直接从缓存中获取结果。

2. 二级缓存 开启二级缓存，在多个 SqlSession 之间共享缓存。在 Mapper 接口或映射文件中配置二级缓存：

@CacheNamespace
public interface UserMapper {
    //...
}

或在 UserMapper.xml 中配置：

<cache eviction="LRU" flushInterval="60000" size="512" readOnly="true"/>

小结

本文详细介绍了 Spring Boot MyBatis 的基础概念、使用方法、常见实践以及最佳实践。通过将 Spring Boot 的快速搭建特性与 MyBatis 的灵活 SQL 映射功能相结合，开发者能够高效地构建出稳定、高性能的数据库访问层。在实际项目中，合理运用多数据源配置、分页处理、事务管理等常见实践，以及代码结构优化、SQL 性能优化和缓存策略等最佳实践，能够进一步提升应用的质量和性能。希望本文能够帮助读者更好地理解和使用 Spring Boot MyBatis，在实际开发中取得更好的效果。

参考资料

1. Spring Boot 官方文档
2. MyBatis 官方文档
3. MyBatis-Spring-Boot-Starter 官方文档