当前位置：首页 > news >正文

MyBatis面经

news 2026/2/10 13:28:35

MyBatis常见面试题

！！本文主要是博主总结看着玩的，不具有很高的参考价值，慎重

1、MyBatis是什么？MyBatis工作原理？MyBatis的使用场景有哪些？

MyBatis是一款优秀的持久层框架，它是一个基于Java语言的ORM框架，通过XML或注解的方式将Java对象和数据库中的表进行映射，实现持久化操作。

mybatis工作原理：
大家可以看一下源码。推荐文章MyBatis底层原理小白版本

mybatis配置文件，包括Mybatis全局配置文件和Mybatis映射文件，其中全局配置文件配置了数据源、事务等信息；映射文件配置了SQL执行相关的信息。

mybatis通过读取配置文件信息(全局配置文件和映射文件)，构造出SqlSessionFactory，即会话工厂。

通过SqlSessionFactory，可以创建SqlSession即会话。

Mybatis是通过SqlSession来操作数据库的。SqlSession本身不能直接操作数据库，它是通过底层的Executor执行器接口来操作数据库的。

Executor接口有两个实现类，一个是普通执行器，一个是缓存执行器(默认)。Executor执行器要处理的SQL信息是封装到一个底层对象MappedStatement中。

MyBatis在以下场景下都有着广泛的应用：

1、数据库访问操作：MyBatis提供了灵活的SQL语句编写和自定义的SQL映射，可以更加细粒度地控制SQL语句的执行，因此适用于需要对数据库进行复杂操作的场景。

2、大数据量操作：MyBatis的批量操作和分页查询功能能够很好地处理大量数据的访问和操作，因此适用于需要对大量数据进行操作的场景。

3、高并发访问：MyBatis的缓存机制可以有效地减少数据库访问的次数，提高系统的并发能力，因此适用于需要支持高并发访问的场景。

4、数据库事务处理：MyBatis支持事务处理机制，可以对多个操作进行事务管理，因此适用于需要进行数据库事务处理的场景。

5、多数据源操作：MyBatis可以支持多数据源的操作，可以同时连接多个数据库进行操作，因此适用于需要同时操作多个数据库的场景。
综上所述，MyBatis可以广泛应用于各种需要进行数据库访问和ORM操作的场景，特别是在需要高并发、大数据量和复杂操作的场景下更加适用。

2、MyBatis具有哪些优点？

MyBatis具有以下优点：

1、灵活性高：MyBatis提供了丰富的映射语句和灵活的配置，可以满足不同的需求。

2、易于掌握：MyBatis的学习曲线比较平稳，上手比较容易。

3、性能较好：MyBatis通过对SQL语句和结果集的缓存，可以提高系统的性能。

4、可以自由控制SQL：MyBatis支持使用动态SQL来构建复杂的SQL语句，可以自由控制SQL的执行。

5、易于集成：MyBatis可以与Spring等框架进行集成，方便与其他框架一起使用。

总之，MyBatis是一款功能强大、易于使用、性能出色的ORM框架，被广泛应用于各种Java项目中。

3、MyBatis的工作原理以及工作流程是什么？

依旧建议看底层原理MyBatis底层原理小白版本

MyBatis的工作原理可以简单地概括为以下三个步骤：

1、通过SqlSessionFactoryBuilder创建SqlSessionFactory对象；

2、通过SqlSessionFactory对象的openSession方法创建SqlSession对象；

3、通过SqlSession对象操作数据库，包括执行SQL语句、提交事务等。

MyBatis的工作流程如下：

1、加载MyBatis的配置文件，包括数据库连接信息、映射文件的位置等；

2、解析配置文件，创建Configuration对象，用于保存MyBatis的配置信息；

3、创建SqlSessionFactory（线程安全）对象，是用于创建SqlSession对象的工厂；

4、创建SqlSession对象，用于执行SQL语句的，一个SqlSession对象代表一次数据库连接；

5、通过SqlSession对象执行SQL语句，包括查询、插入、更新、删除等操作；

