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

 

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 的⼯作流程如下：

• ⾸先加载 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 配置有关，存在的意义仅在于⽤来减少类完全限定名的冗余。

 

<configuration>
 <typeAliases>
 <typeAlias alias="Integer" type="java.lang.Integer" />
 <typeAlias alias="Long" type="java.lang.Long" />
 <typeAlias alias="HashMap" type="java.util.HashMap" />
 <typeAlias alias="LinkedHashMap" type="java.util.LinkedHashMap" />
 <typeAlias alias="ArrayList" type="java.util.ArrayList" />
 <typeAlias alias="LinkedList" type="java.util.LinkedList" />
 </typeAliases>
</configuration>

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

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

添加 User 的映射⽂件

 

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

<mapper namespace="com.neo.mapper.UserMapper" >

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

<resultMap id="BaseResultMap" type="com.neo.model.User" >
 <id column="id" property="id" jdbcType="BIGINT" />
 <result column="userName" property="userName" jdbcType="VARCHAR" />
 <result column="passWord" property="passWord" jdbcType="VARCHAR" />
 <result column="user_sex" property="userSex" javaType="com.neo.enums.UserSexEn
um"/>
 <result column="nick_name" property="nickName" jdbcType="VARCHAR" />
</resultMap>

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

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

 

第三步，写具体的 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即可。

接下来直接使⽤ 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 。

点击这⾥下载源码