第01篇_MyBatis基础应用

第01章_MyBatis概述

第一节 MyBatis简介

1. 什么是MyBatis？

MyBatis 是一个开源的、基于 Java 的持久层框架，它简化了数据库操作的复杂性，同时又提供了灵活的 SQL 映射机制。

2. MyBatis入门案例

1) 前置准备

数据库中有一张 User 表，下面将使用 MyBatis 对其进行查询操作：

​x
1
create database test01 charset utf8;
2

3
create table if not exists user(
4
    id int(11) unsigned not null auto_increment comment '用户编号'
5
    ,username varchar(32) not null comment '用户名称'
6
    ,birthday varchar(38) not null comment '用户生日'
7
    ,sex char(2) not null comment '性别，0男1女'
8
    ,address varchar(255) null comment '用户地址'
9
    ,primary key(id)
10
    )engine=innodb default charset=utf8 comment='用户表';
11

12
insert into user(username, birthday, sex, address) values('hyx', '1999-09-13', '0', '深圳市南山区');
13
commit;
14

该表对应的实体类和 DAO 接口如下：

21
1
// 实体类
2
package org.example.model;
3
import java.io.Serializable;
4
import java.sql.Date;
5
@Data
6
public class User implements Serializable {
7
    private Integer id;
8
    private String username;
9
    private Date birthday;
10
    private String sex;
11
    private String address;
12
}
13

14
// DAO 接口
15
package org.example.dao;
16
import org.example.model.User;
17
import java.util.List;
18
public interface UserDao {
19
    List<User> findAll();
20
}
21

如果使用传统的 JDBC 或 JdbcTemplate ，那么下一步应该实现 DAO 接口，编写具体的 CURD 方法。

但是，使用 MyBatis 后，你无需自己手写这些繁琐的实现类，这些 MyBatis 都会使用动态代理技术帮你生成。

2) 依赖导入

引入 MyBatis 相关的依赖如下：

36
1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns="http://maven.apache.org/POM/4.0.0"
3
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5
    <modelVersion>4.0.0</modelVersion>
6

7
    <groupId>org.example</groupId>
8
    <artifactId>demo01</artifactId>
9
    <version>1.0-SNAPSHOT</version>
10

11
    <dependencies>
12
        <!-- MyBatis 依赖-->
13
        <dependency>
14
            <groupId>org.mybatis</groupId>
15
            <artifactId>mybatis</artifactId>
16
            <version>3.4.5</version>
17
        </dependency>
18
        
19
        <!-- MySql JDBC 驱动-->
20
        <dependency>
21
            <groupId>mysql</groupId>
22
            <artifactId>mysql-connector-java</artifactId>
23
            <version>5.1.6</version>
24
            <scope>runtime</scope>
25
        </dependency>
26

27
        <!-- Junit 用于测试-->
28
        <dependency>
29
            <groupId>junit</groupId>
30
            <artifactId>junit</artifactId>
31
            <version>4.10</version>
32
            <scope>test</scope>
33
        </dependency>
34
    </dependencies>
35

36
</project>

如果你使用的是Oracle或SqlServer数据库，应该切换如下驱动：

12
1
<dependency>
2
    <groupId>com.microsoft.sqlserver</groupId>
3
    <artifactId>sqljdbc4</artifactId>
4
    <version>4.0</version>
5
</dependency>
6

7
<dependency>
8
    <groupId>com.oracle</groupId>
9
    <artifactId>ojdbc14</artifactId>
10
    <version>10.2.0.5.0</version>
11
</dependency>
12

3) 核心配置

在类路径下新建src\main\resources\mybatis-config.xml配置文件，用来配置 MyBatis 的相关属性和行为：

24
1
<?xml version="1.0" encoding="UTF-8"?>
2
<!DOCTYPE configuration
3
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
5
<configuration>
6
    <!-- 环境配置 -->
7
    <environments default="dev">
8
        <environment id="dev">
9
            <transactionManager type="JDBC"></transactionManager>
10
            <!-- 数据源配置 -->
11
            <dataSource type="POOLED">
12
                <property name="driver"   value="com.mysql.jdbc.Driver"/>
13
                <property name="url"      value="jdbc:mysql://42.192.223.129:3306/test01"/>
14
                <property name="username" value="root"/>
15
                <property name="password" value="root"/>
16
            </dataSource>
17
        </environment>
18
    </environments>
19

20
    <!-- 映射文件扫描 -->
21
    <mappers>
22
        <mapper resource="org/example/dao/UserDao.xml"/>
23
    </mappers>
24
</configuration>

如果你使用的是Oracle或SqlServer数据库，JDBC连接四要素应修改如下：

9
1
    <property name="driver" value="oracle.jdbc.driver.OracleDriver"/>
2
    <property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:ORCLONE"/>
3
    <property name="username" value="kbssfms"/>
4
    <property name="password" value="kbssfms"/>
5

