MyBatis核心应用整理

偏执的太偏执、 2023-09-25 19:29 23阅读 0赞

> 官网地址：https://mybatis.org/mybatis-3/zh/index.html

*  MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。
 *  MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作
 *  MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
 *  MyBatis也成为“半自动”的ORM框架，半自动化”是相对于Hibernate的全自动化来说的。它的封装程度没有Hibernate那么高，不会自动生成全部的SQL语句，主要解决的是SQL和对象的映射问题。
 *  在MyBatis里面，SQL和代码是分离的，所以会写SQL基本上就会用MyBatis，没有额外的学习成本。

## MyBatis实际案例 ##

通过实际的案例代码来演示下MyBatis的具体使用

### 1. 环境准备 ###

先搭建MyBatis的使用环境

#### 1.1 创建项目 ####

创建一个普通的Maven项目，然后添加对应的Mybatis和MySQL的相关依赖

<dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.4</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.11</version>
    </dependency>

#### 1.2 POJO对象 ####

通过数据库中的 T\_USER 表来创建的对应的POJO对象如下：  
（ps. 有用到Lombok，自行添加对应的依赖)

@Data
    public class User {
        
        private Integer id;
    
        private String userName;
    
        private String nickName;
    
        private String password;
    
        private Integer age;
    }

#### 1.3 添加配置文件 ####

在MyBatis中需要添加全局的配置文件和对应的映射文件。  
![在这里插入图片描述][e4479925f38f4ded900891261a270644.png]

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
    
        <properties resource="db.properties"></properties>
        <settings>
            
            <setting name="logImpl" value="STDOUT_LOGGING" />
    
            
            <setting name="cacheEnabled" value="false"/>
    
            
            <setting name="lazyLoadingEnabled" value="true"/>
            
            <setting name="aggressiveLazyLoading" value="true"/>
            
            
            
            
            <setting name="localCacheScope" value="SESSION"/>
        </settings>
    
        <typeAliases>
            <typeAlias alias="user" type="com.boge.domain.User" />
        </typeAliases>
    
        <environments default="development">
            <environment id="development">
                <transactionManager type="JDBC"/>
                <dataSource type="POOLED">
                    <property name="driver" value="${jdbc.driver}"/>
                    <property name="url" value="${jdbc.url}"/>
                    <property name="username" value="${jdbc.username}"/>
                    <property name="password" value="${jdbc.password}"/>
                </dataSource>
            </environment>
        </environments>
    
        <mappers>
            <mapper resource="mapper/UserMapper.xml"/>
        </mappers>
    
    </configuration>

数据库属性的配置文件

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/mybatisdb?characterEncoding=utf-8&serverTimezone=UTC
    jdbc.username=root
    jdbc.password=123456

关联的映射文件，通常来说一张表对应一个，在这个里面配置增删改查的SQL语句，以及参数和返回的结果集的映射关系。

<?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.sissie.mapper.UserMapper">
      <resultMap id="BaseResultMap" type="user">
        <id property="id" column="id" jdbcType="INTEGER"/>
        <result property="userName" column="user_name" jdbcType="VARCHAR" />
        <result property="nickName" column="nick_name" jdbcType="VARCHAR" />
        <result property="password" column="password" jdbcType="VARCHAR"/>
        <result property="age" column="age" jdbcType="INTEGER"/>
      
      </resultMap>
    
      <select id="selectUserById" resultMap="BaseResultMap" statementType="PREPARED" >
            select * from t_user where id = #{id}
        </select>
    
      
      <select id="selectUserByBean"  parameterType="user" resultMap="BaseResultMap" >
            select * from t_user where user_name = '${userName}'
        </select>
    
      <select id="selectUserList" resultMap="BaseResultMap" >
            select * from t_user
        </select>
    </mapper>

环境准备好后，就可以来使用其实现数据库的操作了。

### 编程式的使用 ###

在MyBatis中的使用方式有两种，首先来看下第一种编程式的方式：

/**
         * MyBatis API 的使用
         * @throws Exception
         */
        @Test
        public void test1() throws  Exception{
        
            // 1.获取配置文件
            InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
            // 2.加载解析配置文件并获取SqlSessionFactory对象
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
            // 3.根据SqlSessionFactory对象获取SqlSession对象
            SqlSession sqlSession = factory.openSession();
            // 4.通过SqlSession中提供的 API方法来操作数据库
            List<User> list = sqlSession.selectList("com.sissie.mapper.UserMapper.selectUserList");
            for (User user : list) {
        
                System.out.println(user);
            }
            // 5.关闭会话
            sqlSession.close();
        }

以上这种方式其实就是通过SqlSession中提供的相关的API方法来执行对应的CRUD操作，查找我们写的SQL语句是通过 namespace+“.”+id的方式实现的。  
这样的调用方式，解决了重复代码、资源管理、SQL耦合、结果集映射这4大问题。

不过，这样的调用方式还是会存在一些问题：

1.  Statement ID是硬编码，维护起来很不方便；
2.  不能在编译时进行类型检查，如果namespace或者Statement ID输错了，只能在运行的时候报错。

所以我们通常会使用第二种方式，也是新版的MyBatis里面推荐的方式：定义一个Mapper接口的方式。这个接口全路径必须跟Mapper.xml里面的namespace对应起来，方法也要跟Statement ID一一对应。

### 3. 代理方式的使用 ###

第二种，还可以通过SqlSession中提供的getMapper方法来获取声明接口的代理对象来处理。实现如下：

#### 3.1 接口声明 ####

需要声明一个Dao的接口。然后在接口中定义相关的方法。

package com.sissie.mapper;
    
    import com.boge.pojo.User;
    
    import java.util.List;
    
    /**
     * Dao 的接口声明
     */
    public interface UserMapper {
        
        public User selectUserById(Integer id);
    }

#### 3.2 映射文件 ####

通过getMapper的方式来使用的话，需要添加对应的映射文件，在映射文件中我们需要将namespace声明为上面接口的全类路径名，同时对应的sql标签的id要和方法名称一致

<?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.sissie.mapper.UserMapper">
        
      <resultMap id="BaseResultMap" type="user" >
        <id property="id" column="id" jdbcType="INTEGER"/>
        <result property="userName" column="user_name" jdbcType="VARCHAR" />
        <result property="nickName" column="nick_name" jdbcType="VARCHAR" />
        <result property="password" column="password" jdbcType="VARCHAR"/>
        <result property="age" column="age" jdbcType="INTEGER"/>
      </resultMap>
    
        <sql id="baseSQL">
            id,user_name,real_name,password,age,d_id
        </sql>
     
      <select id="selectUserById" useCache="false"   resultMap="BaseResultMap" statementType="PREPARED" parameterType="_int" >
            select
             id,
             user_name ,
             real_name ,
             password,
             age
             from t_user where id = #{id}
        </select>
    </mapper>

最后还要保证映射文件的名称和接口的名称要一致。在文件很多的情况能很好的管理。

### 3.3 getMapper ###

最后在通过getMapper方法来获取声明的Dao接口的代码对象来实现数据库操作。