6、提交事务，如果需要的话；

7、关闭SqlSession对象，释放资源。

4、什么是MyBatis的接口绑定？有哪些实现方式？

接口绑定，就是在MyBatis中任意定义接口，然后把接口里面的方法和SQL语句绑定，我们直接调用接口方法就可以，这样比起原来了SqlSession提供的方法我们可以有更加灵活的选择和设置。

接口绑定有两种实现方式

通过注解绑定，就是在接口的方法上面加上 @Select、@Update等注解，里面包含Sql语句来绑定；
通过xml里面写SQL来绑定，在这种情况下，要指定xml映射文件里面的namespace必须为接口的全路径名。当Sql语句比较简单时候，用注解绑定，当SQL语句比较复杂时候，用xml绑定，一般用xml绑定的比较多。

5、当实体类中的属性名和表中的字段名不一样，怎么办？

查询sql的时候给查询出来的列起别名: 我们应尽量给列起别名而不是修改对应类的属性名，后者牵扯的太多

<!-- User{ int id; String pwd} -->
<select id = "getUser" parameterType="int" resultType="user">select id, password pwd from user where id = #{id}
</select>

通过来映射字段名和实体类属性名的一一对应的关系。

<select id = "getUser" parameterType="int" resultMap="userMap">select * from user where id = #{id}
</select>
<resultMap type="user" id="userMap"><!–用result属性来映射非主键字段，property为实体类属性名，column为数据库表中的属性–><result property ="id" column ="id"/><result property="pwd" column="password" />
</reslutMap>

6、在mapper中如何传递多个参数?

1. 顺序传参

public User selectUser(String name, int deptId);
<select id="selectUser" resultMap="UserResultMap">select * from userwhere user_name = #{0} and dept_id = #{1}
</select>
#{}里面的数字代表传入参数的顺序。
这种方法不建议使用，sql层表达不直观，且一旦顺序调整容易出错。

@Param注解传参法

public User selectUser(@Param("userName") String name, int @Param("deptId") deptId);
<select id="selectUser" resultMap="UserResultMap">select * from userwhere user_name = #{userName} and dept_id = #{deptId}
</select> 
#{}里面的名称对应的是注解@Param括号里面修饰的名称。
这种方法在参数不多的情况还是比较直观的，推荐使用。

Map传参法

public User selectUser(Map<String, Object> params);
<select id="selectUser" parameterType="java.util.Map" resultMap="UserResultMap">select * from userwhere user_name = #{userName} and dept_id = #{deptId}
</select>
#{}里面的名称对应的是Map里面的key名称。
这种方法适合传递多个参数，且参数易变能灵活传递的情况。

Java Bean传参法

public User selectUser(User user);
<select id="selectUser" parameterType="com.jourwon.pojo.User" resultMap="UserResultMap">select * from userwhere user_name = #{userName} and dept_id = #{deptId}
</select>
#{}里面的名称对应的是User类里面的成员属性。
这种方法直观，需要建一个实体类，扩展不容易，需要加属性，但代码可读性强，业务逻辑处理方便，推荐使用。

7、MyBatis中的#{}和${}有什么区别？

#{}是占位符，预编译处理；${}是拼接符，字符串替换，没有预编译处理。
Mybatis在处理#{}时，#{}传入参数是以字符串传入，会将SQL中的#{}替换为?号，调用PreparedStatement的set方法来赋值。
Mybatis在处理 ${}时，是原值传入，就是把${}替换成变量的值，相当于JDBC中的Statement编译
变量替换后，#{} 对应的变量自动加上单引号 ‘ ’；变量替换后，${} 对应的变量不会加上单引号 ‘ ’

#{} 可以有效的防止SQL注入，提高系统安全性；${} 不能防止SQL 注入