6
    <property name ="driverClassName" value ="com.microsoft.sqlserver.jdbc.SQLServerDriver"></property>
7
    <property name ="url" value ="jdbc:sqlserver://127.0.0.1:1433;DatabaseName=kbssfms"></property>
8
    <property name ="username" value ="sa"></property>
9
    <property name ="password" value ="Sa147741"></property>

4) 映射配置

在类路径下新建src\main\resources\org\example\dao\UserDao.xml配置文件，用于配置执行的SQL语句和结果集映射方式。

11
1
<?xml version="1.0" encoding="UTF-8"?>
2
<!DOCTYPE mapper
3
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5
<mapper namespace="org.example.dao.UserDao">
6

7
    <!-- 查询所有用户 -->
8
    <select id="findAll" resultType="org.example.model.User">
9
        SELECT * FROM user
10
    </select>
11
</mapper>

5) 简单测试：使用MyBatis查询

编写一个简单的测试类进行测试：

46
1
package org.example.dao.test;
2

3
import org.apache.ibatis.io.Resources;
4
import org.apache.ibatis.session.SqlSession;
5
import org.apache.ibatis.session.SqlSessionFactory;
6
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
7
import org.example.dao.UserDao;
8
import org.example.model.User;
9

10
import java.io.InputStream;
11
import java.util.List;
12

13
public class MybatisTest {
14

15
    public static void main(String[] args) throws Exception {
16
        //1.读取主配置文件
17
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
18

19
        //2.创建 SqlSessionFactoryBuilder
20
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
21

22
        //3. 构建 SqlSessionFactory
23
        SqlSessionFactory factory = builder.build(in);
24

25
        //4. 打开会话
26
        SqlSession session = factory.openSession();
27

28
        //5. 获取代理对象
29
        UserDao userDao = session.getMapper(UserDao.class);
30

31
        //6. 使用代理对象执行查询所有方法
32
        List<User> users = userDao.findAll();
33
        for (User user : users) {
34
            System.out.println(user);
35
        }
36

37
        //7. 释放资源
38
        if (session != null) {
39
            session.close();
40
        }
41
        if (in != null) {
42
            in.close();
43
        }
44

45
    }
46
}

运行结果如下：

注意：

1. 上述案例的完整工程代码可参考附件 mybatis-demo/demo01 工程！

3. MyBatis核心类简介

1) SqlSessionFactoryBuilder

SqlSessionFactoryBuilder使用了构建者模式，用于解析配置文件和构建SqlSessionFactory，支持的构建方法如下：

8
1
// 方式1：基于配置文件构建（mybatis-config.xml及引用的 Mapper 配置）
2
SqlSessionFactory build(InputStream inputStream)
3
SqlSessionFactory build(InputStream inputStream, String environment)
4
SqlSessionFactory build(InputStream inputStream, Properties properties)
5
SqlSessionFactory build(InputStream inputStream, String env, Properties props)
6

7
// 方式2：基于Java配置构建
8
SqlSessionFactory build(Configuration config)

方式1已经在入门案例中介绍，方式2基于Java配置构建方式示例如下：

18
1
// 获取数据源
2
DataSource dataSource = BaseDataTest.createBlogDataSource();
3

4
// 创建一个环境（使用JDBC事务管理器）
5
Environment environment = new Environment("development", new JdbcTransactionFactory(), dataSource);
6

7
// 创建一个配置
8
Configuration configuration = new Configuration(environment);
9
configuration.setLazyLoadingEnabled(true);
10
configuration.setEnhancementEnabled(true);
11
configuration.getTypeAliasRegistry().registerAlias(Blog.class);
12
configuration.getTypeAliasRegistry().registerAlias(Post.class);
13
configuration.getTypeAliasRegistry().registerAlias(Author.class);
14
configuration.addMapper(BoundBlogMapper.class);
15
configuration.addMapper(BoundAuthorMapper.class);
16

17
// 构建SqlSessionFactory
18
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(configuration);

2) SqlSessionFactory

SqlSessionFactory使用了工厂模式，用于管理配置信息和创建SqlSession，支持的创建方法如下：

19
1
// 默认创建方法
2
// 事务不自动提交、使用默认事务隔离级别、使用SIMPLE执行器、从当前环境配置的DataSource 实例中获取 Connection 对象
3
SqlSession openSession() 
4

5
// 支持设置是否自动提交、事务隔离级别、连接等
6
SqlSession openSession(boolean autoCommit)
7
SqlSession openSession(Connection connection)
8
SqlSession openSession(TransactionIsolationLevel level) 
9

10
// 支持选择不同的执行器
11
// SIMPLE：每个语句的执行创建一个新的预处理语句
12
// REUSE： 复用预处理语句
13
// BATCH： 批量执行更新语句
14
SqlSession openSession(ExecutorType execType, TransactionIsolationLevel level)
15
SqlSession openSession(ExecutorType execType)
16
SqlSession openSession(ExecutorType execType, boolean autoCommit)
17
SqlSession openSession(ExecutorType execType, Connection connection)
18
Configuration getConfiguration();
19