/**
         * MyBatis getMapper 方法的使用
         */
        @Test
        public void test2() throws Exception{
        
            // 1.获取配置文件
            InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
            // 2.加载解析配置文件并获取SqlSessionFactory对象
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
            // 3.根据SqlSessionFactory对象获取SqlSession对象
            SqlSession sqlSession = factory.openSession();
            // 4.通过SqlSession中提供的 API方法来操作数据库
            UserMapper mapper = sqlSession.getMapper(UserMapper.class);
            List<User> list = mapper.selectUserList();
            for (User user : list) {
        
                System.out.println(user);
            }
            // 5.关闭会话
            sqlSession.close();
        }

通过执行接口方法，来执行映射器中的SQL语句。

### 总结 MyBatis使用的特点： ###

1.  使用连接池对连接进行管理
2.  SQL和代码分离，集中管理
3.  结果集映射
4.  参数映射和动态SQL
5.  重复SQL的提取
6.  缓存管理
7.  插件机制

## MyBatis核心配置 ##

在MyBatis中最核心的应该是以上提到的两个配置文件，一个全局配置文件，一个映射文件。只要把这两个文件弄清楚，其实对于MyBatis的使用就掌握了大部分。

> 网址：https://mybatis.net.cn/configuration.html

接下来详细的介绍下这两个配置文件：

### 1.全局配置文件 ###

MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。 配置文档的顶层结构如下：

配置文件遵循的规则：  
![在这里插入图片描述][898f3a0f52084091b66c67800a1efb8a.png_pic_center]  
ELEMENT指定了有哪些元素；  
（）表示：子元素；

？表示：要不没有，有也只有一个标签；

，表示：要按指定顺序；  
![在这里插入图片描述][221a0390f40248c2a37cf6a5573857d0.png_pic_center]  
重点参数如下：

*  configuration（配置）
 *  properties（属性）
 *  settings（设置）
 *  typeAliases（类型别名）
 *  typeHandlers（类型处理器）
 *  objectFactory（对象工厂）
 *  plugins（插件）
 *  environments（环境配置）
    
     *  environment（环境变量）
        
         *  transactionManager（事务管理器）
         *  dataSource（数据源）
 *  databaseIdProvider（数据库厂商标识）
 *  mappers（映射器）

#### 1.1 configuration ####

configuration是整个配置文件的根标签，实际上也对应着MyBatis里面最重要的配置类Configuration。它贯穿MyBatis执行流程的每一个环节。

#### 1.2 properties ####

第一个一级标签，用来配置参数信息，比如最常见的数据库连接信息。  
为了避免直接把参数写死在xml配置文件中，可以把这些参数单独放在properties文件中，用properties标签引入进来，然后在xml配置文件中用$\{\}引用就可以了。可以用resource引用应用里面的相对路径，也可以用url指定本地服务器或者网络的绝对路径。

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
    	
        <properties resource="db.properties"></properties>
        <environments default="development">
            <environment id="development">
                <dataSource type="POOLED">
                
                    <property name="driver" value="${jdbc.driver}"/>
                    <property name="url" value="${jdbc.url}"/>
                    <property name="username" value="${jdbc.username}"/>
                    <property name="password" value="${jdbc.password}"/>
                </dataSource>
            </environment>
        </environments>
    
    </configuration>

#### 1.3 settings ####

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。 下表描述了设置中各项设置的含义、默认值等。

