Executor 是 MyBatis 的核心接口之一，其中定义了数据库操作的基本方法。在实际应用中经常涉及的 SqISession 接口的功能，都是基于 Executor 接口实现的。

  1. public interface Executor {
  2.   ResultHandler NO_RESULT_HANDLER = null;
  4.   // 执行update、insert、delete三种类型的SQL语句
  5.   int update(MappedStatement ms, Object parameter) throws SQLException;
  7.   // 执行select类型的SQL语句，返回值分为结果对象列表或游标对象
  8.   <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;
  10.   <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;
  12.   <E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException;
  14.   // 批量执行SQL语句
  15.   List<BatchResult> flushStatements() throws SQLException;
  17.   // 提交事务
  18.   void commit(boolean required) throws SQLException;
  20.   // 回滚事务
  21.   void rollback(boolean required) throws SQLException;
  23.   // 创建缓存中用到的CacheKey对象
  24.   CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);
  26.   // 根据CacheKey对象查找缓存
  27.   boolean isCached(MappedStatement ms, CacheKey key);
  29.   // 清空一级缓存
  30.   void clearLocalCache();
  32.   // 延迟加载一级缓存中的数据
  33.   void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType);
  35.   // 获取事务
  36.   Transaction getTransaction();
  38.   // 关闭事务
  39.   void close(boolean forceRollback);
  41.   // 是否关闭
  42.   boolean isClosed();
  43. }

1 BaseExecutor

BaseExecutor 是一个实现了 Executor 接口的抽象类，它实现了 Executor 接口的大部分方法。BaseExecutor 中主要提供了缓存管理和事务管理的基本功能，继承 BaseExecutor 的子类只要实现四个基本方法来完成数据库的相关操作即可，这四个方法分别是：doUpdate()方法、doQuery()方法、doQueryCursor()方法、doFlushStatement()方法。

  1. public abstract class BaseExecutor implements Executor {
  3.   private static final Log log = LogFactory.getLog(BaseExecutor.class);
  5.   // 事务对象，用于实现事务的提交、回滚和关闭
  6.   protected Transaction transaction;
  7.   // 其中封装的Executor对象
  8.   protected Executor wrapper;
  10.   // 延迟加载队列
  11.   protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
  12.   // 一级缓存，用于缓存该Executor对象查询结果集映射得到的结果对象
  13.   protected PerpetualCache localCache;
  14.   // 一级缓存，用于缓存输出类型的参数
  15.   protected PerpetualCache localOutputParameterCache;
  16.   protected Configuration configuration;
  18.   // 记录嵌套查询的层数
  19.   protected int queryStack;
  20.   // 是否关闭
  21.   private boolean closed;
  22. }

1.1 一级缓存简介

常见的应用系统中，数据库是比较珍贵的资源，很容易成为整个系统的瓶颈。在设计和维护系统时，会进行多方面的权衡，并且利用多种优化手段，减少对数据库的直接访问。

使用缓存是一种比较有效的优化手段，使用缓存可以减少应用系统与数据库的网络交互、减少数据库访问次数、降低数据库的负担、降低重复创建和销毁对象等一系列开销，从而提高整个系统的性能。

MyBatis 提供的缓存功能，分别为一级缓存和二级缓存。BaseExecutor 主要实现了一级缓存的相关内容。一级缓存是会话级缓存，在 MyBatis 中每创建一个 SqlSession 对象，就表示开启一次数据库会话。在一次会话中，应用程序可能会在短时间内(一个事务内)，反复执行完全相同的查询语句，如果不对数据进行缓存，那么每一次查询都会执行一次数据库查询操作，而多次完全相同的、时间间隔较短的查询语句得到的结果集极有可能完全相同，这会造成数据库资源的浪费。

为了避免上述问题，MyBatis 会在 Executor 对象中建立一个简单的一级缓存，将每次查询的结果集缓存起来。在执行查询操作时，会先查询一级缓存，如果存在完全一样的查询情况，则直接从一级缓存中取出相应的结果对象并返回给用户，减少数据库访问次数，从而减小了数据库的压力。