3) SqlSession

SqlSession是 MyBatis 的核心组件之一，用于执行 SQL 语句、管理事务以及获取映射器对象（Mapper）等，主要方法如下：

48
1
// 1. 语句执行方法
2
<T> T selectOne(String statement, Object parameter)
3
<E> List<E> selectList(String statement, Object parameter)
4
<T> Cursor<T> selectCursor(String statement, Object parameter) // 游标形式：可以借助迭代器实现数据的惰性加载
5
<K,V> Map<K,V> selectMap(String statement, Object parameter, String mapKey)
6
int insert(String statement, Object parameter) // insert、update 以及 delete 方法返回的值表示受该语句影响的行数
7
int update(String statement, Object parameter)
8
int delete(String statement, Object parameter)
9

10
// 2. 语句执行方法(不需要参数的重载形式)
11
<T> T selectOne(String statement)
12
<E> List<E> selectList(String statement)
13
<T> Cursor<T> selectCursor(String statement)
14
<K,V> Map<K,V> selectMap(String statement, String mapKey)
15
int insert(String statement)
16
int update(String statement)
17
int delete(String statement)
18

19
// 3. select方法的高级版本：允许你限制返回行数的范围，或是提供自定义结果处理逻辑，通常在数据集非常庞大的情形下使用。
20
<E> List<E> selectList (String statement, Object parameter, RowBounds rowBounds)
21
<T> Cursor<T> selectCursor(String statement, Object parameter, RowBounds rowBounds)
22
<K,V> Map<K,V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowbounds)
23
void select (String statement, Object parameter, ResultHandler<T> handler)
24
void select (String statement, Object parameter, RowBounds rowBounds, ResultHandler<T> handler)
25

26
// 4. 批量更新方法：当使用 BATCH 执行器时，可以使用这个方法清除（执行）缓存在 JDBC 驱动类中的批量更新语句。
27
List<BatchResult> flushStatements()
28

29
// 5. 事务控制方法：在使用由 Connection 实例控制的 JDBC 事务管理器时，用于控制事务作用域。
30
// 注意：这些方法不适用于外部事务管理器。
31
void commit()
32
void commit(boolean force)
33
void rollback()
34
void rollback(boolean force)
35

36
// 6. 清空本地缓存(会话缓存)
37
void clearCache()
38

39
// 7. 关闭会话
40
void close()
41
    
42
// 8. 获取 Configuration 实例
43
Configuration getConfiguration()
44
 
45
// 9. 获取映射器
46
//    映射器相对上述CURD方法，最大的优点是符合类型安全，并且对IDE和单元测试也更加友好。
47
<T> T getMapper(Class<T> type)
48

5) 映射器实例

映射器通过SqlSession的getMapper方法获取，本质上是一个 DAO 接口的动态代理类，内部保存了当前SqlSession对象的引用，主要用于执行SQL语句，并通过返回值获得执行结果。

注意：

1. 用于创建映射器的 DAO 接口，不能出现方法重载，否则会出现命名空间冲突。

2. 映射器方法的参数名默认按位置命名为param1、param2...等，可以使用@Param注解进行修改。

4. 使用映射器注解

MyBatis支持在映射器上通过注解进行映射配置，示例如下：

4
1
public interface UserDao {
2
    @Select("SELECT * FROM USER")
3
    List<User> findAll();
4
}

此时需修改核心配置mybatis-config.xml，通过注解进行扫描：

4
1
<!-- 通过注解进行扫描 -->
2
<mappers>
3
    <mapper class="org.example.dao.UserDao"/>
4
</mappers>

注意

1. 注意删除XML中该方法对应的映射配置，同一个映射器方法，不能同时存在两种配置方式。

5. MyBatis日志实现

MyBatis按照SLF4J -> COMMONS_LOGGING -> LOG4J2 -> LOG4J -> JDK_LOGGING的顺序查找日志实现，可在配置文件中进行修改：

6
1
<!-- mybatis-config.xml -->
2
<configuration>
3
  <settings>
4
    <setting name="logImpl" value="LOG4J"/>
5
  </settings>
6
</configuration>

此外，还可以配置为STDOUT_LOGGING和NO_LOGGING，或者其它实现了 org.apache.ibatis.logging.Log 接口的日志适配器。

第二节 MyBatis-Spring简介

1. 什么是MyBatis-Spring？

MyBatis-Spring是一个适配模块，可以将 MyBatis 无缝集成到 Spring 框架中，它可以：

• 从容器中查找数据源创建SqlSessionFactory。

• 创建线程安全的SqlSession或Mapper，并将其注册到容器中，支持直接注入使用。

• 使用 Mapper 接口执行SQL语句时，从Spring上下文获取SqlSession，从而参与Spring事务管理。

• 将 MyBatis 抛出的持久化异常PersistenceException统一转换为 Spring 的数据访问异常DataAccessException。