<table> 
 <thead> 
  <tr> 
   <th>设置参数</th> 
   <th align="left">描述</th> 
   <th align="left">有效值</th> 
   <th align="left">默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>cacheEnabled</td> 
   <td align="left">全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存。</td> 
   <td align="left">true</td> 
   <td align="left">false</td> 
  </tr> 
  <tr> 
   <td>lazyLoadingEnabled</td> 
   <td align="left">延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态。</td> 
   <td align="left">true</td> 
   <td align="left">false</td> 
  </tr> 
  <tr> 
   <td>aggressiveLazyLoading</td> 
   <td align="left">当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载（参考lazyLoadTriggerMethods).</td> 
   <td align="left">true</td> 
   <td align="left">false</td> 
  </tr> 
  <tr> 
   <td>multipleResultSetsEnabled</td> 
   <td align="left">是否允许单一语句返回多结果集（需要兼容驱动）。</td> 
   <td align="left">true</td> 
   <td align="left">false</td> 
  </tr> 
  <tr> 
   <td>useColumnLabel</td> 
   <td align="left">使用列标签代替列名。不同的驱动在这方面会有不同的表现， 具体可参考相关驱动文档或通过测试这两种不同的模式来观察所用驱动的结果。</td> 
   <td align="left">true</td> 
   <td align="left">false</td> 
  </tr> 
  <tr> 
   <td>useGeneratedKeys</td> 
   <td align="left">允许 JDBC 支持自动生成主键，需要驱动兼容。 如果设置为 true 则这个设置强制使用自动生成主键，尽管一些驱动不能兼容但仍可正常工作（比如 Derby）。</td> 
   <td align="left">true</td> 
   <td align="left">false</td> 
  </tr> 
  <tr> 
   <td>autoMappingBehavior</td> 
   <td align="left">指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示取消自动映射；PARTIAL 只会自动映射没有定义嵌套结果集映射的结果集。 FULL 会自动映射任意复杂的结果集（无论是否嵌套）。</td> 
   <td align="left">NONE, PARTIAL, FULL</td> 
   <td align="left">PARTIAL</td> 
  </tr> 
  <tr> 
   <td>autoMappingUnknownColumnBehavior</td> 
   <td align="left">指定发现自动映射目标未知列（或者未知属性类型）的行为。 NONE: 不做任何反应WARNING: 输出提醒日志(‘org.apache.ibatis.session.AutoMappingUnknownColumnBehavior’ 的日志等级必须设置为 WARN) FAILING: 映射失败 (抛出 SqlSessionException)</td> 
   <td align="left">NONE, WARNING, FAILING</td> 
   <td align="left">NONE</td> 
  </tr> 
  <tr> 
   <td>defaultExecutorType</td> 
   <td align="left">配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（prepared statements）； BATCH 执行器将重用语句并执行批量更新。</td> 
   <td align="left">SIMPLE REUSE BATCH</td> 
   <td align="left">SIMPLE</td> 
  </tr> 
  <tr> 
   <td>defaultStatementTimeout</td> 
   <td align="left">设置超时时间，它决定驱动等待数据库响应的秒数。</td> 
   <td align="left">任意正整数</td> 
   <td align="left">Not Set (null)</td> 
  </tr> 
  <tr> 
   <td>defaultFetchSize</td> 
   <td align="left">为驱动的结果集获取数量（fetchSize）设置一个提示值。此参数只可以在查询设置中被覆盖。</td> 
   <td align="left">任意正整数</td> 
   <td align="left">Not Set (null)</td> 
  </tr> 
  <tr> 
   <td>safeRowBoundsEnabled</td> 
   <td align="left">允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为false。</td> 
   <td align="left">true</td> 
   <td align="left">false</td> 
  </tr> 
  <tr> 
   <td>safeResultHandlerEnabled</td> 
   <td align="left">允许在嵌套语句中使用分页（ResultHandler）。如果允许使用则设置为false。</td> 
   <td align="left">true</td> 
   <td align="left">false</td> 
  </tr> 
  <tr> 
   <td>mapUnderscoreToCamelCase</td> 
   <td align="left">是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN 到经典 Java 属性名 aColumn 的类似映射。</td> 
   <td align="left">true| false</td> 
   <td align="left">False</td> 
  </tr> 
  <tr> 
   <td>localCacheScope</td> 
   <td align="left">MyBatis 利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。 默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地会话仅用在语句执行上，对相同 SqlSession 的不同调用将不会共享数据。</td> 
   <td align="left">SESSION| STATEMENT</td> 
   <td align="left">SESSION</td> 
  </tr> 
  <tr> 
   <td>jdbcTypeForNull</td> 
   <td align="left">当没有为参数提供特定的 JDBC 类型时，为空值指定 JDBC 类型。 某些驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。</td> 
   <td align="left">JdbcType 常量. 大多都为: NULL, VARCHAR and OTHER</td> 
   <td align="left">OTHER</td> 
  </tr> 
  <tr> 
   <td>lazyLoadTriggerMethods</td> 
   <td align="left">指定哪个对象的方法触发一次延迟加载。</td> 
   <td align="left">用逗号分隔的方法列表。</td> 
   <td align="left">equals,clone,hashCode,toString</td> 
  </tr> 
  <tr> 
   <td>defaultScriptingLanguage</td> 
   <td align="left">指定动态 SQL 生成的默认语言。</td> 
   <td align="left">一个类型别名或完全限定类名。</td> 
   <td align="left">org.apache.ibatis.scripting.xmltags.XMLLanguageDriver</td> 
  </tr> 
  <tr> 
   <td>defaultEnumTypeHandler</td> 
   <td align="left">指定 Enum 使用的默认 TypeHandler 。 (从3.4.5开始) 一个类型别名或完全限定类名。</td> 
   <td align="left">org.apache.ibatis.type.EnumTypeHandler</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td>callSettersOnNulls</td> 
   <td align="left">指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这对于有 Map.keySet() 依赖或 null 值初始化的时候是有用的。注意基本类型（int、boolean等）是不能设置成 null 的。</td> 
   <td align="left">true| false</td> 
   <td align="left">false</td> 
  </tr> 
  <tr> 
   <td>returnInstanceForEmptyRow</td> 
   <td align="left">当返回行的所有列都是空时，MyBatis默认返回null。 当开启这个设置时，MyBatis会返回一个空实例。 请注意，它也适用于嵌套的结果集 (i.e. collectioin and association)。（从3.4.2开始）</td> 
   <td align="left">true| false</td> 
   <td align="left">false</td> 
  </tr> 
  <tr> 
   <td>logPrefix</td> 
   <td align="left">指定 MyBatis 增加到日志名称的前缀。</td> 
   <td align="left">任何字符串</td> 
   <td align="left">Not set</td> 
  </tr> 
  <tr> 
   <td>logImpl</td> 
   <td align="left">指定 MyBatis 所用日志的具体实现，未指定时将自动查找。</td> 
   <td align="left">SLF4J</td> 
   <td align="left">LOG4J| LOG4J2 | JDK_LOGGING | COMMONS_LOGGING\</td> 
  </tr> 
  <tr> 
   <td>proxyFactory</td> 
   <td align="left">指定 Mybatis 创建具有延迟加载能力的对象所用到的代理工具。</td> 
   <td align="left">CGLIB\</td> 
   <td align="left">JAVASSIST</td> 
  </tr> 
  <tr> 
   <td>vfsImpl</td> 
   <td align="left">指定VFS的实现</td> 
   <td align="left">自定义VFS的实现的类全限定名，以逗号分隔。</td> 
   <td align="left">Not set</td> 
  </tr> 
  <tr> 
   <td>useActualParamName</td> 
   <td align="left">允许使用方法签名中的名称作为语句参数名称。 为了使用该特性，你的工程必须采用Java 8编译，并且加上-parameters选项。（从3.4.1开始）</td> 
   <td align="left">true| false</td> 
   <td align="left">true</td> 
  </tr> 
  <tr> 
   <td>configurationFactory</td> 
   <td align="left">指定一个提供Configuration实例的类。 这个被返回的Configuration实例用来加载被反序列化对象的懒加载属性值。 这个类必须包含一个签名方法static Configuration getConfiguration(). (从 3.2.3 版本开始)</td> 
   <td align="left">类型别名或者全类名.</td> 
   <td align="left">Not set</td> 
  </tr> 
 </tbody> 
</table>

设置的案例

#### 1.4 typeAliases ####

TypeAlias是类型的别名，主要用来简化类名全路径的拼写。比如参数类型和返回值类型都可能会用到Bean，如果每个地方都配置全路径的话，那么内容就比较多，还可能会写错。

可以为项目的Bean创建别名，既可以指定单个类，也可以指定一个package，自动转换。

然后在使用的时候就可以简化了

<?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.sissie.mapper.UserMapper">
    
      
      <select id="selectUserByBean"  parameterType="user" resultType="user"  >
            select * from t_user where user_name = '${userName}'
        </select>
    
    </mapper>

MyBatis里面有很多系统预先定义好的类型别名，在TypeAliasRegistry中。所以可以用string代替java.lang.String。

public TypeAliasRegistry() {
        
        registerAlias("string", String.class);
    
        registerAlias("byte", Byte.class);
        registerAlias("long", Long.class);
        registerAlias("short", Short.class);
        registerAlias("int", Integer.class);
        registerAlias("integer", Integer.class);
        registerAlias("double", Double.class);
        registerAlias("float", Float.class);
        registerAlias("boolean", Boolean.class);
    
        registerAlias("byte[]", Byte[].class);
        registerAlias("long[]", Long[].class);
        registerAlias("short[]", Short[].class);
        registerAlias("int[]", Integer[].class);
        registerAlias("integer[]", Integer[].class);
        registerAlias("double[]", Double[].class);
        registerAlias("float[]", Float[].class);
        registerAlias("boolean[]", Boolean[].class);
    
        registerAlias("_byte", byte.class);
        registerAlias("_long", long.class);
        registerAlias("_short", short.class);
        registerAlias("_int", int.class);
        registerAlias("_integer", int.class);
        registerAlias("_double", double.class);
        registerAlias("_float", float.class);
        registerAlias("_boolean", boolean.class);
    
        registerAlias("_byte[]", byte[].class);
        registerAlias("_long[]", long[].class);
        registerAlias("_short[]", short[].class);
        registerAlias("_int[]", int[].class);
        registerAlias("_integer[]", int[].class);
        registerAlias("_double[]", double[].class);
        registerAlias("_float[]", float[].class);
        registerAlias("_boolean[]", boolean[].class);
    
        registerAlias("date", Date.class);
        registerAlias("decimal", BigDecimal.class);
        registerAlias("bigdecimal", BigDecimal.class);
        registerAlias("biginteger", BigInteger.class);
        registerAlias("object", Object.class);
    
        registerAlias("date[]", Date[].class);
        registerAlias("decimal[]", BigDecimal[].class);
        registerAlias("bigdecimal[]", BigDecimal[].class);
        registerAlias("biginteger[]", BigInteger[].class);
        registerAlias("object[]", Object[].class);
    
        registerAlias("map", Map.class);
        registerAlias("hashmap", HashMap.class);
        registerAlias("list", List.class);
        registerAlias("arraylist", ArrayList.class);
        registerAlias("collection", Collection.class);
        registerAlias("iterator", Iterator.class);
    
        registerAlias("ResultSet", ResultSet.class);
      }