一级缓存的生命周期与 SqlSession 相同，其实也就与 SqISession 中封装的 Executor 对象的生命周期相同。当调用 Executor 对象的 close()方法时（断开连接），该 Executor 对象对应的一级缓存就会被废弃掉。一级缓存中对象的存活时间受很多方面的影响，例如，在调用 Executor 的 update()方法时，也会先请空一级缓存。一级缓存默认是开启的，一般情况下，不需要用户进行特殊配置。

1.2 一级缓存的管理

BaseExecutor 的 query()方法会首先创建 CacheKey 对象，并根据该 CacheKey 对象查找一级缓存，如果缓存命中则返回缓存中记录的结果对象，如果缓存未命中则查询数据库得到结果集，之后将结果集映射成结果对象并保存到一级缓存中，同时返回结果对象。

  1. public abstract class BaseExecutor implements Executor {
  2.   @Override
  3.   public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
  4.     // 获取BoundSql对象
  5.     BoundSql boundSql = ms.getBoundSql(parameter);
  6.     // 创建CacheKey对象，该对象由多个参数组装而成
  7.     CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
  8.     // query方法的重载，进行后续处理
  9.     return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
  10.  }
  12.   @Override
  13.   public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
  14.     if (closed) {
  15.       throw new ExecutorException("Executor was closed.");
  16.     }
  17.     // 可以看到CacheKey对象由MappedStatement的id、RowBounds的offset和limit
  18.     // sql语句(包含占位符"?")、用户传递的实参组成
  19.     CacheKey cacheKey = new CacheKey();
  20.     cacheKey.update(ms.getId());
  21.     cacheKey.update(rowBounds.getOffset());
  22.     cacheKey.update(rowBounds.getLimit());
  23.     cacheKey.update(boundSql.getSql());
  24.     List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
  25.     TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
  26.     // 获取用户传入的实参，并添加到CacheKey对象中
  27.     for (ParameterMapping parameterMapping : parameterMappings) {
  28.       // 过滤掉输出类型的参数
  29.       if (parameterMapping.getMode() != ParameterMode.OUT) {
  30.         Object value;
  31.         String propertyName = parameterMapping.getProperty();
  32.         if (boundSql.hasAdditionalParameter(propertyName)) {
  33.           value = boundSql.getAdditionalParameter(propertyName);
  34.         } else if (parameterObject == null) {
  35.           value = null;
  36.         } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
  37.           value = parameterObject;
  38.         } else {
  39.           MetaObject metaObject = configuration.newMetaObject(parameterObject);
  40.           value = metaObject.getValue(propertyName);
  41.         }
  42.         // 将实参添加到CacheKey对象中
  43.         cacheKey.update(value);
  44.       }
  45.     }
  46.     // 如果configuration的environment不为空，则将该environment的id
  47.     // 添加到CacheKey对象中
  48.     if (configuration.getEnvironment() != null) {
  49.       cacheKey.update(configuration.getEnvironment().getId());
  50.     }
  51.     return cacheKey;
  52.   }
  54.   @Override
  55.   public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
  56.     // 检查当前Executor是否已关闭
  57.     ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
  58.     if (closed) {
  59.       throw new ExecutorException("Executor was closed.");
  60.     }
  61.     if (queryStack == 0 && ms.isFlushCacheRequired()) {
  62.       // 非嵌套查询，且<select>节点配置的flushCache属性为true时，才会清空一级缓存
  63.       clearLocalCache();
  64.     }
  65.     List<E> list;
  66.     try {
  67.       // 增加查询层数
  68.       queryStack++;
  69.       // 根据传入的CacheKey对象 查询一级缓存
  70.       list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
  71.       if (list != null) {
  72.         // 针对存储过程调用的处理，在一级缓存命中时，获取缓存中保存的输出类型参数
  73.         // 并设置到用户传入的实参parameter对象中
  74.         handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
  75.       } else {
  76.         // 缓存未命中，则从数据库查询结果集，其中会调用doQuery()方法完成数据库查询操作，
  77.         // 该方法为抽象方法，由BaseExecutor的子类实现
  78.         list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
  79.       }
  80.     } finally {
  81.       // 当前查询完成，查询层数减少
  82.       queryStack--;
  83.     }
  84.     if (queryStack == 0) {
  85.       // 延迟加载的相关内容
  86.       for (DeferredLoad deferredLoad : deferredLoads) {
  87.         deferredLoad.load();
  88.       }
  89.       deferredLoads.clear();
  90.       if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
  91.         // issue #482
  92.         clearLocalCache();
  93.       }
  94.     }
  95.     return list;
  96.   }
  97. }