2. 基本整合流程

1) 依赖导入

引入相关依赖如下：

5
1
<dependency>
2
    <groupId>org.mybatis</groupId>
3
    <artifactId>mybatis-spring</artifactId>
4
    <version>2.0.7</version>
5
</dependency>

2) 创建SqlSessionFactory

Spring需要一个SqlSessionFactory来保存配置信息和创建SqlSession，可以通过SqlSessionFactoryBean来创建并注册到Spring容器。

5
1
<!-- 创建SqlSessionFactory -->
2
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
3
    <!-- 需要一个dataSource -->
4
    <property name="dataSource" ref="dataSource" />
5
</bean>

等效的 Java 配置如下：

9
1
@Configuration
2
public class MyBatisConfig {
3
    @Bean
4
    public SqlSessionFactory sqlSessionFactory() throws Exception {
5
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
6
        factoryBean.setDataSource(dataSource());
7
        return factoryBean.getObject();
8
    }
9
}

注意：

1. 可以直接通过依赖注入或继承 SqlSessionDaoSupport 的方式来获得容器中的 SqlSessionFactory 实例。

2. 不建议直接调用该实例的 openSession() 方法获取SQL会话，因为通过该会话执行SQL时，不会参与到Spring管理的事务中，并且需要手动关闭该会话。

3) 创建SqlSessionTemplate

SqlSessionTemplate是SqlSession的实现类，与其它 Spring 模板类似，它将会话数据保存在线程变量中，是线程安全的。

可以通过如下配置来创建SqlSessionTemplate，以代替 MyBatis 原生的DefaultSqlSession，将其注入到新创建的 Mapper 中，从而让 Spring 介入到 MyBatis 的会话管理，控制事务的提交和异常转换等相关操作。

5
1
<!-- 创建SqlSession -->
2
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
3
    <!-- 需要一个sqlSessionFactory -->
4
    <constructor-arg index="0" ref="sqlSessionFactory" />
5
</bean>

等效的Java配置如下：

7
1
@Configuration
2
public class MyBatisConfig {
3
    @Bean
4
    public SqlSessionTemplate sqlSession() throws Exception {
5
        return new SqlSessionTemplate(sqlSessionFactory());
6
    }
7
}

SqlSessionTemplate创建完毕并注册到Spring容器后，可以通过注入的方式，来使用它，如下所示。

10
1
@Service
2
public class UserDaoImpl implements UserDao {
3
    @Autowired
4
    private SqlSession sqlSession;
5

6
    public User getUser(String userId) {
7
        return sqlSession.selectOne("org.mybatis.spring.sample.mapper.UserMapper.getUser", userId);
8
    }
9
}
10

注意：

1. SqlSessionTemplate 是通过实现+组合方式对 DefaultSqlSession 的装饰，通过它执行SQL语句时，会获取 Spring 的事务管理器创建或获取当前线程会话，从而参与到Spring管理的事务中。

2. 请勿直接调用 SqlSessionTemplate 的 commit()、rollback()、close() 方法，这将会抛出 UnsupportedOperationException 异常。

3. SqlSessionTemplate是线程安全的，但是数据源等配置信息是各线程共享的，如果存在多个数据源，则需要创建多个实例。

4) 创建Mapper

一般来说，实际开发中，都会使用 MyBatis 的映射器来访问数据库，可以通过MapperFactoryBean来创建并注册到Spring容器。

7
1
<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
2
    <!--为UserMapper接口创建线程安全的映射器-->
3
    <property name="mapperInterface" value="org.mybatis.spring.sample.mapper.UserMapper" />
4
    <!--通过sqlSessionFactory传入配置信息-->
5
    <property name="sqlSessionFactory" ref="sqlSessionFactory" />
6
</bean>
7

等效的java配置如下：

9
1
@Configuration
2
public class MyBatisConfig {
3
    @Bean
4
    public UserMapper userMapper() throws Exception {
5
        SqlSessionTemplate sqlSessionTemplate = new SqlSessionTemplate(sqlSessionFactory());
6
        return sqlSessionTemplate.getMapper(UserMapper.class);
7
    }
8
}
9

然后就可以将映射器注入到你的业务对象中进行使用了。

9
1
@Service
2
public class FooServiceImpl implements FooService {
3
    @Autowired
4
    private final UserMapper userMapper;
5

6
    public User doSomeBusinessStuff(String userId) {
7
        return this.userMapper.getUser(userId);
8
    }
9
}

提示：

1. 你也可以为 MapperFactoryBean 传入一个 SqlSessionTemplate，这样将会使用其内部的 SqlSessionFactory，而忽略传入的那个。

2. 创建SqlSessionFactoryBean详解

在 MyBatis-Spring 整合工程中，一般通过 SqlSessionFactoryBean 来创建 SqlSessionFactory 并注册到 Spring 容器，以便 MapperFactoryBean或继承 SqlSessionDaoSupport 的类注入使用，其主要配置说明如下：