#### 1.5 TypeHandler ####

由于Java类型和数据库的JDBC类型不是一一对应的（比如String与varchar、char、text），所以我们把Java对象转换为数据库的值，和把数据库的值转换成Java对象，需要经过一定的转换，这两个方向的转换就要用到TypeHandler。

当参数类型和返回值是一个对象的时候，没有做任何的配置，为什么对象里面的一个String属性，可以转换成数据库里面的varchar字段？

这是因为MyBatis已经内置了很多TypeHandler（在type包下），它们全部全部注册在TypeHandlerRegistry中，他们都继承了抽象类BaseTypeHandler，泛型就是要处理的Java数据类型。

这个也是为什么大部分类型都不需要处理。当我们查询数据和登记数据，做数据类型转换的时候，就会自动调用对应的TypeHandler的方法。  
![在这里插入图片描述][326bf7b9847a4c00b7173ffe3745f3d1.png_pic_center]

#### 1.6 objectFactory ####

当我们把数据库返回的结果集转换为实体类的时候，需要创建对象的实例，由于我们不知道需要处理的类型是什么，有哪些属性，所以不能用new的方式去创建。只能通过反射来创建。

在MyBatis里面，它提供了一个工厂类的接口，叫做ObjectFactory，专门用来创建对象的实例（MyBatis封装之后，简化了对象的创建），里面定义了4个方法。

package org.apache.ibatis.reflection.factory;
    
    import java.util.List;
    import java.util.Properties;
    
    public interface ObjectFactory {
        
    
      default void setProperties(Properties properties) {
        
        // NOP
      }
      <T> T create(Class<T> type);
      <T> T create(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs);
      <T> boolean isCollection(Class<T> type);
    
    }

<table> 
 <thead> 
  <tr> 
   <th><strong>方法</strong></th> 
   <th><strong>作用</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>void</strong> setProperties(Properties properties);</td> 
   <td>设置参数时调用</td> 
  </tr> 
  <tr> 
   <td> T create(Class type);</td> 
   <td>创建对象（调用无参构造函数）</td> 
  </tr> 
  <tr> 
   <td> T create(Class type, List&lt;Class&lt;?&gt;&gt; constructorArgTypes, List constructorArgs);</td> 
   <td>创建对象（调用带参数构造函数）</td> 
  </tr> 
  <tr> 
   <td> <strong>boolean</strong> isCollection(Class type)</td> 
   <td>判断是否集合</td> 
  </tr> 
 </tbody> 
</table>

ObjectFactory有一个默认的实现类DefaultObjectFactory。创建对象的方法最终都调用了instantiateClass()，这里面能看到反射的代码（代码片段如下）：

public class DefaultObjectFactory implements ObjectFactory, Serializable {
        
        private static final long serialVersionUID = -8855120656740914948L;
    
        public DefaultObjectFactory() {
        
        }
    
        public <T> T create(Class<T> type) {
        
            return this.create(type, (List)null, (List)null);
        }
    
        public <T> T create(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
        
            Class<?> classToCreate = this.resolveInterface(type);
            return this.instantiateClass(classToCreate, constructorArgTypes, constructorArgs);
        }
    
        private <T> T instantiateClass(Class<T> type, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
        
            try {
        
                Constructor constructor;
                if (constructorArgTypes != null && constructorArgs != null) {
        
                    constructor = type.getDeclaredConstructor((Class[])constructorArgTypes.toArray(new Class[0]));
    
                    try {
        
                        return constructor.newInstance(constructorArgs.toArray(new Object[0]));
                    } catch (IllegalAccessException var7) {
        
                        if (Reflector.canControlMemberAccessible()) {
        
                            constructor.setAccessible(true);
                            return constructor.newInstance(constructorArgs.toArray(new Object[0]));
                        } else {
        
                            throw var7;
                        }
                    }
                } else {
        
                    constructor = type.getDeclaredConstructor();
    
                    try {
        
                        return constructor.newInstance();
                    } catch (IllegalAccessException var8) {
        
                        if (Reflector.canControlMemberAccessible()) {
        
                            constructor.setAccessible(true);
                            return constructor.newInstance();
                        } else {
        
                            throw var8;
                        }
                    }
                }
            } catch (Exception var9) {
        
                String argTypes = (String)((List)Optional.ofNullable(constructorArgTypes).orElseGet(Collections::emptyList)).stream().map(Class::getSimpleName).collect(Collectors.joining(","));
                String argValues = (String)((List)Optional.ofNullable(constructorArgs).orElseGet(Collections::emptyList)).stream().map(String::valueOf).collect(Collectors.joining(","));
                throw new ReflectionException("Error instantiating " + type + " with invalid types (" + argTypes + ") or values (" + argValues + "). Cause: " + var9, var9);
            }
        }

默认情况下，所有的对象都是由DefaultObjectFactory创建。

package com.sissie.objectfactory;
    
    import com.sissie.domain.User;
    import org.apache.ibatis.reflection.factory.DefaultObjectFactory;
    
    /**
     *
     * 自定义ObjectFactory，通过反射的方式实例化对象
     * 一种是无参构造函数，一种是有参构造函数——第一个方法调用了第二个方法
     */
    public class MyObjectFactory extends DefaultObjectFactory {
        
    
        @Override
        public Object create(Class type) {
        
            System.out.println("创建对象方法：" + type);
            if (type.equals(User.class)) {
        
                User blog = (User) super.create(type);
                blog.setUserName("object factory");
                blog.setId(1111);
                blog.setRealName("张三");
                return blog;
            }
            Object result = super.create(type);
            return result;
        }
    
    }

测试使用

public class ObjectFactoryTest {
        
        public static void main(String[] args) {
        
            MyObjectFactory factory = new MyObjectFactory();
            User myBlog = (User) factory.create(User.class);
            System.out.println(myBlog);
        }
    }

如果在config文件里面注册，在创建对象的时候会被自动调用：

<objectFactory type="com.sissie.objectfactory.MyObjectFactory">
            <property name="boge" value="666"/>
        </objectFactory>

这样，就可以让MyBatis的创建实体类的时候使用我们自己的对象工厂。  
默认情况下，所有的对象都是由DefaultObjectFactory创建。

package com.boge.objectfactory;
    