从上面的代码中可以看到，BaseExecutor 的 query()方法会根据 flushCache 属性和 localCacheScope 配置 决定是否清空一级缓存。

另外，BaseExecutor 的 update()方法在调用 doUpdate()方法之前，也会清除一级缓存。update()方法负责执行 insert、update、delete 三类 SQL 语句，它是调用 doUpdate()方法实现的。

  1.   @Override
  2.   public int update(MappedStatement ms, Object parameter) throws SQLException {
  3.     // 判断当前的Executor是否已经关闭
  4.     ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
  5.     if (closed) {
  6.       throw new ExecutorException("Executor was closed.");
  7.     }
  8.     // 清除一级缓存，该方法会调用localCache和localOutputParameterCache
  9.     // 的clear()方法清除缓存
  10.     clearLocalCache();
  11.     // 抽象方法，交由子类实现
  12.     return doUpdate(ms, parameter);
  13.   }
  15.   @Override
  16.   public void clearLocalCache() {
  17.     if (!closed) {
  18.       localCache.clear();
  19.       localOutputParameterCache.clear();
  20.     }
  21.   }

1.3 事务相关操作

在 BatchExecutor 实现中，可以缓存多条 SQL 语句，等待合适时机将缓存的多条 SQL 语句一并发送到数据库执行。Executor 的 flushStatements()方法主要是针对批处理多条 SQL 语句的，它会调用 doFlushStatements()这个基本方法处理 Executor 中缓存的多条 SQL 语句。在 BaseExecutor 的 commit()及 rollback()等方法中都会首先调用 flushStatements()方法，然后再执行相关事务操作。

  1.   @Override
  2.   public void commit(boolean required) throws SQLException {
  3.     // 检查当前连接是否已关闭
  4.     if (closed) {
  5.       throw new ExecutorException("Cannot commit, transaction is already closed");
  6.     }
  7.     // 清除一级缓存
  8.     clearLocalCache();
  9.     // 不执行Executor中缓存的SQL语句
  10.     flushStatements();
  11.     // 根据参数required决定是否提交事务
  12.     if (required) {
  13.       transaction.commit();
  14.     }
  15.   }
  17.   @Override
  18.   public List<BatchResult> flushStatements() throws SQLException {
  19.     return flushStatements(false);
  20.   }
  22.   public List<BatchResult> flushStatements(boolean isRollBack) throws SQLException {
  23.     if (closed) {
  24.       throw new ExecutorException("Executor was closed.");
  25.     }
  26.     // 这是一个交由子类实现的抽象方法，参数isRollBack表示
  27.     // 是否执行Executor中缓存的SQL语句，false表示执行，true表示不执行
  28.     return doFlushStatements(isRollBack);
  29.   }
  31.   @Override
  32.   public void rollback(boolean required) throws SQLException {
  33.     if (!closed) {
  34.       try {
  35.         // 清除一级缓存
  36.         clearLocalCache();
  37.         // 批量执行缓存的sql语句
  38.         flushStatements(true);
  39.       } finally {
  40.         // 根据required决定是否回滚事务
  41.         if (required) {
  42.           transaction.rollback();
  43.         }
  44.       }
  45.     }
  46.   }
  48.   @Override
  49.   public void close(boolean forceRollback) {
  50.     try {
  51.       try {
  52.         // 根据forceRollback参数决定 是否强制回滚该事务
  53.         rollback(forceRollback);
  54.       } finally {
  55.         if (transaction != null) {
  56.           transaction.close();
  57.         }
  58.       }
  59.     } catch (SQLException e) {
  60.       // Ignore.  There's nothing that can be done at this point.
  61.       log.warn("Unexpected exception on closing transaction.  Cause: " + e);
  62.     } finally {
  63.       transaction = null;
  64.       deferredLoads = null;
  65.       localCache = null;
  66.       localOutputParameterCache = null;
  67.       closed = true;
  68.     }
  69.   }

2 SimpleExecutor

