第 3-2 课：SpringBoot如何优雅地使⽤ MyBatis XML 配置版

本是古典何须时尚 2023-06-27 04:29 28阅读 0赞

MyBatis  是现如今最流⾏的  ORM  框架之⼀，我们先来了解⼀下什么是  ORM  框架。

### **ORM** 框架  ###

对象关系映射（ Object Relational Mapping ， ORM ）模式是⼀种为了解决⾯向对象与关系数据库存在的互不

匹配的现象的技术。简单的说， ORM  是通过使⽤描述对象和数据库之间映射的元数据，将程序中的对象⾃动

持久化到关系数据库中。

### 为什么需要 **ORM**？  ###

当你开发⼀个应⽤程序的时候（不使⽤  O/R Mapping ），可能会写不少数据访问层代码，⽤来从数据库保

存、删除、读取对象信息等；在  DAL  中写了很多的⽅法来读取对象数据、改变状态对象等任务，⽽这些代码

写起来总是重复的。针对这些问题  ORM  提供了解决⽅案，简化了将程序中的对象持久化到关系数据库中的

操作。

ORM  框架的本质是简化编程中操作数据库的编码，在  Java  领域发展到现在基本上就剩两家最为流⾏，⼀个

是宣称可以不⽤写⼀句  SQL  的  Hibernate ，⼀个是以动态  SQL  ⻅⻓的  MyBatis ，两者各有特点。在企业级系

统开发中可以根据需求灵活使⽤，会发现⼀个有趣的现象：传统企业⼤都喜欢使⽤  Hibernate ，⽽互联⽹⾏业

通常使⽤  MyBatis 。

### **MyBatis** 介绍  ###

MyBatis  是⼀款标准的  ORM  框架，被⼴泛的应⽤于各企业开发中。 MyBatis  最早是  Apache  的⼀个开源项⽬

iBatis ， 2010  年这个项⽬由  Apache Software Foundation  迁移到了  Google Code ，并且改名为  MyBatis ，

2013  年  11  ⽉⼜迁移到  Github 。从  MyBatis  的迁移史，也可以看出源码托管平台的发展史， GitHub  ⽬前已

经成为世界上最⼤的开源软件托管平台，建议⼤家多多关注这个全球最⼤的同性社交⽹站。

MyBatis  ⽀持普通的  SQL  查询，存储过程和⾼级映射的优秀持久层框架。 MyBatis  消除了⼏乎所有的  JDBC

代码和参数的⼿⼯设置以及对结果集的检索封装。 MaBatis  可以使⽤简单的  XML  或注解⽤于配置和原始映

射，将接⼝和  Java  的  POJO （ Plain Old Java Objects ，普通的  Java  对象）映射成数据库中的记录。

作为⼀款使⽤⼴泛的开源软件，它的特点有哪些呢？

### 优点 ###

*  SQL 被统⼀提取出来，便于统⼀管理和优化 
 *  SQL 和代码解耦，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰、更易维护、更易单元测试 
 *  提供映射标签，⽀持对象与数据库的 ORM 字段关系映射 
 *  提供对象关系映射标签，⽀持对象关系组件维护 
 *  灵活书写动态 SQL，⽀持各种条件来动态⽣成不同的 SQL

### 缺点  ###

*  编写 SQL 语句时⼯作量很⼤，尤其是字段多、关联表多时，更是如此 
 *  SQL 语句依赖于数据库，导致数据库移植性差

### **MyBatis** ⼏个重要的概念  ###

**Mapper**  配置 可以使⽤基于  XML  的  Mapper  配置⽂件来实现，也可以使⽤基于  Java  注解的  MyBatis  注解来

实现，甚⾄可以直接使⽤  MyBatis  提供的  API  来实现。

**Mapper**  接⼝ 是指⾃⾏定义的⼀个数据操作接⼝，类似于通常所说的  DAO  接⼝。早期的  Mapper  接⼝需要⾃

定义去实现，现在  MyBatis  会⾃动为  Mapper  接⼝创建动态代理对象。 Mapper  接⼝的⽅法通常与  Mapper

配置⽂件中的  select 、 insert 、 update 、 delete  等  XML  结点存在⼀⼀对应关系。

**Executor** ， MyBatis  中所有的  Mapper  语句的执⾏都是通过  Executor  进⾏的， Executor  是  MyBatis  的⼀个