1) configLocation

configLocation 用来指定MyBatis配置文件路径。但这个配置文件并不是一个完整的MyBatis配置，它会忽略配置中的<environments>、<dataSource>和<transactionManager>等信息，但仍会解析<settings>和<typeAliases>等配置。

6
1
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
2
    <property name="dataSource" ref="dataSource"/>
3
    
4
    <!-- 引用mybatis配置文件中的配置 -->
5
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
6
</bean>

2) mapperLocations

mapperLocations用来指定映射配置文件路径。很多时候，映射配置文件和映射器类不在同一资源路径下，这时可以通过该属性来指定，并且可以同时指定多个路径和递归搜索。

5
1
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
2
    <property name="dataSource" ref="dataSource" />
3
    <!-- 加载在sample.config.mappers包和子包中的映射器配置文件 -->
4
    <property name="mapperLocations" value="classpath*:sample/config/mappers/**/*.xml" />
5
</bean>

提示：

1. 你也可以通过配置上面的 configLocation 属性，指定 MyBatis 配置文件，在其<mappers>标签内指定映射器配置文件。

3) databaseIdProvider

如果你使用了多种数据库，那么需要设置 databaseIdProvider 属性。

20
1
<!-- 配置数据库厂商的databaseId -->
2
<bean id="databaseIdProvider" class="org.apache.ibatis.mapping.VendorDatabaseIdProvider">
3
    <property name="properties">
4
        <props>
5
            <prop key="SQL Server">mssql</prop>
6
            <prop key="DB2">db2</prop>
7
            <prop key="Oracle">oracle</prop>
8
            <prop key="MySQL">mysql</prop>
9
        </props>
10
    </property>
11
</bean>
12

13
<!-- 创建SqlSessionFactory -->
14
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
15
    <property name="dataSource" ref="dataSource" />
16
    
17
    <!--指定数据库厂商ID配置-->
18
    <property name="databaseIdProvider" ref="databaseIdProvider"/>
19
</bean>
20

4) configuration

configuration属性能够在没有对应的 MyBatis 配置文件的情况下，直接设置 Configuration 实例。例如：

8
1
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
2
  <property name="dataSource" ref="dataSource" />
3
  <property name="configuration">
4
    <bean class="org.apache.ibatis.session.Configuration">
5
      <property name="mapUnderscoreToCamelCase" value="true"/>
6
    </bean>
7
  </property>
8
</bean>

5) transactionFactoryClass

transactionFactoryClass属性用于自定义事务工厂，一般不做配置。

4. 创建SqlSessionTemplate详解

MyBatis-Spring 工程提供的 SqlSessionTemplate，将会替代原 MyBatis 的 DefaultSqlSession 注入到映射器中，并且在注入前经过动态代理，在调用其方法时被拦截，用于控制事务和转换异常等操作。下面是创建时可以使用的一些配置参数：

1) ExecutorType

ExecutorType 用于指定 SqlSessionTemplate 的执行器类型，如下配置创建一个用于批处理的SqlSessionTemplate。

7
1
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
2
    <constructor-arg index="0" ref="sqlSessionFactory" />
3
    
4
    <!--指定执行器类型为批处理执行器(编译1次，设置参数N次，执行1次)-->
5
    <constructor-arg index="1" value="BATCH" />
6
</bean>
7

等效的java配置如下：

7
1
@Configuration
2
public class MyBatisConfig {
3
    @Bean
4
    public SqlSessionTemplate sqlSession() throws Exception {
5
        return new SqlSessionTemplate(sqlSessionFactory(), ExecutorType.BATCH);
6
    }
7
}

现在所有的映射语句可以进行批量操作了，可以在 DAO 中编写如下的代码。

12
1
@Service
2
public class UserService {
3
    @Autowire
4
    private final SqlSession sqlSession;
5

6
    public void insertUsers(List<User> users) {
7
        for (User user : users) {
8
            sqlSession.insert("org.mybatis.spring.sample.mapper.UserMapper.insertUser", user);
9
        }
10
    }
11
}
12

注意：

1. 同一个事务只能使用一种执行器，如果你需要不同的执行器执行SQL，请拆分为多个事务或完全不使用事务。

2) SqlSessionDaoSupport

SqlSessionDaoSupport 是一个抽象的支持类，用来为你提供 SqlSession。业务类继承它后，调用 getSqlSession() 方法就会得到一个 SqlSessionTemplate，之后可以用于执行 SQL 方法，并参与 Spring 事务管理。

5
1
public class UserDaoImpl extends SqlSessionDaoSupport implements UserDao {
2
    public User getUser(String userId) {
3
        return getSqlSession().selectOne("org.mybatis.spring.sample.mapper.UserMapper.getUser", userId);
4
    }
5
}

前提是你为业务对象注入了 SqlSessionFactory 或 SqlSessionTemplate，如果两个属性都被注入，那么SqlSessionFactory 将会被忽略。