SimpleExecutor 继承了 BaseExecutor 抽象类，它是最简单的 Executor 接口实现。Executor 组件使用了模板方法模式，一级缓存等固定不变的操作都封装到了 BaseExecutor 中，在 SimpleExecutor 中就不必再关心一级缓存等操作，只需要专注实现 4 个基本方法的实现即可。

  1. public class SimpleExecutor extends BaseExecutor {
  3.   public SimpleExecutor(Configuration configuration, Transaction transaction) {
  4.     super(configuration, transaction);
  5.   }
  7.   @Override
  8.   public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
  9.     Statement stmt = null;
  10.     try {
  11.       // 获取配置对象
  12.       Configuration configuration = ms.getConfiguration();
  13.       // 创建StatementHandler对象
  14.       StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
  15.       // 完成Statement的创建和初始化，该方法首先会调用StatementHandler的prepare()方法
  16.       // 创建Statement对象，然后调用StatementHandler的parameterize()方法处理占位符
  17.       stmt = prepareStatement(handler, ms.getStatementLog());
  18.       // 调用StatementHandler的query()方法，执行sql语句，并通过ResultSetHandler
  19.       // 完成结果集的映射
  20.       return handler.<E>query(stmt, resultHandler);
  21.     } finally {
  22.       // 关闭Statement对象
  23.       closeStatement(stmt);
  24.     }
  25.   }
  27.   private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  28.     Statement stmt;
  29.     Connection connection = getConnection(statementLog);
  30.     // 创建Statement对象
  31.     stmt = handler.prepare(connection, transaction.getTimeout());
  32.     // 处理占位符
  33.     handler.parameterize(stmt);
  34.     return stmt;
  35.   }
  37.   /**
  38.    * 与前面doQuery()方法的实现非常类似
  39.    */
  40.   @Override
  41.   public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
  42.     Statement stmt = null;
  43.     try {
  44.       Configuration configuration = ms.getConfiguration();
  45.       StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
  46.       stmt = prepareStatement(handler, ms.getStatementLog());
  47.       return handler.update(stmt);
  48.     } finally {
  49.       closeStatement(stmt);
  50.     }
  51.   }
  53.   @Override
  54.   protected <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql) throws SQLException {
  55.     Configuration configuration = ms.getConfiguration();
  56.     StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, null, boundSql);
  57.     Statement stmt = prepareStatement(handler, ms.getStatementLog());
  58.     return handler.<E>queryCursor(stmt);
  59.   }
  61.   @Override
  62.   public List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException {
  63.     // SimpleExecutor不提供sql语句批处理，所以直接返回空集合
  64.     return Collections.emptyList();
  65.   }
  67. }

3 ReuseExecutor

在传统的 JDBC 编程中，复用 Statement 对象是常用的一种优化手段，该优化手段可以减少 SQL 预编译的开销以及创建和销毁 Statement 对象的开销，从而提高性能（Reuse，复用）。

ReuseExecutor 提供了 Statement 复用的功能，ReuseExecutor 中通过 statementMap 字段缓存使用过的 Statement 对象，key 是 SQL 语句，value 是 SQL 对应的 Statement 对象。

ReuseExecutor.doQuery()、doQueryCursor()、doUpdate()方法的实现与 SimpleExecutor 中对应方法的实现一样，区别在于其中调用的 prepareStatement()方法，SimpleExecutor 每次都会通过 JDBC 的 Connection 对象创建新的 Statement 对象，而 ReuseExecutor 则会先尝试重用 StaternentMap 中缓存的 Statement 对象。

  1.   // 本map用于缓存使用过的Statement，以提升本框架的性能
  2.   // key SQL语句，value 该SQL语句对应的Statement
  3.   private final Map<String, Statement> statementMap = new HashMap<String, Statement>();
  5.   private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  6.     Statement stmt;
  7.     BoundSql boundSql = handler.getBoundSql();
  8.     // 获取要执行的sql语句
  9.     String sql = boundSql.getSql();
  10.     // 如果之前执行过该sql，则从缓存中取出对应的Statement对象
  11.     // 不再创建新的Statement，减少系统开销
  12.     if (hasStatementFor(sql)) {
  13.       stmt = getStatement(sql);
  14.       // 修改超时时间
  15.       applyTransactionTimeout(stmt);
  16.     } else {
  17.       // 获取数据库连接
  18.       Connection connection = getConnection(statementLog);
  19.       // 从连接中获取Statement对象
  20.       stmt = handler.prepare(connection, transaction.getTimeout());
  21.       // 将sql语句 和 其对应的Statement对象缓存起来
  22.       putStatement(sql, stmt);
  23.     }
  24.     // 处理占位符
  25.     handler.parameterize(stmt);
  26.     return stmt;
  27.   }
  29.   /**
  30.    * 当事务提交或回滚、连接关闭时，都需要关闭这些缓存的Statement对象。前面分析的BaseExecutor的
  31.    * commit()、rollback()和close()方法中都会调用doFlushStatements()方法，
  32.    * 所以在该方法中关闭Statement对象的逻辑非常合适
  33.    */
  34.   @Override
  35.   public List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException {
  36.     // 遍历Statement对象集合，并依次关闭
  37.     for (Statement stmt : statementMap.values()) {
  38.       closeStatement(stmt);
  39.     }
  40.     // 清除对Statement对象的缓存
  41.     statementMap.clear();
  42.     // 返回一个空集合
  43.     return Collections.emptyList();
  44.   }