核⼼接⼝。

**SqlSession** ，是  MyBatis  的关键对象，是执⾏持久化操作的独享，类似于  JDBC  中的  Connection ，

SqlSession  对象完全包含以数据库为背景的所有执⾏  SQL  操作的⽅法，它的底层封装了  JDBC  连接，可以

⽤  SqlSession  实例来直接执⾏被映射的  SQL  语句。

**SqlSessionFactory** ，是  MyBatis  的关键对象，它是单个数据库映射关系经过编译后的内存镜像。

SqlSessionFactory  对象的实例可以通过  SqlSessionFactoryBuilder  对象类获得，⽽

SqlSessionFactoryBuilder  则可以从  XML  配置⽂件或⼀个预先定制的  Confifiguration  的实例构建出。

MyBatis  的⼯作流程如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MjI3ODk2_size_16_color_FFFFFF_t_70][]

*  ⾸先加载 Mapper 配置的 SQL 映射⽂件，或者是注解的相关 SQL 内容。 
 *  创建会话⼯⼚，MyBatis 通过读取配置⽂件的信息来构造出会话⼯⼚（SqlSessionFactory）。 
 *  创建会话。根据会话⼯⼚，MyBatis 就可以通过它来创建会话对象（SqlSession），会话对象是⼀个接 ⼝，该接⼝中包含了对数据库操作的增、删、改、查⽅法。 
 *  创建执⾏器。因为会话对象本身不能直接操作数据库，所以它使⽤了⼀个叫做数据库执⾏器 （Executor）的接⼝来帮它执⾏操作。 
 *  封装 SQL 对象。在这⼀步，执⾏器将待处理的 SQL 信息封装到⼀个对象中（MappedStatement），该 对象包括 SQL 语句、输⼊参数映射信息（Java 简单类型、HashMap 或 POJO）和输出结果映射信息 （Java 简单类型、HashMap 或 POJO）。 
 *  操作数据库。拥有了执⾏器和 SQL 信息封装对象就使⽤它们访问数据库了，最后再返回操作结果，结 束流程。

在我们具体的使⽤过程中，就是按照上述的流程来执⾏。

### 什么是 **MyBatis-Spring-Boot-Starter**  ###

mybatis-spring-boot-starter  是  MyBatis  帮助我们快速集成  Spring Boot  提供的⼀个组件包，使⽤这个组件可

以做到以下⼏点：

*  构建独⽴的应⽤ 
 *  ⼏乎可以零配置 
 *  需要很少的 XML 配置

mybatis-spring-boot-starter  依赖于  MyBatis-Spring  和  Spring Boot ，最新版  1.3.2  需要  MyBatis-Spring

1.3  以上， Spring Boot  版本  1.5  以上。

注意  mybatis-spring-boot-starter  是  MyBatis  官⽅开发的  Starter ，⽽不是  Spring Boot  官⽅开发的启动包，

其实是  MyBatis  看  Spring Boot  市场使⽤度⾮常⾼，因此主动开发出  Starter  包进⾏集成，但这⼀集成确实解

决了很多问题，使⽤起来⽐以前简单很多。 mybatis-spring-boot-starter  主要提供了两种解决⽅案，⼀种是简

化后的  XML  配置版，⼀种是使⽤注解解决⼀切问题。

MyBatis  以前只有  XML  配置这种使⽤的形式，到了后来注解使⽤特别⼴泛， MyBatis  也顺应潮流提供了注解

的⽀持，从这⾥可以看出  MyBatis  ⼀直都跟随着主流技术的变化来完善⾃⼰。接下来给⼤家介绍⼀下如何使

⽤  XML  版本。

XML  版本保持映射⽂件的⽅式，最新版的使⽤主要体现在不需要实现  Dao  的实现层，系统会⾃动根据⽅法

名在映射⽂件中找到对应的  SQL 。

### 初始化脚本 ###

为了⽅便项⽬演示，需要在 test 仓库创建 users 表，脚本如下：