3
1
<bean id="userDao" class="org.mybatis.spring.sample.dao.UserDaoImpl">
2
    <property name="sqlSessionFactory" ref="sqlSessionFactory" />
3
</bean>

5. 批量创建Mapper

1) <mybatis:scan>方式

<mybatis:scan>标签与组件扫描所使用的<context:component-scan/>标签类似，通过base-package属性指定多个以逗号分割的包名，递归扫描发现的映射器，然后创建对应的 MapperFactoryBean 并注册到Spring中。

11
1
<beans xmlns="http://www.springframework.org/schema/beans"
2
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3
  xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
4
  xsi:schemaLocation="
5
  http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
6
  http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring.xsd">
7

8
  <!-- 扫描 org.example.dao 及其子包下的映射器 -->
9
  <mybatis:scan base-package="org.example.dao" factory-ref="sqlSessionFactory"/>
10

11
</beans>

下面是<mybatis:scan>标签的一些配置参数：

• factory-ref/template-ref：指定创建映射器时使用的 SqlSessionFactory 或 SqlSessionTemplate的Bean名称。

  • 一般只在有多数据源时使用，因为默认情况下MapperFactoryBean会被注入默认的 SqlSessionFactory 或 SqlSessionTemplate。

• annotation： 指定映射器应该具有的注解(如@Repository)，如果扫描到的接口未包含该注解，则跳过解析。

• marker-interface：指定映射器应该继承的接口，如果扫描到的接口未继承该接口，则跳过解析。

默认情况下，注册的映射器都以映射器接口的首字母小写非全限定类名作为名称，你可以通过 @Component 或 JSR-330 标准中 @Named 注解来进行修改。

注意：

1. <context:component-scan/>标签无法发现并注册映射器。因为映射器是一个接口，组建扫描时无法实例化。

2. 映射器接口的Bean名称默认为首字母小写类名，可通过 @Component 或 @Named 注解修改。

2) @MapperScan方式

@MapperScan注解也可以用于批量创建Mapper，它会自动扫描basePackageClasses 或 basePackages包及其子包的映射器。

5
1
@Configuration
2
@MapperScan("org.mybatis.spring.sample.mapper")
3
public class AppConfig {
4
    // ...
5
}

注意：

1. 如果未定义 basePackageClasses 或 basePackages，则会从声明@MapperScan注解类的包中进行扫描。

2. 同样的，@MapperScan 也可配置 sqlSessionFactory、sqlSessionTemplate、markerInterface、annotationClass 等属性。

3) MapperScannerConfigurer方式

MapperScannerConfigurer 是一个 BeanDefinitionRegistryPostProcessor，可以在容器创建的时候扫描映射器。

7
1
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
2
    <property name="basePackage" value="org.mybatis.spring.sample.mapper" />
3
    
4
    <!-- 可指定 SqlSessionFactory 的BeanName -->
5
    <!-- 可指定 SqlSessionFactory 的BeanName -->
6
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
7
</bean>

如果有多个数据源，可以使用sqlSessionFactoryBeanName 或 sqlSessionTemplateBeanName 属性指定 sqlSessionFactory 或 sqlSessionTemplate 的 bean 名称（注意使用 vlaue 指定BenaName，而不是 ref 引用对象）。

4) 注意事项

为了支持 SpringBoot 2.2 的延迟初始化控制功能，新增了lazyInitialization属性，用于控制映射器的延迟初始化，默认为false。如果使用延迟初始化功能，开发人员需要了解以下限制，否则延迟初始化功能无法在您的应用程序上使用。

• 不能使用 <association>(@One) 和 <collection>(@Many) 引用其他映射器的语句

• 不能使用<include> 包含到其他映射器的片段

• 不能使用 <cache-ref>(@CacheNamespaceRef) 引用其他映射器的缓存

• 不能使用 <select resultMap="...">(@ResultMap) 引用其他映射器的结果映射

但是，你可以通过使用 @DependsOn 同时初始化依赖 bean 来使用它，如下所示：

4
1
@DependsOn("vendorMapper")
2
public GoodsMapper {
3
    // ...
4
}

6. 关于事务管理器

MyBatis 与 Spring 整合后，使用同一个事务管理器（默认为DataSourceTransactionManage），在事务开启时，会创建一个全新的 DefaultSqlSession ，当事务完成后，这个 session 会以合适的方式提交或回滚。

1) 配置事务管理器

MyBatis使用与 JDBC 相同的事务管理器 DataSourceTransactionManager，并且配置方式一致，详情可以参考 Spring 事务相关讲解。

5
1
<!-- 配置一个事务管理器 -->
2
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
3
    <!-- 需要一个数据源 -->
4
    <constructor-arg ref="dataSource" />
5
</bean>

等效的java配置如下：

7
1
@Configuration
2
public class DataSourceConfig {
3
    @Bean
4
    public DataSourceTransactionManager transactionManager() {
5
        return new DataSourceTransactionManager(dataSource());
6
    }
7
}