    import com.boge.domain.User;
    import org.apache.ibatis.reflection.factory.DefaultObjectFactory;
    
    /**
     *
     * 自定义ObjectFactory，通过反射的方式实例化对象
     * 一种是无参构造函数，一种是有参构造函数——第一个方法调用了第二个方法
     */
    public class MyObjectFactory extends DefaultObjectFactory {
        
    
        @Override
        public Object create(Class type) {
        
            System.out.println("创建对象方法：" + type);
            if (type.equals(User.class)) {
        
                User blog = (User) super.create(type);
                blog.setUserName("object factory");
                blog.setId(1111);
                blog.setRealName("张三");
                return blog;
            }
            Object result = super.create(type);
            return result;
        }
    
    }

测试使用

如果在config文件里面注册，在创建对象的时候会被自动调用：

<objectFactory type="com.boge.objectfactory.MyObjectFactory">
            <property name="boge" value="666"/>
        </objectFactory>

这样，就可以让MyBatis的创建实体类的时候使用我们自己的对象工厂。

#### 1.7 plugins ####

插件是MyBatis的一个很强大的机制。跟很多其他的框架一样，MyBatis预留了插件的接口，让MyBatis更容易扩展。

http://www.mybatis.org/mybatis-3/zh/configuration.html\#plugins

#### 1.8 environments ####

environments标签用来管理数据库的环境，比如项目中有开发环境、测试环境、生产环境的数据库。可以在不同的环境中使用不同的数据库地址或者类型。

**environment**

一个environment标签就是一个数据源，代表一个数据库。这里面有两个关键的标签，一个是事务管理器，一个是数据源。

**transactionManager**

如果配置的是JDBC，则会使用Connection对象的commit()、rollback()、close()管理事务。

如果配置成MANAGED，会把事务交给容器来管理，比如JBOSS，Weblogic。如果跑的是本地程序，配置成MANAGE不会有任何事务。

如果是Spring + MyBatis，则没有必要配置，因为会直接在applicationContext.xml里面配置数据源和事务，覆盖MyBatis的配置。

**dataSource**

数据源，顾名思义，就是数据的来源，一个数据源就对应一个数据库。在Java里面，它是对数据库连接的一个抽象。

一般的数据源都会包括连接池管理的功能，所以很多时候也把DataSource直接 称为连接池，准确的说法应该是：带连接池功能的数据源。

#### 1.9 mappers ####

标签配置的是映射器，也就是Mapper.xml的路径。这里配置的目的是让MyBatis在启动的时候去扫描这些映射器，创建映射关系。

有四种指定Mapper文件的方式：

> 网址：http://www.mybatis.org/mybatis-3/zh/configuration.html\#mappers

a.使用相对于类路径的资源引用（resource）

b.使用完全限定资源定位符（绝对路径）（URL）

c.使用映射器接口实现类的完全限定类名

d.将包内的映射器接口实现全部注册为映射器（最常用）

### 2. 映射文件 ###

MyBatis 的真正强大在于它的语句映射，这是它的魔力所在。由于它的异常强大，映射器的 XML 文件就显得相对简单。如果拿它跟具有相同功能的 JDBC 代码进行对比，你会立即发现省掉了将近 95% 的代码。MyBatis 致力于减少使用成本，让用户能更专注于 SQL 代码。

SQL 映射文件只有很少的几个顶级元素（按照应被定义的顺序列出）：

| 表示：元素之间无先后顺序

\*表示：不限，也可以没有

\+表示：至少要有一个

![image.png][]

*  `cache` – 该命名空间的缓存配置。
 *  `cache-ref` – 引用其它命名空间的缓存配置。
 *  `resultMap` – 描述如何从数据库结果集中加载对象，是最复杂也是最强大的元素。
 *  `parameterMap` – 老式风格的参数映射。此元素已被废弃，并可能在将来被移除！请使用行内参数映射。文档中不会介绍此元素。
 *  `sql` – 可被其它语句引用的可重用语句块。
 *  `insert` – 映射插入语句。
 *  `update` – 映射更新语句。
 *  `delete` – 映射删除语句。
 *  `select` – 映射查询语句。

#### 2.1 cache ####

给定命名空间的缓存配置（是否开启二级缓存）。

全局开启，单独的设置：useCache="false"也不会走缓存了。

<?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.boge.mapper.UserMapper">
    
        <cache />
    
      <resultMap id="BaseResultMap" type="user" >
        <id property="id" column="id" jdbcType="INTEGER"/>
        <result property="userName" column="user_name" jdbcType="VARCHAR" />
        <result property="realName" column="real_name" jdbcType="VARCHAR" />
        <result property="password" column="password" jdbcType="VARCHAR"/>
        <result property="age" column="age" jdbcType="INTEGER"/>
      </resultMap>
    
      <select id="selectUserById" useCache="false"   resultMap="BaseResultMap" statementType="PREPARED" parameterType="_int" >
            select
             id,
             user_name ,
             real_name ,
             password,
             age
             from t_user where id = #{id}
        </select>
    