DROP TABLE IF EXISTS `users`;
    CREATE TABLE `users` (
     `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键id',
     `userName` varchar(32) DEFAULT NULL COMMENT '⽤户名',
     `passWord` varchar(32) DEFAULT NULL COMMENT '密码',
     `user_sex` varchar(32) DEFAULT NULL,
     `nick_name` varchar(32) DEFAULT NULL,
     PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

### 关键依赖包  ###

当然任何模式都需要⾸先引⼊  mybatis-spring-boot-starter  的  pom  ⽂件，现在最新版本是  1.3.2 。

<dependency>
     <groupId>org.mybatis.spring.boot</groupId>
     <artifactId>mybatis-spring-boot-starter</artifactId>
     <version>1.3.2</version>
    </dependency>

### **application** 配置  ###

application.properties  添加相关配置：

mybatis.config-location=classpath:mybatis/mybatis-config.xml
    mybatis.mapper-locations=classpath:mybatis/mapper/*.xml
    mybatis.type-aliases-package=com.neo.model
    spring.datasource.url=jdbc:mysql://localhost:3306/test?serverTimezone=UTC&useUnico
    de=true&characterEncoding=utf-8&useSSL=true
    spring.datasource.username=root
    spring.datasource.password=root
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

其中：

*  mybatis.confifig-location，配置 mybatis-confifig.xml 路径，mybatis-confifig.xml 中配置 MyBatis 基础属 性； 
 *  mybatis.mapper-locations，配置 Mapper 对应的 XML ⽂件路径； 
 *  mybatis.type-aliases-package，配置项⽬中实体类包路径； 
 *  spring.datasource.\*，数据源配置。

Spring Boot  启动时数据源会⾃动注⼊到  SqlSessionFactory  中，使⽤  SqlSessionFactory  构建

SqlSessionFactory ，再⾃动注⼊到  Mapper  中，最后我们直接使⽤  Mapper  即可。

## ##

### 启动类  ###

在启动类中添加对  Mapper  包扫描  @MapperScan ， Spring Boot  启动的时候会⾃动加载包路径下的

Mapper 。

@Spring BootApplication
    @MapperScan("com.neo.mapper")
    public class Application {
     public static void main(String[] args) {
     SpringApplication.run(Application.class, args);
     }
    }

或者直接在  Mapper  类上⾯添加注解  @Mapper ，建议使⽤上⾯那种，不然每个  mapper  加个注解也挺麻烦

的。

### 示例演示  ###

### **MyBatis** 公共属性  ###

mybatis-confifig.xml  主要配置常⽤的  typeAliases ，设置类型别名，为  Java  类型设置⼀个短的名字。它只和

XML  配置有关，存在的意义仅在于⽤来减少类完全限定名的冗余。

这样我们在使⽤  Mapper.xml  的时候，需要引⼊可以直接这样写：

resultType="Integer" 
    //或者
    parameterType="Long"

### 添加 **User** 的映射⽂件  ###

第⼀步，指明对应⽂件的  Mapper  类地址：

第⼆部，配置表结构和类的对应关系：

这⾥为了更好的贴近⼯作情况，将类的两个字段和数据库字段设置为不⼀致，其中⼀个使⽤了枚举。使⽤枚

举有⼀个⾮常⼤的优点，插⼊此属性的数据会⾃动进⾏校验，如果不是枚举的内容会报错。

第三步，写具体的  SQL  语句，⽐如这样：

<select id="getAll" resultMap="BaseResultMap" >
     SELECT 
     *
     FROM users
    </select>

MyBatis XML  有⼀个特点是可以复⽤  XML ，⽐如我们公⽤的⼀些  XML  ⽚段可以提取出来，在其他  SQL  中去

引⽤。例如：

<sql id="Base_Column_List" >
     id, userName, passWord, user_sex, nick_name
    </sql>
    <select id="getAll" resultMap="BaseResultMap" >
     SELECT 
     <include refid="Base_Column_List" />
     FROM users
    </select>

这个例⼦就是，上⾯定义了需要查询的表字段，下⾯  SQL  使⽤  include  引⼊，避免了写太多重复的配置内

容。

下⾯是常⽤的增、删、改、查的例⼦：

<select id="getOne" parameterType="Long" resultMap="BaseResultMap" >
     SELECT 
     <include refid="Base_Column_List" />
     FROM users
     WHERE id = #{id}
    </select>
    <insert id="insert" parameterType="com.neo.model.User" >
     INSERT INTO 
     users
     (userName,passWord,user_sex) 
     VALUES
     (#{userName}, #{passWord}, #{userSex})
    </insert>
    <update id="update" parameterType="com.neo.model.User" >
     UPDATE 
     users 
     SET 
     <if test="userName != null">userName = #{userName},</if>
     <if test="passWord != null">passWord = #{passWord},</if>
     nick_name = #{nickName}
     WHERE 
     id = #{id}
    </update>
    <delete id="delete" parameterType="Long" >
     DELETE FROM
     users 
     WHERE 
     id =#{id}
    </delete>

上⾯  update  的  SQL  使⽤了  if  标签，可以根据不同的条件⽣产动态  SQL ，这就是  MyBatis  最⼤的特点。

## ##

### 编写 **Dao** 层的代码 ###

public interface UserMapper {
     
     List<UserEntity> getAll();
     
     UserEntity getOne(Long id);
     void insert(UserEntity user);
     void update(UserEntity user);
     void delete(Long id);
    }

注意：这⾥的⽅法名需要和  XML  配置中的  id  属性⼀致，不然会找不到⽅法去对应执⾏的  SQL 。

### 测试使⽤  ###

按照  Spring  ⼀贯使⽤形式，直接将对应的  Mapper  注⼊即可。

@Resource
    private UserMapper userMapper;

如果使⽤的是  Idea ，这块的注解经常会报 “could not autowire” ， Eclipse  却没有问题，其实代码是正确的，这

是  Idea  的误报。可以选择降低  Autowired  检测的级别，不要提示就好。

在  File | Settings | Editor | Inspections  选项中使⽤搜索功能找到  Autowiring for Bean Class ，将  Severity  的

级别由之前的  error  改成  warning即可。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MjI3ODk2_size_16_color_FFFFFF_t_70 1][]

接下来直接使⽤  userMapper  进⾏数据库操作即可。

@Test
    public void testUser() {
     //增加
     userMapper.insert(new User("aa", "a123456", UserSexEnum.MAN));
     //删除
     int count=userMapper.delete(2l);
     User user = userMapper.getOne(1l);
     user.setNickName("smile");
     //修改
     userMapper.update(user);
     //查询
     List<User> users = userMapper.getAll();
    }

在示例代码中，写了两份的使⽤示例，⼀个是  Test ，⼀个在  Controller  层，⽅便⼤家下载查看。

### 分⻚查询  ###

多条件分⻚查询是实际⼯作中最常使⽤的功能之⼀， MyBatis  特别擅⻓处理这类的问题。在实际⼯作中，会

对分⻚进⾏简单的封装，⽅便前端使⽤。另外在  Web  开发规范使⽤中， Web  层的参数会以  param  为后缀的 GitChat

对象进⾏传参，以  result  结尾的实体类封装返回的数据。

下⾯给⼤家以  User  多条件分⻚查询为例进⾏讲解。

先定义⼀个分⻚的基础类：

public class PageParam {
     private int beginLine; //起始⾏
     private Integer pageSize = 3;
     private Integer currentPage=0; // 当前⻚
     //getter setter省略
     public int getBeginLine() {
     return pageSize*currentPage;//⾃动计算起始⾏
     }
    }

默认每⻚  3  条记录，可以根据前端传参进⾏修改。

user  的查询条件参数类继承分⻚基础类：

public class UserParam extends PageParam{
     private String userName;
     private String userSex;
     //getter setter省略
    }

接下来配置具体的  SQL ，先将查询条件提取出来。

<sql id="Base_Where_List">
     <if test="userName != null and userName != ''">
     and userName = #{userName}
     </if>
     <if test="userSex != null and userSex != ''">
     and user_sex = #{userSex}
     </if>
    </sql>

从对象  UserParam  中获取分⻚信息和查询条件，最后进⾏组合。 GitChat

<select id="getList" resultMap="BaseResultMap" parameterType="com.neo.param.UserPa
    ram">
     select
     <include refid="Base_Column_List" />
     from users
     where 1=1
     <include refid="Base_Where_List" />
     order by id desc
     limit #{beginLine} , #{pageSize}
    </select>

前端需要展示总共的⻚码，因此需要统计出查询结果的总数。

<select id="getCount" resultType="Integer" parameterType="com.neo.param.UserParam"
    >
     select
     count(1)
     from users
     where 1=1
     <include refid="Base_Where_List" />
    </select>

Mapper  中定义的两个⽅法和配置⽂件相互对应。

public interface UserMapper {
     List<UserEntity> getList(UserParam userParam);
     int getCount(UserParam userParam);
    }

具体使⽤：

@Test
    public void testPage() {
     UserParam userParam=new UserParam();
     userParam.setUserSex("WOMAN");
     userParam.setCurrentPage(1);
     List<UserEntity> users=userMapper.getList(userParam);
     long count=userMapper.getCount(userParam);
     Page page = new Page(userParam,count,users);
     System.out.println(page);
    }

在实际使⽤中，只需要传⼊  CurrentPage  参数即可，默认  0  就是第⼀⻚，传  1  就是第⼆⻚的内容，最后将结

果封装为  Page  返回给前端。

public class Page<E> implements Serializable {
     private int currentPage = 0; //当前⻚数
     private long totalPage; //总⻚数
     private long totalNumber; //总记录数
     private List<E> list; //数据集
    }

Page  将分⻚信息和数据信息进⾏封装，⽅便前端显示第⼏⻚、总条数和数据，这样分⻚功能就完成了。

### 多数据源处理  ###

接下来为⼤家介绍如何使⽤  MyBatis  配置多数据源使⽤。

### 配置⽂件  ###

⾸先我们需要配置两个不同的数据源：

mybatis.config-location=classpath:mybatis/mybatis-config.xml
    spring.datasource.one.jdbc-url=jdbc:mysql://localhost:3306/test1?serverTimezone=UT
    C&useUnicode=true&characterEncoding=utf-8&useSSL=true
    spring.datasource.one.username=root
    spring.datasource.one.password=root
    spring.datasource.one.driver-class-name=com.mysql.cj.jdbc.Driver
    spring.datasource.two.jdbc-url=jdbc:mysql://localhost:3306/test2?serverTimezone=UT
    C&useUnicode=true&characterEncoding=utf-8&useSSL=true
    spring.datasource.two.username=root
    spring.datasource.two.password=root
    spring.datasource.two.driver-class-name=com.mysql.cj.jdbc.Driver

注意，需要提前在  test1  和  test2  库中创建好  User  表结构。

第⼀个数据源以  spring.datasource.one.\*  为前缀连接数据库  test1 ，第⼆个数据源以  spring.datasource.two.\*

为前缀连接数据库  test2 。

同时需要将上述的  UserMapper.xml  ⽂件复制两份到  resources/mybatis/mapper/one  和

resources/mybatis/mapper/two  ⽬录下各⼀份。

### 数据源配置  ###

为两个数据源创建不同的  Mapper  包路径，将以前的  UserMapper  复制到包  com.neo.mapper.one  和

com.neo.mapper.two  路径下，并且分别重命名为： User1Mapper 、 User2Mapper 。

配置第⼀个数据源，新建  DataSource1Confifig 。

⾸先加载配置的数据源：

@Bean(name = "oneDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.one")
    @Primary
    public DataSource testDataSource() {
     return DataSourceBuilder.create().build();
    }

注意，在多数据源中只能指定⼀个  @Primary  作为默认的数据源使⽤。

根据创建的数据源，构建对应的  SqlSessionFactory 。

@Bean(name = "oneSqlSessionFactory")
    @Primary
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("oneDataSource") DataSou
    rce dataSource) throws Exception {
     SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
     bean.setDataSource(dataSource);
     bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources
    ("classpath:mybatis/mapper/one/*.xml"));
     return bean.getObject();
    }

代码中需要指明需要加载的  Mapper xml  ⽂件。

同时将数据源添加到事务中。

@Bean(name = "oneTransactionManager")
    @Primary
    public DataSourceTransactionManager testTransactionManager(@Qualifier("oneDataSour
    ce") DataSource dataSource) {
     return new DataSourceTransactionManager(dataSource);
    }

接下来将上⾯创建的  SqlSessionFactory  注⼊，创建我们在  Mapper  中需要使⽤的  SqlSessionTemplate 。

@Bean(name = "oneSqlSessionTemplate")
    @Primary
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("oneSqlSessionFactory"
    ) SqlSessionFactory sqlSessionFactory) throws Exception {
     return new SqlSessionTemplate(sqlSessionFactory);
    }

最后将上⾯创建的  SqlSessionTemplate  注⼊到对应的  Mapper  包路径下，这样这个包下⾯的  Mapper  都会使

⽤第⼀个数据源来进⾏数据库操作。

@Configuration
    @MapperScan(basePackages = "com.neo.mapper.one", sqlSessionTemplateRef = "oneSqlS
    essionTemplate")
    public class OneDataSourceConfig {
     ...
    }

*  basePackages 指明 Mapper 地址。 
 *  sqlSessionTemplateRef 指定 Mapper 路径下注⼊的 sqlSessionTemplate。

### 第⼆个数据源配置 ###

DataSource2Confifig  的配置和上⾯类似，⽅法上需要去掉  @Primary  注解，替换对应的数据源和  Mapper  路

径即可。下⾯是  DataSource2Confifig  完整示例：

@Configuration
    @MapperScan(basePackages = "com.neo.mapper.two", sqlSessionTemplateRef = "twoSqlS
    essionTemplate")
    public class DataSource2Config {
     @Bean(name = "twoDataSource")
     @ConfigurationProperties(prefix = "spring.datasource.two")
     public DataSource testDataSource() {
     return DataSourceBuilder.create().build();
     }
     @Bean(name = "twoSqlSessionFactory")
     public SqlSessionFactory testSqlSessionFactory(@Qualifier("twoDataSource") Dat
    aSource dataSource) throws Exception {
     SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
     bean.setDataSource(dataSource);
     bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResou
    rces("classpath:mybatis/mapper/two/*.xml"));
     return bean.getObject();
     }
     @Bean(name = "twoTransactionManager")
     public DataSourceTransactionManager testTransactionManager(@Qualifier("twoData
    Source") DataSource dataSource) {
     return new DataSourceTransactionManager(dataSource);
     }
     @Bean(name = "twoSqlSessionTemplate")
     public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("twoSqlSessionFact
    ory") SqlSessionFactory sqlSessionFactory) throws Exception {
     return new SqlSessionTemplate(sqlSessionFactory);
     }
    }

从上⾯的步骤我们可以总结出来，创建多数据源的过程就是：⾸先创建  DataSource ，注⼊到 SqlSessionFactory 中，再创建事务，将  SqlSessionFactory  注⼊到创建的  SqlSessionTemplate  中，最后将 SqlSessionTemplate 注⼊到对应的  Mapper  包路径下。其中需要指定分库的  Mapper  包路径。

注意，在多数据源的情况下，我们不需要在启动类添加： @MapperScan("com.xxx.mapper")  的注解。

这样  MyBatis  多数据源的配置就完成了，如果有更多的数据源请参考第⼆个数据源的配置即可。

## ##

### 测试  ###

配置好多数据源之后，在项⽬中想使⽤哪个数据源就把对应数据源注⼊到类中使⽤即可。

@RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserMapperTest {
     @Autowired
     private User1Mapper user1Mapper;
     @Autowired
     private User2Mapper user2Mapper;
     @Test
     public void testInsert() throws Exception {
     user1Mapper.insert(new User("aa111", "a123456", UserSexEnum.MAN));
     user1Mapper.insert(new User("bb111", "b123456", UserSexEnum.WOMAN));
     user2Mapper.insert(new User("cc222", "b123456", UserSexEnum.MAN));
     }
    }

上⾯的测试类中注⼊了两个不同的  Mapper ，对应了不同的数据源。在第⼀个数据源中插⼊了两条数据，第

⼆个数据源中插⼊了⼀条信息，运⾏测试⽅法后查看数据库 1 有两条数据，数据库 2 有⼀条数据，证明多数据

源测试成功。

### 总结  ###

这节课介绍了  ORM  框架 和  MyBatis  框架相关概念介绍，以⽤户数据为例演示了  MyBatis  的增、删、改、

查，以及分⻚查询、多数据源处理等常⻅场景。通过上⾯的示例可以发现  MyBatis  将执⾏  SQL  和代码做了隔

离，保证代码处理和  SQL  的相对独⽴，层级划分⽐较清晰， MyBatis  对动态  SQL  ⽀持⾮常友好，可以在

XML  ⽂件中复⽤代码⾼效编写动态  SQL 。

[点击这⾥下载源码][Link 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MjI3ODk2_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200103145149390.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MjI3ODk2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MjI3ODk2_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200103151435230.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MjI3ODk2,size_16,color_FFFFFF,t_70
[Link 1]: https://github.com/ityouknow/spring-boot-leaning/tree/gitbook_column2.0