注意：

1. 为事务管理器指定的 DataSource 必须和用来创建 SqlSessionFactoryBean 的是同一个数据源，否则事务管理器就无法工作了。

2) 事务控制

你可以使用 @Transaction 注解或 AOP 方式来配置哪些方法应该进行事务控制，这和 Spring 事务章节所讲述的方式相同。也可以使用Spring 提供的编程式API来精细控制事务，如下案例所示。

19
1
@Service
2
public class UserService {
3
    @Autowired
4
    private final PlatformTransactionManager transactionManager;
5

6
    public void createUser() {
7
        // 获取当前活动事务或创建新事物(由TransactionDefinition决定事务传播行为)
8
        TransactionStatus txStatus = transactionManager.getTransaction(new DefaultTransactionDefinition());
9
        try {
10
            userMapper.insertUser(user);
11
        } catch (Exception e) {
12
            // 出异常回滚
13
            transactionManager.rollback(txStatus);
14
            throw e;
15
        }
16
        // 业务成功，提交事务
17
        transactionManager.commit(txStatus);
18
    }
19
}

第三节 MyBatis-Spring-Boot-Starter

MyBatis-Spring-Boot-Starter用于快速构建基于SpringBoot 和 Mybatis 的应用程序。

1. 基本整合流程

1) 依赖导入

首先从官方文档查找合适的依赖版本。

如果你使用 Maven来管理项目，则可以通过下面配置来引入依赖。

5
1
<dependency>
2
    <groupId>org.mybatis.spring.boot</groupId>
3
    <artifactId>mybatis-spring-boot-starter</artifactId>
4
    <version>2.2.2</version>
5
</dependency>

2) 自动配置

当容器中只有一个DataSource时(或存在主候选对象)，MyBatis-Spring-Boot-Starter 会进行自动配置。自动配置包括以下一些内容：

• 使用默认 DataSource 配置SqlSessionFactory，使用该 SqlSessionFactory 配置SqlSessionTemplate。

• 配置MapperScannerConfigurer，用于批量创建Mapper。

• 配置Interceptor、TypeHandler、DatabaseIdProvider、LanguageDriver。

3) 基础使用

只需要将映射器接口加上@Mapper注解即可，容器启动时会自动扫描类路径下带@Mapper注解的映射器并注册到容器中。

5
1
@Mapper
2
public interface CityMapper {
3
  @Select("SELECT * FROM CITY WHERE state = #{state}")
4
  City findByState(@Param("state") String state);
5
}

然后就可以通过注入的方式使用该映射器了。

18
1
@SpringBootApplication
2
public class SampleMybatisApplication implements CommandLineRunner {
3
  private final CityMapper cityMapper;
4

5
  public SampleMybatisApplication(CityMapper cityMapper) {
6
    this.cityMapper = cityMapper;
7
  }
8

9
  public static void main(String[] args) {
10
    SpringApplication.run(SampleMybatisApplication.class, args);
11
  }
12

13
  @Override
14
  public void run(String... args) throws Exception {
15
    System.out.println(this.cityMapper.findByState("CA"));
16
  }
17
}
18

同样，也可以通过注入的方式使用已配置好的SqlSessionFactory和SqlSessionTemplate。

12
1
@Component
2
public class CityDao {
3
  private final SqlSession sqlSession;
4

5
  public CityDao(SqlSession sqlSession) {
6
    this.sqlSession = sqlSession;
7
  }
8

9
  public City selectCityById(long id) {
10
    return this.sqlSession.selectOne("selectCityById", id);
11
  }
12
}

注意：

1. 如果需要修改扫描路径或扫描指定的注解/接口，可以结合 MyBatis-Spring 提供的@MapperScan注解。

4) 高级扫描

MyBatis-Spring-Boot-Starter还会检测容器中存在的Interceptor、TypeHandler、DatabaseIdProvider、LanguageDriver接口实现类，并将它们添加到 Configuration 中。

60
1
// 添加 Interceptor、TypeHandler、DatabaseIdProvider
2
@Configuration
3
public class MyBatisConfig {
4
  @Bean
5
  MyInterceptor myInterceptor() {
6
    return MyInterceptor();
7
  }
8
  @Bean
9
  MyTypeHandler myTypeHandler() {
10
    return MyTypeHandler();
11
  }
12
  @Bean
13
  MyLanguageDriver myLanguageDriver() {
14
    return MyLanguageDriver();
15
  }
16
  @Bean
17
  VendorDatabaseIdProvider databaseIdProvider() {
18
    VendorDatabaseIdProvider databaseIdProvider = new VendorDatabaseIdProvider();
19
    Properties properties = new Properties();
20
    properties.put("SQL Server", "sqlserver");
21
    properties.put("DB2", "db2");
22
    properties.put("H2", "h2");
23
    databaseIdProvider.setProperties(properties);
24
    return databaseIdProvider;
25
  }  
26
}
27