拓展内容：SQL 预编译

1、数据库预编译起源

（1）数据库 SQL 语句编译特性

数据库接收到 sql 语句之后，需要词法和语义解析，以优化 sql 语句，制定执行计划。这需要花费一些时间。但是很多情况，我们的同一条 sql 语句可能会反复执行，或者每次执行的时候只有个别的值不同（比如：query 的 where 子句值不同，update 的 set 子句值不同，insert 的 values 值不同）。

（2）减少编译的方法

如果每次都需要经过上面的词法语义解析、语句优化、制定执行计划等，则效率就明显不行了。为了解决上面的问题，于是就有了预编译，预编译语句就是将这类语句中的值用占位符替代，可以视为将 sql 语句模板化或者说参数化。一次编译、多次运行，省去了解析优化等过程。

（3）缓存预编译

预编译语句被 DB 的编译器编译后的执行代码被缓存下来，那么下次调用时只要是相同的预编译语句就不需要重复编译，只要将参数直接传入编译过的语句执行代码中(相当于一个函数)就会得到执行。并不是所以预编译语句都一定会被缓存，数据库本身会用一种策略（内部机制）。

（4） 预编译的实现方法

预编译是通过 PreparedStatement 和占位符来实现的。

2.预编译作用

（1）减少编译次数 提升性能

预编译之后的 sql 多数情况下可以直接执行，DBMS（数据库管理系统）不需要再次编译。越复杂的 sql，往往编译的复杂度就越大。

（2）防止 SQL 注入

使用预编译，后面注入的参数将不会再次触发 SQL 编译。也就是说，对于后面注入的参数，系统将不会认为它会是一个 SQL 命令，而默认其是一个参数，参数中的 or 或 and 等（SQL 注入常用技俩）就不是 SQL 语法保留字了。

3.mybatis 是如何实现预编译的

mybatis 默认情况下，将对所有的 sql 进行预编译。mybatis 底层使用 PreparedStatement，过程是，先将带有占位符（即”?”）的 sql 模板发送至数据库服务器，由服务器对此无参数的 sql 进行编译后，将编译结果缓存，然后直接执行带有真实参数的 sql。核心是通过 “#{ }” 实现的。在预编译之前，#{ } 被解析为一个预编译语句（PreparedStatement）的占位符 ?。

  1. // sqlMap 中如下的 sql 语句
  2. select * from user where name = #{name};
  3. // 解析成为预编译语句
  4. select * from user where name = ?;

4 BatchExecutor

应用系统在执行一条 SQL 语句时，会将 SQL 语句以及相关参数通过网络发送到数据库系统。对于频繁操作数据库的应用系统来说，如果执行一条 SQL 语句就向数据库发送一次请求，很多时间会浪费在网络通信上。使用批量处理的优化方式可以在客户端缓存多条 SQL 语句，并在合适的时机将多条 SQL 语句打包发送给数据库执行，从而减少网络方面的开销，提升系统的性能。

需要注意的是，在批量执行多条 SQL 语句时，每次向数据库发送的 SQL 语句条数 是有上限的，若超出上限，数据库会拒绝执行这些 SQL 语句井抛出异常，所以批量发送 SQL 语句的时机很重要。