-- 假如 有个 id = 5 or 1=1
delete from 表名 where id = #{id} 
delete from 表名 where id = ${id}-- 执行上面两条sql
第一个会变成这样-> delete from 表名 where id = '5 or 1=1';--执行肯定是失败的
第一个会变成这样-> delete from 表名 where id = 5 or 1=1;--这种情况就是sql注入，如果没有id为5的，那么就会判断 1=1，
这样结果是必然成立的，那么 delete 就会将整个表的数据全都删掉。对于任意一行 where 1=1 都是成立的

#{} 的变量替换是在DBMS 中；${} 的变量替换是在 DBMS 外

怎么理解第六点：

#{} 是mybaits 中的一种动态sql的用法，#{} 用于预编译，由DBMS进行处理。

${} 是一种在很多基于文本的配置文件（比如属性文件、XML配置文件等）中常用的变量替换语法。

在这种情况下，${} 用于将变量的值直接替换到SQL语句或者其他配置中。这种替换发生在应用程序加载配置文件的时候，而不是在DBMS中

8、模糊查询like语句该怎么写?

'%${question}%' 可能引起SQL注入，不推荐

<select id="getStudent2" parameterType="String" resultMap="StudentTeacher">select * from student where name like '%${name}%'
</select>

"%"#{question}"%" 注意：因为#{…}解析成sql语句时候，会在变量外侧自动加单引号 ’ '，所以这里 % 需要使用双引号" "，不能使用单引号 ’ ’ ，不然会查不到任何结果。
```
<select id="getStudent2" parameterType="String" resultMap="StudentTeacher">select * from student where name like "%"#{name}"%"
</select>
```
CONCAT(‘%’,#{question},‘%’) 使用CONCAT()函数，推荐

oracle的concat函数只支持两个参数，但是mysql的concat函数支持好几个，更换数据库就要重新sql
```
<select id="getStudent2" parameterType="String" resultMap="StudentTeacher">select * from student where name like concat('%',#{name},'%')
</select>
```
使用bind标签

bind元素的作用是通过OGNL表达式去自定义一个上下文变量，这样更方便使用。在进行模糊查询时，如果是Mysql数据库，常常会用到的是一个concat,它用%和参数相连。然而在Oracle数据库则没有，Oracle数据库使用||进行连接。这样SQL就需要提供两种形式去实现。但是有了bind元素，就不必使用数据库的语言，而是使用MyBatis的动态SQL实现。
```
<select id="getStudent2" parameterType="String" resultMap="StudentTeacher"><bind name="pattern" value="'%'+name+'%'"/>select * from student where name like #{pattern}
</select>
```

9、MyBatis的动态SQL有哪些？如何使用动态SQL？

1、IF

<select id="findUserById" parameterType="int" resultType="User">select * from user where 1 = 1<if test="id != null">and id = #{id}</if><if test="username != null">and username = #{username}</if>
</select>

2、Where元素： Where元素用于将多个条件拼接在一起，如果第一个条件为真，则拼接"WHERE"关键字，否则拼接"AND"关键字,二人且若子句的开头为 ‘and’ 或者 ‘or’ 则也会删掉

<select id="findUser" parameterType="User" resultType="User">select * from user<where><!--只有当下面的条件有任何一个返回值的时候才会拼接 where--><if test="id != null">and id = #{id}</if><if test="username != null">and username = #{username}</if></where>
</select>

3、choose (when, otherwise) ：Choose元素类似于Java中的switch语句，用于选择一个分支执行。例如：

<select id="findUser" parameterType="User" resultType="User">select * from user<where><choose><when test="id != null">and id = #{id}</when><when test="username != null">and username = #{username}</when><otherwise>and 1 = 1</otherwise></choose></where>
</select>

4、Set: Set元素用于更新操作，通过Set元素可以动态地设置更新语句中的字段。例如：

<update id="updateUser" parameterType="User">update user<set><if test="username != null">username = #{username},</if><if test="password != null">password = #{password},</if></set>where id = #{id}
</update>

10、Mybatis如何执行批量操作

使用 <foreach> 标签

<!--
select * from blog where 1=1 and (id = 1 or id=2 or id=3)
我们现在传递一个万能的map，map中存在一个集合
-->
<select id="queryBlogForeach" parameterType="map" resultType="blog">select * from blog<where><foreach collection="ids" item="id" open="and (" separator="or" close=")">id = #{id}</foreach></where>
</select>

11、MyBatis实现一对一（多对一）有几种方式?具体怎么操作的？

第一种，按照结果嵌套查询

这种就简单的理解为：

我们已经把需要的表并在一起了，我们只需要选择我们需要的属性进行映射就行了。

<select id="getStudent2" resultMap="StudentTeacher2">select  s.id sid,s.name sname, t.name tnamefrom student s, teacher twhere s.tid = t.id
</select><resultMap id="StudentTeacher2" type="student"><result property="id" column="sid"/><result property="name" column="name"/><association property="teacher" javaType="teacher"><result property="name" column="tname"/></association>
</resultMap>
<!--
<association property="teacher" javaType="teacher"><result property="name" column="tname"/>
</association>
这种比较简单，<association>用来映射Student类的teacher属性 这个属性的类型也就是 javaType="teacher"；<select id="getStudent2">中我们需要的是 teacher的name属性，那么我们只需要映射一下tname就行
<result property="name" column="tname"/>
-->

第二种：按查询进行嵌套处理

这中就简单的理解为子查询

我们先查学生表的所有信息，将查到的tid 给子查询，让子查询找到对应的数据，再把结果返回

<select id="getStudent" resultMap="StudentTeacher">select * from student
<!-- select id,name,tid from student -->    
</select><resultMap id="StudentTeacher" type="student"><result property="id" column="id"/><result property="name" column="name"/><association property="teacher" javaType="teacher" select="getTeacher"column="tid"/>
</resultMap>
<!--
<association property="teacher" javaType="teacher" select="getTeacher"column="tid"/>
我们可以这样理解这句话：
我需要映射Student类的teacher属性，这个属性的java类型是Teacher，这个属性的数据从哪里来呢，我们需要调用 getTeacher 这个sql语句去查询，同时要传递给这个sql语句 参数进行查询。这个参数就是我们从 getStudent 查询语句中查出来的 tid 
--><select id="getTeacher" resultType="teacher">select * from teacher where id = #{??};
</select>
<!--
我们发现 id = #{??} #{}里面的内容即使改变了，对查询语句的结果是没有任何影响的
我们可以将理解为这样  select * from teacher where id = ?; 
我们知道sql中有预编译，也许本质就是下面这样呢 
preparedStatement.setInt(1, resuleSet.getInt("tid"));
当然，具体流程是啥我不清楚。只是想让大家明白 #{??} 里面的内用没啥影响，但不能为空，大家可以自己试一下。
-->

12、MyBatis实现一对多有几种方式,怎么操作的？

第一种，按照结果嵌套查询

<select id="getTeacher" resultMap="TeacherStudent">select s.id sid, s.name sname, t.name tname, t.id tidfrom student s,teacher twhere s.tid = t.id and t.id = #{tid}
</select><resultMap id="TeacherStudent" type="Teacher2"><result property="id" column="tid"/><result property="name" column="tname"/><collection property="students" javaType="ArrayList" ofType="Student2"><result property="id" column="sid"/><result property="name" column="sname"/><result property="tid" column="tid"/></collection>
</resultMap>
<!--
只要理解了上面的association，这个也就很好理解了
我们使用<collection> 去映射teacher类的students属性。
students 的 java类型是个集合 ， 集合里面存放的数据类型也就是泛型，是 ofType="Student2"
-->

第二种：按照查询进行嵌套

<select id="getTeacherById" resultMap="TeacherStudent">select id ddd, name from teacher where id = #{tid}
</select><resultMap id="TeacherStudent" type="Teacher2"><result property="id" column="ddd"/><result property="name" column="name"/><collection property="students" javaType="ArrayList" ofType="Student2"select="getStudentByTid" column="ddd"/>
</resultMap><select id="getStudentByTid" resultType="student2">select * from student where tid = #{hh}
</select>
<!--
同样， getStudentByTid 中的参数仍旧跟 #{}中的内容没有关系
而且，切记 ！ column一定是跟我们从数据库中查出来的列名保持一致
-->

13、通常一个Xml映射文件，都会写一个Dao接口与之对应，请问，这个Dao接口的工作原理是什么？Dao接口里的方法，参数不同时，方法能重载吗？

依旧建议看一下源码

Dao接口，就是人们常说的Mapper接口，接口的全限名，就是映射文件中的namespace的值，接口的方法名，就是映射文件中MappedStatement的id值，接口方法内的参数，就是传递给sql的参数。Mapper接口是没有实现类的，当调用接口方法时，接口全限名+方法名拼接字符串作为key值，可唯一定位一个MappedStatement，举例：

com.mybatis3.mappers.StudentDao.findStudentById，可以唯一找到namespace为com.mybatis3.mappers.StudentDao下面id = findStudentById的MappedStatement。在Mybatis中，每一个、、、标签，都会被解析为一个MappedStatement对象。

Dao接口里的方法，是不能重载的，因为是全限名+方法名的保存和寻找策略。

Dao接口的工作原理是JDK动态代理，Mybatis运行时会使用JDK动态代理为Dao接口生成代理proxy对象，代理对象proxy会拦截接口方法，转而执行MappedStatement所代表的sql，然后将sql执行结果返回。

另一种有争议的答案：
mybatis层面可以实现有条件的重载，但xml配置文件中的id是唯一不可重复的，所以对于重载的多个（同名）方法，都将指向同一个MapperStatement，但有潜在的异常风险，一般不建议使用

public Data getOne()
public Data getOne(@Parme("id") long id)
<select id="getOne" resultType="xxx.xxx.Data">SELECT * FROM data_table<if test="id != null">WHERE id = #{id}</if>
</select>
<!--
同时满足以下条件可以实现重载
a. 只有一个无参方法和一个有参方法
b. 有多个有参方法时，参数的数量需要相同，且使用相同的@Param值
-->

14、Mybatis是如何进行分页的？

MyBatis的分页方式有五种：基于关键字的分页、基于MyBatis物理分页插件的分页、基于MyBatis逻辑分页插件的分页、基于数据库的分页、基于应用程序的分页。

1、基于limit语句的分页

<select id="getStudent" parameterType="map" resultMap="StudentTeacher">select * from student limit #{offset},#{count};
</select>

2、基于RowBounds：RowBounds是将所有符合条件的数据全都查询到内存中，然后在内存中对数据进行分页，若数据量大，千万别使用RowBounds

mappep.xml里面正常配置，不用对rowBounds任何操作。mybatis的拦截器自动操作rowBounds进行分页。

XML：
<select id="getUserByRowBounds"  resultType="student2" >select * from student
</select>
接口：
List<Student2> getUserByRowBounds(RowBounds rowBounds);
使用：
RowBounds rowBounds = new RowBounds(0,2);
List<Student2> userList = mapper.getUserByRowBounds(rowBounds);

3、基于插件PageHelper（其实自定义插件也行）

导入相应依赖（注意版本匹配问题）

<dependency><groupId>com.github.pagehelper</groupId><artifactId>pagehelper</artifactId><version>5.2.0</version>
</dependency>

配置文件（注意依赖的版本）

<plugins><plugin interceptor="com.github.pagehelper.PageInterceptor">
<!--            <property name="dialect" value="mysql"/>--></plugin>
</plugins>

XML：
<select id="getUserByPageHelper"  resultType="student2" >select * from student
</select>
底层：
List<Student2> getUserByPageHelper();
使用：
int pageNo = 1;//第一页
int pageSize = 2;//每页两条数据
PageHelper.startPage(pageNo,pageSize);//注意，只会匹配最近的一条sql语句，每次使用，都要重新声明
List<Student2> userList = mapper.getUserByPageHelper();

15、MyBatis插件原理以及自定义插件

MyBatis的插件机制是一种扩展机制，可以在MyBatis执行SQL语句的各个阶段中插入自定义的逻辑，用于扩展或修改MyBatis的功能。

MyBatis的插件机制主要包括以下几个接口：

Interceptor：Interceptor是MyBatis插件的核心接口，所有的插件都要实现该接口，Interceptor中定义了四个方法，分别是intercept、plugin、setProperties和getProperties。

Executor：Executor是MyBatis的执行器，用于执行SQL语句。

MyBatis提供了三种执行器：SimpleExecutor、ReuseExecutor和BatchExecutor，Executor中定义了一些方法，如query、update等，可以被Interceptor拦截。

ParameterHandler：ParameterHandler用于处理JDBC ParameterStatement的参数，同样可以被Interceptor拦截。

ResultSetHandler：ResultSetHandler用于处理JDBC ResultSet的接口，同样可以被Interceptor拦截。

StatementHandler：StatementHandler是用于处理JDBC Statement的接口，同样可以被Interceptor拦截。

编写MyBatis插件的步骤如下：

1、实现Interceptor接口，并实现intercept方法，该方法中可以插入自定义的逻辑。

2、实现plugin方法，该方法用于返回一个代理对象，该代理对象包含了原始对象和Interceptor对象的逻辑，用于拦截原始对象的方法调用。

3、在mybatis-config.xml中配置插件，将Interceptor的实现类添加到plugins节点中。

下面是一个简单的插件实现示例：

@Intercepts({@Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})
})
public class MyPlugin implements Interceptor {@Overridepublic Object intercept(Invocation invocation) throws Throwable {// 在执行update方法前，输出日志System.out.println("Before executing update method.");Object result = invocation.proceed();// 在执行update方法后，输出日志System.out.println("After executing update method.");return result;}@Overridepublic Object plugin(Object target) {// 生成代理对象return Plugin.wrap(target, this);}@Overridepublic void setProperties(Properties properties) {// 设置插件属性}}

在上面的示例中，我们定义了一个MyPlugin类，实现了Interceptor接口，重写了intercept、plugin和setProperties方法。

注解@Intercepts用于标记拦截的对象和方法，@Signature用于标记拦截的方法参数类型。

intercept方法中，我们可以插入自定义的逻辑，例如在执行update方法前后输出日志。

plugin方法中，我们生成了一个代理对象，并将该代理对象返回。

setProperties方法中，我们可以设置插件的属性。

在完成插件的编写后，我们需要在mybatis-config.xml文件中配置插件，

例如：

<plugins><plugin interceptor="com.example.MyPlugin"><property name="property1" value="value1"/><property name="property2" value="value2"/></plugin>
</plugins>

在上面的配置中，我们将MyPlugin类作为插件的拦截器，并通过标签设置了插件的属性。

总之，MyBatis的插件机制是一种非常灵活的扩展机制，可以通过自定义的插件实现一些自己的功能，例如日志记录、缓存、分页等。

16、MyBatis中如何处理延迟加载？

MyBatis中的延迟加载可以通过两种方式来实现：基于动态代理的延迟加载和基于MyBatis自带的延迟加载机制。

基于动态代理的延迟加载

基于动态代理的延迟加载是MyBatis默认的延迟加载方式。

当查询主对象时，MyBatis只会查询主对象，而不会查询关联对象。

当需要使用关联对象时，MyBatis会通过动态代理的方式生成代理对象，再通过代理对象加载关联对象。

需要使用延迟加载功能时，只需要在Mapper.xml文件中使用或标签指定关联对象即可。

例如：

<!-- 延迟加载一对一关系的关联对象 -->
<association property="author" column="author_id" select="getAuthorById" fetchType="lazy"/><!-- 延迟加载一对多关系的关联对象 -->
<collection property="posts" column="id" select="getPostsByBlogId" fetchType="lazy"/>

基于MyBatis自带的延迟加载机制

基于MyBatis自带的延迟加载机制是指使用MyBatis提供的专门负责延迟加载的组件进行延迟加载。

该组件需要在MyBatis的配置文件中进行配置。

使用该组件时，需要在查询语句中使用ResultMap来指定关联对象，以便在查询时进行关联对象的加载。

例如：

<!-- 配置MyBatis自带的延迟加载机制 -->
<settings><setting name="lazyLoadingEnabled" value="true"/><setting name="aggressiveLazyLoading" value="false"/>
</settings>
<!-- 延迟加载一对一关系的关联对象 -->
<resultMap id="blogResult" type="Blog"><id property="id" column="id"/><result property="title" column="title"/><association property="author" column="author_id" select="getAuthorById" fetchType="lazy"/>
</resultMap><!-- 延迟加载一对多关系的关联对象 -->
<resultMap id="blogResult" type="Blog"><id property="id" column="id"/><result property="title" column="title"/><collection property="posts" column="id" select="getPostsByBlogId" fetchType="lazy"/>
</resultMap>

需要注意的是，基于动态代理的延迟加载方式只支持单个对象的延迟加载，即只能延迟加载一对一关系的关联对象；

而基于MyBatis自带的延迟加载机制则支持一对多关系的关联对象的延迟加载。因此，在使用延迟加载时需要根据具体的场景进行选择。

17、Mybatis都有哪些Executor执行器？它们之间的区别是什么？

Mybatis有三种基本的Executor执行器，SimpleExecutor、ReuseExecutor、BatchExecutor。

SimpleExecutor：每执行一次update或select，就开启一个Statement对象，用完立刻关闭Statement对象。

ReuseExecutor：执行update或select，以sql作为key查找Statement对象，存在就使用，不存在就创建，用完后，不关闭Statement对象，而是放置于Map<String, Statement>内，供下一次使用。简言之，就是重复使用Statement对象。

BatchExecutor：执行update（没有select，JDBC批处理不支持select），将所有sql都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个Statement对象，每个Statement对象都是addBatch()完毕后，等待逐一执行executeBatch()批处理。与JDBC批处理相同。

18、MyBatis缓存机制

MyBatis的缓存机制是指在执行SQL语句时，将查询结果缓存起来，下次执行相同的SQL语句时，直接从缓存中获取结果，从而提高查询效率。MyBatis的缓存机制分为一级缓存和二级缓存两种。查询顺序为：先查二级缓存，再查一级缓存，最后去数据库

1、一级缓存

一级缓存是指MyBatis的SqlSession级别的缓存，即在同一个SqlSession中执行相同的SQL语句，第二次查询时会直接从缓存中获取结果。

一级缓存的默认开启是通过SqlSessionFactory的默认值配置的，可以通过在mybatis-config.xml文件中的标签中配置开启或关闭，
一级缓存的缓存范围为SqlSession级别，即同一个SqlSession中的所有操作都共享同一个缓存。

一级缓存的缓存失效情况包括以下几种：

(1) SqlSession关闭；
(2) 执行了增删改操作；
(3) 执行了清空缓存操作；
(4) 在SqlSession中显式地调用了clearCache方法。

2、二级缓存

所有的数据都会先放在一级缓存中，只有当会话提交或关闭的时候，才会提交到二级缓存

二级缓存是指MyBatis的Mapper级别的缓存，即在多个SqlSession中执行相同的SQL语句，第二次查询时会直接从缓存中获取结果。

二级缓存的默认开启是通过Mapper的缓存配置实现的，可以通过在Mapper.xml文件中的标签中配置开启或关闭，

例如：

<setting name="cacheEnabled" value="true"/>

二级缓存的缓存范围为Mapper级别，即同一个Mapper的所有SqlSession共享同一个缓存。

二级缓存的缓存失效情况包括以下几种：

(1) 执行了增删改操作；
(2) 执行了清空缓存操作；
(3) 在Mapper.xml文件中的标签中配置了flushInterval属性，表示缓存刷新的时间间隔；
(4) 在Mapper.xml文件中的标签中配置了size属性，表示缓存的最大容量，当缓存的数量超过最大容量时，会触发缓存的清空操作；
(5) 在SqlSession中显式地调用了clearCache方法。