28
// 添加 ThymeleafLanguageDriver
29
@Configuration
30
public class MyBatisConfig {
31
  @Bean
32
  ThymeleafLanguageDriverConfig thymeleafLanguageDriverConfig() {
33
    return ThymeleafLanguageDriverConfig.newInstance(c -> {
34
      // ... customization code
35
    });
36
  }
37
}
38

39
// 添加 FreeMarkerLanguageDriverConfig
40
@Configuration
41
public class MyBatisConfig {
42
  @Bean
43
  FreeMarkerLanguageDriverConfig freeMarkerLanguageDriverConfig() {
44
    return FreeMarkerLanguageDriverConfig.newInstance(c -> {
45
      // ... customization code
46
    });
47
  }
48
}
49

50
// 添加 Velocity语言驱动程序
51
@Configuration
52
public class MyBatisConfig {
53
  @Bean
54
  VelocityLanguageDriverConfig velocityLanguageDriverConfig() {
55
    return VelocityLanguageDriverConfig.newInstance(c -> {
56
      // ... customization code
57
    });
58
  }
59
}
60

5) SpringBootVFS

MyBatis-Spring-Boot-Starter提供的SpringBootVFS继承自MyBatis框架的VFS(虚拟文件系统)，用于从应用程序或应用服务器加载指定的类，如别名对应的类、类型处理器等。

在自动配置 SqlSessionFactory 时，将会默认使用，但在自定义 SqlSessionFactory 时，需要通过下面示例代码显式调用。

11
1
@Configuration
2
public class MyBatisConfig {
3
  @Bean
4
  public SqlSessionFactory masterSqlSessionFactory() throws Exception {
5
    SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
6
    factoryBean.setDataSource(masterDataSource());
7
    factoryBean.setVfs(SpringBootVFS.class); 
8
    // ...
9
    return factoryBean.getObject();
10
  }
11
}

2. 修改MyBatis配置

1) YML方式

使用mybatis前缀来配置MyBatis的相关属性，部分属性说明如下，完整的属性列表及说明可参考MybatisProperties。

下面是一个简单的使用案例。

8
1
## application.yml
2
mybatis:
3
    type-aliases-package: com.example.domain.model
4
    type-handlers-package: com.example.typehandler
5
    configuration:
6
        map-underscore-to-camel-case: true
7
        default-fetch-size: 100
8
        default-statement-timeout: 30

12) ConfigurationCustomizer方式

实现ConfigurationCustomizer接口可对 Configuration 进行全面的 Java 配置。

13
1
@Configuration
2
public class MyBatisConfig {
3
  @Bean
4
  ConfigurationCustomizer mybatisConfigurationCustomizer() {
5
    return new ConfigurationCustomizer() {
6
      @Override
7
      public void customize(Configuration configuration) {
8
        // customize ...
9
      }
10
    };
11
  }
12
}
13

3) SqlSessionFactoryBeanCustomizer方式

实现SqlSessionFactoryBeanCustomizer接口可对SqlSessionFactoryBean进行全面的Java配置(2.2.2+版本)。

13
1
@Configuration
2
public class MyBatisConfig {
3
  @Bean
4
  SqlSessionFactoryBeanCustomizer sqlSessionFactoryBeanCustomizer() {
5
    return new SqlSessionFactoryBeanCustomizer() {
6
      @Override
7
      public void customize(SqlSessionFactoryBean factoryBean) {
8
        // customize ...
9
      }
10
    };
11
  }
12
}
13

第02章_配置文件详解

第一节 properties标签

1. 定义属性

通过 properties 标签定义属性名和属性值：

15
1
<!-- 方式1：内部标签 -->
2
<!-- 方式2：通过 resource 属性引入类路径下的 properties 文件 -->
3
<!-- 方式3：通过 url      属性引入网络或本地 properties 文件 -->
4
<properties resource="org/mybatis/example/config.properties">
5
    <!-- 内部标签定义属性 -->
6
    <property name="username" value="dev_user"/>
7
    <property name="password" value="F2Fa3!33TYyg"/>
8

9
    <!-- 开启属性默认值特性 -->
10
    <property name="org.apache.ibatis.parsing.PropertyParser.enable-default-value" value="true"/>
11
    <!-- 设置默认值分隔符（默认为冒号） -->
12
    <property name="org.apache.ibatis.parsing.PropertyParser.default-value-separator" value=":"/>
13
</properties>
14

15

注意：

1. 不同位置配置的属性优先级如下：直接通过 build() 方法传入的属性 > 引入文件中配置的属性 > 内部property标签定义的属性。

2. 使用属性

在 mybatis-config.xml 中使用属性：

6
1
<dataSource type="POOLED">
2
  <property name="driver" value="${driver}"/>
3
  <property name="url" value="${url}"/>
4
  <property name="username" value="${username:root}"/>    <!-- 属性默认值 -->
5
  <property name="password" value="${password}"/>
6
</dataSource>