mybatis 的 BatchExecutor 实现了批处理多条 SQL 语句的功能。

  1. public class BatchExecutor extends BaseExecutor {
  3.   public static final int BATCH_UPDATE_RETURN_VALUE = Integer.MIN_VALUE + 1002;
  4.   // 缓存多个Statement对象，其中每个Statement对象中都可以缓存多条
  5.   // 结构相同 但参数不同的sql语句
  6.   private final List<Statement> statementList = new ArrayList<Statement>();
  7.   // 记录批处理的结果，BatchResult中通过updateCounts字段
  8.   // 记录每个Statement对象 执行批处理的结果
  9.   private final List<BatchResult> batchResultList = new ArrayList<BatchResult>();
  10.   // 记录当前执行的sql语句
  11.   private String currentSql;
  12.   // 记录当前执行的MappedStatement对象
  13.   private MappedStatement currentStatement;
  15.   /**
  16.    * JDBC中的批处理只支持insert、update、delete等类型的SQL语句，不支持select类型的
  17.    * SQL语句，所以doUpdate()方法是BatchExecutor中最重要的一个方法。
  18.    * 本方法在添加一条SQL语句时，首先会将currentSql字段记录的SQL语句以及currentStatement字段
  19.    * 记录的MappedStatement对象与当前添加的SQL以及MappedStatement对象进行比较，
  20.    * 如果相同则添加到同一个Statement对象中等待执行，如果不同则创建新的Statement对象
  21.    * 井将其缓存到statementList集合中等待执行
  22.    */
  23.   @Override
  24.   public int doUpdate(MappedStatement ms, Object parameterObject) throws SQLException {
  25.     // 获取configuration配置对象
  26.     final Configuration configuration = ms.getConfiguration();
  27.     // 实例化一个StatementHandler，并返回
  28.     final StatementHandler handler = configuration.newStatementHandler(this, ms, parameterObject, RowBounds.DEFAULT, null, null);
  29.     // 获取需要执行的sql语句
  30.     final BoundSql boundSql = handler.getBoundSql();
  31.     final String sql = boundSql.getSql();
  32.     final Statement stmt;
  33.     // 判断要执行的sql语句结构 及 MappedStatement对象 是否与上次的相同
  34.     if (sql.equals(currentSql) && ms.equals(currentStatement)) {
  35.       // 相同则添加到同一个Statement对象中等待执行
  36.       // 首先获取statementList集合中最后一个Statement对象
  37.       int last = statementList.size() - 1;
  38.       stmt = statementList.get(last);
  39.       // 重新设置事务超时时间
  40.       applyTransactionTimeout(stmt);
  41.       // 绑定实参，处理占位符？
  42.       handler.parameterize(stmt);
  43.       // 查找对应的BatchResult对象，并记录用户传入的实参
  44.       BatchResult batchResult = batchResultList.get(last);
  45.       batchResult.addParameterObject(parameterObject);
  46.     } else {
  47.       // 不同则创建新的Statement对象井将其缓存到statementList集合中等待执行
  48.       Connection connection = getConnection(ms.getStatementLog());
  49.       // 创建新的Statement对象
  50.       stmt = handler.prepare(connection, transaction.getTimeout());
  51.       // 绑定实参，处理占位符？
  52.       handler.parameterize(stmt);
  53.       // 记录本次的sql语句 及 Statement对象
  54.       currentSql = sql;
  55.       currentStatement = ms;
  56.       // 将新创建的Statement对象添加到statementList集合
  57.       statementList.add(stmt);
  58.       // 添加新的BatchResult对象
  59.       batchResultList.add(new BatchResult(ms, sql, parameterObject));
  60.     }
  61.     // 底层通过调用java.sql.Statement的addBatch()方法添加sql语句
  62.     handler.batch(stmt);
  63.     return BATCH_UPDATE_RETURN_VALUE;
  64.   }
  66.   /**
  67.    * 上面的doUpdate()方法负责添加待执行的sql语句，
  68.    * 而doFlushStatements()方法则将上面添加的sql语句进行批量处理
  69.    */
  70.   @Override
  71.   public List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException {
  72.     try {
  73.       // 用于存储批处理结果的集合
  74.       List<BatchResult> results = new ArrayList<BatchResult>();
  75.       // 如果要回滚 则返回一个空集合
  76.       if (isRollback) {
  77.         return Collections.emptyList();
  78.       }
  79.       // 批处理statementList集合中的所以Statement对象
  80.       for (int i = 0, n = statementList.size(); i < n; i++) {
  81.         // 获取Statement对象 和其对应的 BatchResult对象
  82.         Statement stmt = statementList.get(i);
  83.         applyTransactionTimeout(stmt);
  84.         BatchResult batchResult = batchResultList.get(i);
  85.         try {
  86.           // 调用Statement对象的executeBatch()方法，批量执行其中记录的sql语句
  87.           // 将执行返回的int[]数组set进batchResult的updateCounts字段，
  88.           // 其中的每一个int值都代表了对应的sql语句 影响的记录条数
  89.           batchResult.setUpdateCounts(stmt.executeBatch());
  90.           MappedStatement ms = batchResult.getMappedStatement();
  91.           List<Object> parameterObjects = batchResult.getParameterObjects();
  92.           // 获取配置的KeyGenerator对象
  93.           KeyGenerator keyGenerator = ms.getKeyGenerator();
  94.           if (Jdbc3KeyGenerator.class.equals(keyGenerator.getClass())) {
  95.             Jdbc3KeyGenerator jdbc3KeyGenerator = (Jdbc3KeyGenerator) keyGenerator;
  96.             // 获取数据库生成的主键 并设置到parameterObjects中
  97.             jdbc3KeyGenerator.processBatch(ms, stmt, parameterObjects);
  98.           } else if (!NoKeyGenerator.class.equals(keyGenerator.getClass())) {
  99.             // 对于其它类型的KeyGenerator，则调用其processAfter进行处理
  100.             for (Object parameter : parameterObjects) {
  101.               keyGenerator.processAfter(this, ms, stmt, parameter);
  102.             }
  103.           }
  104.           closeStatement(stmt);
  105.         } catch (BatchUpdateException e) {
  106.           StringBuilder message = new StringBuilder();
  107.           message.append(batchResult.getMappedStatement().getId())
  108.                   .append(" (batch index #")
  109.                   .append(i + 1)
  110.                   .append(")")
  111.                   .append(" failed.");
  112.           if (i > 0) {
  113.             message.append(" ")
  114.                     .append(i)
  115.                     .append(" prior sub executor(s) completed successfully, but will be rolled back.");
  116.           }
  117.           throw new BatchExecutorException(message.toString(), e, results, batchResult);
  118.         }
  119.         // 添加处理完的BatchResult对象到要返回的List<BatchResult>集合中
  120.         results.add(batchResult);
  121.       }
  122.       return results;
  123.     } finally {
  124.       // 关闭所有的Statement对象
  125.       for (Statement stmt : statementList) {
  126.         closeStatement(stmt);
  127.       }
  128.       // 清空currentSql、statementList、batchResultList对象
  129.       currentSql = null;
  130.       statementList.clear();
  131.       batchResultList.clear();
  132.     }
  133.   }
  134. }

通过了解 JDBC 的批处理功能 我们可以知道，Statement 中可以添加不同语句结构的 SQL，但是每添加一个新结构的 SQL 语句都会触发一次编译操作。而 PreparedStatement 中只能添加同一语句结构的 SQL 语句，只会触发一次编译操作，但是可以通过绑定多组不同的实参实现批处理。通过上面对 doUpdate()方法的分析可知，BatchExecutor 会将连续添加的、相同语句结构的 SQL 语句添加到同一个 Statement/PreparedStatement 对象中，这样可以有效地减少编译操作的次数。

BatchExecutor 中 doQuery()和 doQueryCursor()方法的实现与前面介绍的 SimpleExecutor 类似，主要区别就是 BatchExecutor 中的这两个方法在最开始都会先调用 flushStatements()方法，执行缓存的 SQL 语句，以保证 从数据库中查询到的数据是最新的。

CachingExecutor 中为 Executor 对象增加了二级缓存相关功能，而 mybatis 的二级缓存在实际使用中往往利大于弊，被 redis 等产品所替代，所以这里不做分析。