    </mapper>

#### 2.2 cache-ref ####

其他命名空间缓存配置的引用。

#### 2.3 resultMap ####

是最复杂也是最强大的元素，用来描述如何从数据库结果集中来加载对象。

#### 2.4 sql ####

可被其他语句引用的可重用语句块。

<sql id="Base_Column_List">
    emp_id, emp_name, gender, email, d_id
    </sql>

#### 2.5 增删改查标签 ####

针对常用的增删改查操作提供的有对应的标签来处理

<insert> – 映射插入语句

<update> – 映射更新语句

<delete> – 映射删除语句

<table> 
 <thead> 
  <tr> 
   <th align="left">属性</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>id</code></td> 
   <td align="left">在命名空间中唯一的标识符，可以被用来引用这条语句。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>parameterType</code></td> 
   <td align="left">将会传入这条语句的参数的类全限定名或别名。这个属性是可选的，因为 MyBatis 可以通过类型处理器（TypeHandler）推断出具体传入语句的参数，默认值为未设置（unset）。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>parameterMap</code></td> 
   <td align="left">用于引用外部 parameterMap 的属性，目前已被废弃。请使用行内参数映射和 parameterType 属性。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>resultType</code></td> 
   <td align="left">期望从这条语句中返回结果的类全限定名或别名。 注意，如果返回的是集合，那应该设置为集合包含的类型，而不是集合本身的类型。 resultType 和 resultMap 之间只能同时使用一个。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>resultMap</code></td> 
   <td align="left">对外部 resultMap 的命名引用。结果映射是 MyBatis 最强大的特性，如果你对其理解透彻，许多复杂的映射问题都能迎刃而解。 resultType 和 resultMap 之间只能同时使用一个。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>flushCache</code></td> 
   <td align="left">将其设置为 true 后，只要语句被调用，都会导致本地缓存和二级缓存被清空，默认值：false。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>useCache</code></td> 
   <td align="left">将其设置为 true 后，将会导致本条语句的结果被二级缓存缓存起来，默认值：对 select 元素为 true。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>timeout</code></td> 
   <td align="left">这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为未设置（unset）（依赖数据库驱动）。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>fetchSize</code></td> 
   <td align="left">这是一个给驱动的建议值，尝试让驱动程序每次批量返回的结果行数等于这个设置值。 默认值为未设置（unset）（依赖驱动）。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>statementType</code></td> 
   <td align="left">可选 STATEMENT，PREPARED 或 CALLABLE。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>resultSetType</code></td> 
   <td align="left">FORWARD_ONLY，SCROLL_SENSITIVE, SCROLL_INSENSITIVE 或 DEFAULT（等价于 unset） 中的一个，默认值为 unset （依赖数据库驱动）。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>databaseId</code></td> 
   <td align="left">如果配置了数据库厂商标识（databaseIdProvider），MyBatis 会加载所有不带 databaseId 或匹配当前 databaseId 的语句；如果带和不带的语句都有，则不带的会被忽略。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>resultOrdered</code></td> 
   <td align="left">这个设置仅针对嵌套结果 select 语句：如果为 true，将会假设包含了嵌套结果集或是分组，当返回一个主结果行时，就不会产生对前面结果集的引用。 这就使得在获取嵌套结果集的时候不至于内存不够用。默认值：<code>false</code>。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>resultSets</code></td> 
   <td align="left">这个设置仅适用于多结果集的情况。它将列出语句执行后返回的结果集并赋予每个结果集一个名称，多个名称之间以逗号分隔。</td> 
  </tr> 
 </tbody> 
</table>

## MyBatis最佳实践 ##

### 1.动态SQL语句 ###

动态 SQL 是 MyBatis 的强大特性之一。

使用动态 SQL 并非一件易事，但借助可用于任何 SQL 映射语句中的强大的动态 SQL 语言，MyBatis 显著地提升了这一特性的易用性。

*  if
 *  choose (when, otherwise)
 *  trim (where, set)
 *  foreach

#### 1.1 if ####

需要判断的时候，条件写在test中

<select id="selectListIf" parameterType="user" resultMap="BaseResultMap" >
            select
                <include refid="baseSQL"></include>
            from t_user
            <where>
                <if test="id != null">
                    and id = #{id}
                </if>
                <if test="userName != null">
                    and user_name = #{userName}
                </if>
            </where>
        </select>

#### 1.2 choose ####

需要选择一个条件的时候

<select id="selectListChoose" parameterType="user" resultMap="BaseResultMap" >
            select
            <include refid="baseSQL"></include>
            from t_user
            <where>
                <choose>
                    <when test="id != null">
                        id = #{id}
                    </when>
                    <when test="userName != null and userName != ''">
                        and user_name like CONCAT(CONCAT('%',#{userName,jdbcType=VARCHAR}),'%')
                    </when>
                    <otherwise>
    
                    </otherwise>
                </choose>
            </where>
        </select>

#### 1.3 trim ####

需要去掉where、and、逗号之类的符号的时候

<select id="selectListTrim" resultMap="BaseResultMap" 
                parameterType="user">
            select <include refid="baseSQL"></include>
            
            <trim prefix="where" prefixOverrides="AND |OR ">
                <if test="userName!=null">
                    and user_name = #{userName}
                </if>
                <if test="age != 0">
                    and age = #{age}
                </if>
            </trim>
        </select>
    
        
        <update id="updateUser" parameterType="User">
            update t_user
            <trim prefix="set" suffixOverrides=",">
                <if test="userName!=null">
                    user_name = #{userName},
                </if>
                <if test="age != 0">
                    age = #{age}
                </if>
            </trim>
            where id=#{id}
        </update>

#### 1.4 foreach ####

需要遍历集合的时候

<delete id="deleteByList" parameterType="java.util.List">
             delete from t_user 
             where id in
            <foreach collection="list" item="item" open="(" separator="," close=")">
                 #{item.id,jdbcType=INTEGER}
            </foreach>
        </delete>

动态SQL主要是用来解决SQL语句生成的问题。

### 2.批量操作 ###

在项目中会有一些批量操作的场景，比如导入文件批量处理数据的情况（批量新增商户、批量修改商户信息），当数据量非常大，比如超过几万条的时候，在Java代码中循环发送SQL到数据库执行肯定是不现实的，因为这个意味着要跟数据库创建几万次会话。即使在同一个连接中，也有重复编译和执行SQL的开销。

例如循环插入10000条（大约耗时3秒钟）：

public class Test03Batch {
        
    
        public SqlSession session;
    
        @Before
        public void init() throws IOException {
        
            // 1.获取配置文件
            InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
            // 2.加载解析配置文件并获取SqlSessionFactory对象
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
            // 3.根据SqlSessionFactory对象获取SqlSession对象
            session = factory.openSession();
        }
    
        /**
         * 循环插入10000
         */
        @Test
        public void test1(){
        
            long start = System.currentTimeMillis();
            UserMapper mapper = session.getMapper(UserMapper.class);
            int count = 12000;
            for (int i=2000; i< count; i++) {
        
                User user = new User();
                user.setUserName("a"+i);
                mapper.insertUser(user);
             }
             session.commit();
             session.close();
             long end = System.currentTimeMillis();
             System.out.println("循环批量插入"+count+"条，耗时：" + (end -start )+"毫秒");
        }
    }

在MyBatis里面是支持批量的操作的，包括批量的插入、更新、删除。我们可以直接传入一个List、Set、Map或者数组，配合动态SQL的标签，MyBatis会自动帮我们生成语法正确的SQL语句。

#### 2.1 批量插入 ####

批量插入的语法是这样的，只要在values后面增加插入的值就可以了。

insert into tbl_emp (emp_id, emp_name, gender,email, d_id) values ( ?,?,?,?,? ),( ?,?,?,?,? ),( ?,?,?,?,? )

在Mapper文件里面，我们使用foreach标签拼接 values部分的语句：

<insert id="insertUserList" parameterType="java.util.List" >
            insert into t_user(user_name,real_name)
            values
            <foreach collection="list" item="user" separator=",">
                (#{user.userName},#{user.realName})
            </foreach>
    
        </insert>

Java代码里面，直接传入一个List类型的参数。

/**
         * 批量插入
         */
        @Test
        public void test2(){
        
            long start = System.currentTimeMillis();
            UserMapper mapper = session.getMapper(UserMapper.class);
            int count = 12000;
            List<User> list = new ArrayList<>();
            for (int i=2000; i< count; i++) {
        
                User user = new User();
                user.setUserName("a"+i);
                list.add(user);
            }
            mapper.insertUserList(list);
            session.commit();
            session.close();
            long end = System.currentTimeMillis();
            System.out.println("循环批量插入"+count+"条，耗时：" + (end -start )+"毫秒");
        }

插入一万条大约耗时1秒钟。

可以看到，动态SQL批量插入效率要比循环发送SQL执行要高得多。最关键的地方就在于减少了跟数据库交互的次数，并且避免了开启和结束事务的时间消耗。

#### 2.2 批量更新 ####

批量更新的语法是这样的，通过case when，来匹配id相关的字段值

update t_user set 
    user_name = 
    case id 
    when ? then ? 
    when ? then ? 
    when ? then ? end ,
    nick_name = 
    case id
    when ? then ? 
    when ? then ? 
    when ? then ? end 
    where id in ( ? , ? , ? )

所以在Mapper文件里面最关键的就是case when和where的配置。

需要注意一下open属性和separator属性。

<update id="updateUserList">
         update t_user set
            user_name =
            <foreach collection="list" item="user" index="index" separator=" " open="case id" close="end">
            when #{user.id} then #{user.userName}
            </foreach>
             ,nick_name =
             <foreach collection="list" item="user" index="index" separator=" " open="case id" close="end">
              when #{user.id} then #{user.nickName}
             </foreach>
             where id in
             <foreach collection="list" item="item" open="(" separator="," close=")">
              #{item.id,jdbcType=INTEGER}
             </foreach>
         </update>

java代码实现

/**
         * 批量更新
         */
        @Test
        public void test3(){
        
            long start = System.currentTimeMillis();
            UserMapper mapper = session.getMapper(UserMapper.class);
            int count = 12000;
            List<User> list = new ArrayList<>();
            for (int i=2000; i< count; i++) {
        
                User user = new User();
                user.setId(i);
                user.setUserName("a"+i);
                list.add(user);
            }
            mapper.updateUserList(list);
            session.commit();
            session.close();
            long end = System.currentTimeMillis();
            System.out.println("批量更新"+count+"条，耗时：" + (end -start )+"毫秒");
        }

#### 2.3 批量删除 ####

批量删除也是类似的。

<delete id="deleteByList" parameterType="java.util.List">
             delete from t_user where id in
            <foreach collection="list" item="item" open="(" separator="," close=")">
                #{item.id,jdbcType=INTEGER}
            </foreach>
        </delete>

#### 2.4 BatchExecutor ####

当然MyBatis的动态标签的批量操作也是存在一定的缺点的，比如数据量特别大的时候，拼接出来的SQL语句过大。

MySQL的服务端对于接收的数据包有大小限制，max\_allowed\_packet 默认是 4M，需要修改默认配置或者手动地控制条数，才可以解决这个问题。

Caused by: com.mysql.jdbc.PacketTooBigException: Packet for query is too large (7188967 > 4194304). You can change this value on the server by setting the max_allowed_packet' variable.

在我们的全局配置文件中，可以配置默认的Executor的类型（默认是SIMPLE）。其中有一种BatchExecutor。

也可以在创建会话的时候指定执行器类型

SqlSession session = sqlSessionFactory.openSession(ExecutorType.BATCH);

**Executor**

![image.png][image.png 1]

1.  SimpleExecutor：每执行一次update或select，就开启一个Statement对象，用完立刻关闭Statement对象。
2.  ReuseExecutor：执行update或select，以sql作为key查找Statement对象，存在就使用，不存在就创建，用完后，不关闭Statement对象，而是放置于Map内，供下一次使用。简言之，就是重复使用Statement对象。
3.  BatchExecutor：执行update（没有select，JDBC批处理不支持select），将所有sql都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个Statement对象，每个Statement对象都是addBatch()完毕后，等待逐一执行executeBatch()批处理。与JDBC批处理相同。executeUpdate()是一个语句访问一次数据库，executeBatch()是一批语句访问一次数据库（具体一批发送多少条SQL跟服务端的max\_allowed\_packet有关）。BatchExecutor底层是对JDBC ps.addBatch()和ps. executeBatch()的封装。

@Test
    public void testJdbcBatch() throws IOException {
        
       Connection conn = null;
       PreparedStatement ps = null;
    
       try {
        
           conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatisdb?rewriteBatchedStatements=true", "root", "123456");
           ps = conn.prepareStatement(
                   "INSERT into blog values (?, ?, ?)");
    
           for (int i = 1000; i < 101000; i++) {
        
               Blog blog = new Blog();
               ps.setInt(1, i);
               ps.setString(2, String.valueOf(i)+"");
               ps.setInt(3, 1001);
               ps.addBatch();
          }
    
           ps.executeBatch();
           ps.close();
           conn.close();
      } catch (SQLException se) {
        
           se.printStackTrace();
      } catch (Exception e) {
        
           e.printStackTrace();
      } finally {
        
           try {
        
               if (ps != null) ps.close();
          } catch (SQLException se2) {
        
          }
           try {
        
               if (conn != null) conn.close();
          } catch (SQLException se) {
        
               se.printStackTrace();
          }
      }
    }

### 3.关联查询 ###

#### 3.1 嵌套查询 ####

我们在查询业务数据的时候经常会遇到关联查询的情况，比如查询员工就会关联部门（一对一），查询学生成绩就会关联课程（一对一），查询订单就会关联商品（一对多），等等。

用户和部门的对应关系是1对1的关系

<resultMap id="nestedMap1" type="user">
            <id property="id" column="id" jdbcType="INTEGER"/>
            <result property="userName" column="user_name" jdbcType="VARCHAR" />
            <result property="nickName" column="nick_name" jdbcType="VARCHAR" />
            <result property="password" column="password" jdbcType="VARCHAR"/>
            <result property="age" column="age" jdbcType="INTEGER"/>
            <result property="dId" column="d_id" jdbcType="INTEGER"/>
            <association property="dept" javaType="dept">
                <id column="did" property="dId"/>
                <result column="d_name" property="dName"/>
                <result column="d_desc" property="dDesc"/>
            </association>
        </resultMap>
    
        <select id="queryUserNested" resultMap="nestedMap1">
            SELECT
                t1.`id`
                ,t1.`user_name`
                ,t1.`nick_name`
                ,t1.`password`
                ,t1.`age`
                ,t2.`did`
                ,t2.`d_name`
                ,t2.`d_desc`
            FROM t_user t1
            LEFT JOIN
                t_department t2
                ON t1.`d_id` = t2.`did`
        </select>

还有就是1对多的关联关系，嵌套查询

<resultMap id="nestedMap2" type="dept">
            <id column="did" property="dId"/>
            <result column="d_name" property="dName"/>
            <result column="d_desc" property="dDesc"/>
            <collection property="users" ofType="user">
                <id property="id" column="id" jdbcType="INTEGER"/>
                <result property="userName" column="user_name" jdbcType="VARCHAR" />
                <result property="nickName" column="nick_name" jdbcType="VARCHAR" />
                <result property="password" column="password" jdbcType="VARCHAR"/>
                <result property="age" column="age" jdbcType="INTEGER"/>
                <result property="dId" column="d_id" jdbcType="INTEGER"/>
            </collection>
        </resultMap>
        <select id="queryDeptNested" resultMap="nestedMap2">
            SELECT
                t1.`id`
                ,t1.`user_name`
                ,t1.`nick_name`
                ,t1.`password`
                ,t1.`age`
                ,t2.`did`
                ,t2.`d_name`
                ,t2.`d_desc`
            FROM t_user t1
            RIGHT JOIN
                t_department t2
                ON t1.`d_id` = t2.`did`
        </select>

#### 3.2 延迟加载 ####

在MyBatis里面可以通过开启延迟加载的开关来解决这个问题。

在settings标签里面可以配置：

<setting name="lazyLoadingEnabled" value="true"/>
    
    <setting name="aggressiveLazyLoading" value="false"/>
    
    <setting name="proxyFactory" value="CGLIB" />

lazyLoadingEnabled决定了是否延迟加载（默认false）。

aggressiveLazyLoading决定了是不是对象的所有方法都会触发查询。

1对1的延迟加载配置

<resultMap id="nestedMap1Lazy" type="user">
            <id property="id" column="id" jdbcType="INTEGER"/>
            <result property="userName" column="user_name" jdbcType="VARCHAR" />
            <result property="nickName" column="nick_name" jdbcType="VARCHAR" />
            <result property="password" column="password" jdbcType="VARCHAR"/>
            <result property="age" column="age" jdbcType="INTEGER"/>
            <result property="dId" column="d_id" jdbcType="INTEGER"/>
            <association property="dept" javaType="dept" column="d_id" select="queryDeptByUserIdLazy">
    
            </association>
        </resultMap>
        <resultMap id="baseDept" type="dept">
            <id column="did" property="dId"/>
            <result column="d_name" property="dName"/>
            <result column="d_desc" property="dDesc"/>
        </resultMap>
        <select id="queryUserNestedLazy" resultMap="nestedMap1Lazy">
            SELECT
                t1.`id`
                ,t1.`user_name`
                ,t1.`real_name`
                ,t1.`password`
                ,t1.`age`
                ,t1.d_id
            FROM t_user t1
        </select>
        <select id="queryDeptByUserIdLazy" parameterType="int" resultMap="baseDept">
            select * from t_department where did = #{did}
        </select>

**注意**：开启了延迟加载的开关，调用user.getDept()以及默认的（equals,clone,hashCode,toString）时才会发起第二次查询，其他方法并不会触发查询，比如blog.getName()；

/**
         * 1对1  关联查询 延迟加载
         * @throws Exception
         */
        @Test
        public void test03() throws Exception{
        
            init();
            UserMapper mapper = session.getMapper(UserMapper.class);
            List<User> users = mapper.queryUserNestedLazy();
            for (User user : users) {
        
                System.out.println(user.getUserName() );
            }
        }

触发延迟加载的方法可以通过<lazyLoadTriggerMethods>配置，默认 equals(),clone(),hashCode(),toString()。

1对多的延迟加载的配置

<resultMap id="nestedMap2Lazy" type="dept">
            <id column="did" property="dId"/>
            <result column="d_name" property="dName"/>
            <result column="d_desc" property="dDesc"/>
            <collection property="users" ofType="user" column="did" select="queryUserByDeptLazy">
            </collection>
        </resultMap>
    
        <select id="queryDeptNestedLazy" resultMap="nestedMap2">
            SELECT
                ,t2.`did`
                ,t2.`d_name`
                ,t2.`d_desc`
            FROM
                t_department t2
    
        </select>
    
        <select id="queryUserByDeptLazy"  resultMap="BaseResultMap" >
            select * from t_user where d_id = #{did}
        </select>

### 4.分页操作 ###

#### 4.1 逻辑分页 ####

MyBatis里面有一个逻辑分页对象RowBounds，里面主要有两个属性，offset和limit（从第几条开始，查询多少条）。我们可以在Mapper接口的方法上加上这个参数，不需要修改xml里面的SQL语句。

接口中定义

public List<User> queryUserList(RowBounds rowBounds);

测试类

@Test
        public void test01() throws Exception{
        
            init();
            UserMapper mapper = session.getMapper(UserMapper.class);
            // 设置分页的数据
            RowBounds rowBounds = new RowBounds(1,3);
            List<User> users = mapper.queryUserList(rowBounds);
            for (User user : users) {
        
                System.out.println(user);
            }
        }

RowBounds的工作原理其实是对ResultSet的处理。它会舍弃掉前面offset条数据，然后再取剩下的数据的limit条。

// DefaultResultSetHandler.java
    private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
        
       DefaultResultContext<Object> resultContext = new DefaultResultContext();
       ResultSet resultSet = rsw.getResultSet();
       this.skipRows(resultSet, rowBounds);
       while(this.shouldProcessMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next()) {
        
           ResultMap discriminatedResultMap = this.resolveDiscriminatedResultMap(resultSet, resultMap, (String)null);
           Object rowValue = this.getRowValue(rsw, discriminatedResultMap, (String)null);
           this.storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);
      }
    }

很明显，如果数据量大的话，这种翻页方式效率会很低（跟查询到内存中再使用subList(start,end)没什么区别）。  
**所以分页功能常用的是：物理翻页。**

#### 4.2 物理分页 ####

物理翻页是真正的翻页，它是通过数据库支持的语句来翻页。

第一种简单的办法就是传入参数（或者包装一个page对象），在SQL语句中翻页。

<select id="selectUserPage" parameterType="map" resultMap="BaseResultMap">
      select * from t_user limit #{curIndex} , #{pageSize}
    </select>

第一个问题是要在Java业务代码里面去计算起止序号；第二个问题是：每个需要翻页的Statement都要编写limit语句，会造成Mapper映射器里面很多代码冗余。

那就需要一种通用的方式，不需要去修改配置的任何一条SQL语句，只要传入当前是第几页，每页多少条就可以了，自动计算出来起止序号。

最常用的做法就是使用翻页的插件，比如PageHelper。

// pageSize每一页几条
    PageHelper.startPage(pn, 10);
    List<Employee> emps = employeeService.getAll();
    // navigatePages 导航页码数
    PageInfo page = new PageInfo(emps, 10);
    return Msg.success().add("pageInfo", page);

PageHelper是通过MyBatis的拦截器实现的，简单地来说，它会根据PageHelper的参数，改写SQL语句。比如MySQL会生成limit语句。

[e4479925f38f4ded900891261a270644.png]: https://img-blog.csdnimg.cn/e4479925f38f4ded900891261a270644.png
[898f3a0f52084091b66c67800a1efb8a.png_pic_center]: https://img-blog.csdnimg.cn/898f3a0f52084091b66c67800a1efb8a.png#pic_center
[221a0390f40248c2a37cf6a5573857d0.png_pic_center]: https://img-blog.csdnimg.cn/221a0390f40248c2a37cf6a5573857d0.png#pic_center
[326bf7b9847a4c00b7173ffe3745f3d1.png_pic_center]: https://img-blog.csdnimg.cn/326bf7b9847a4c00b7173ffe3745f3d1.png#pic_center
[image.png]: https://img-blog.csdnimg.cn/img_convert/bffd0973c62a045c99fd70404a4c5811.png
[image.png 1]: https://img-blog.csdnimg.cn/img_convert/971ec8dac2b0c825547a096544c82fa9.png