转载自  mybatis源码阅读(五) ---执行器Executor

1. Executor接口设计与类结构图

public interface Executor {ResultHandler NO_RESULT_HANDLER = null;// 执行update，delete，insert三种类型的sql语句int update(MappedStatement ms, Object parameter) throws SQLException;// 执行select类型的SQL语句，返回值分为结果对象列表和游标对象<E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;<E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;<E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException;// 批量执行SQL语句List<BatchResult> flushStatements() throws SQLException;// 提交事务void commit(boolean required) throws SQLException;// 事务回滚void rollback(boolean required) throws SQLException;// 创建缓存中用到的CacheKey对象CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);boolean isCached(MappedStatement ms, CacheKey key);// 清空一级缓存void clearLocalCache();// 延迟加载一级缓存中的数据void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType);// 获取事务对象Transaction getTransaction();// 关闭Executor对象void close(boolean forceRollback);// 检测Executor对象是否关闭boolean isClosed();void setExecutorWrapper(Executor executor);}

简单执行器SimpleExecutor：每执行一次update或select，就开启一个Statement对象，用完立刻关闭Statement对象。（可以是Statement或PrepareStatement对象）

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

批量执行器BatchExecutor：执行update（没有select，JDBC批处理不支持select），将所有sql都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个Statement对象，每个Statement对象都是addBatch()完毕后，等待逐一执行executeBatch()批处理的；BatchExecutor相当于维护了多个桶，每个桶里都装了很多属于自己的SQL，就像苹果蓝里装了很多苹果，番茄蓝里装了很多番茄，最后，再统一倒进仓库。（可以是Statement或PrepareStatement对象）

缓存执行器CachingExecutor：装饰设计模式典范，先从缓存中获取查询结果，存在就返回，不存在，再委托给Executor delegate去数据库取，delegate可以是上面任一的SimpleExecutor、ReuseExecutor、BatchExecutor。

无用执行器ClosedExecutor：毫无用处，读者可自行查看其源码，仅作为一种标识，和Serializable标记接口作用相当。

作用范围：以上这五个执行器的作用范围，都严格限制在SqlSession生命周期范围内。

2. 基类BaseExecutor源码解析

它是一个实现了Executor接口的抽象类，实现了接口中的大部分方法，其中就是使用了模板模式，它主要提供了缓存和事物管理的基本功能，不同的实现类，只要实现4个基本方法来完成数据库的相关操作，这4个抽象方法：doUpdate()、doQuery()、doFlushStatement()、doQueryCursor。

源码片段

protected Transaction transaction;// 实现事务的回滚和提交，关闭操作
protected Executor wrapper; // 其中封装的Executor对象// 延迟加载队列
protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
// 下面两个属性是一级缓存用到的对象
protected PerpetualCache localCache;
protected PerpetualCache localOutputParameterCache;protected Configuration configuration;// 嵌套查询层级
protected int queryStack;
private boolean closed;
protected abstract int doUpdate(MappedStatement ms, Object parameter)throws SQLException;protected abstract List<BatchResult> doFlushStatements(boolean isRollback)throws SQLException;protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)throws SQLException;protected abstract <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql)throws SQLException;

2.1 SimpleExecutor

@Override
public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {Statement stmt = null;try {Configuration configuration = ms.getConfiguration();StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);stmt = prepareStatement(handler, ms.getStatementLog());return handler.update(stmt);} finally {closeStatement(stmt);}
}@Override
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {Statement stmt = null;try {Configuration configuration = ms.getConfiguration();StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);stmt = prepareStatement(handler, ms.getStatementLog());return handler.<E>query(stmt, resultHandler);} finally {closeStatement(stmt);//关闭statement对象}
}

源码很简单，从configuration对象中去材料，交给handler去处理，处理完后，statement对象马上关闭。

2.2 ReuseExecutor

执行器提供了Statement的重用功能，代码片段如下：

// 缓存使用过的Statement对象，key是SQL语句，value是SQL对应的Statement对象
private final Map<String, Statement> statementMap = new HashMap<String, Statement>();
/*** 准备获取Statement对象* @param handler* @param statementLog* @return* @throws SQLException*/
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {Statement stmt;BoundSql boundSql = handler.getBoundSql();String sql = boundSql.getSql();if (hasStatementFor(sql)) {// 检测是否缓存了相同模式的SQL语句所对应的Statement对象stmt = getStatement(sql);// 从缓存中获取statement对象applyTransactionTimeout(stmt);// 修改超时时间} else {Connection connection = getConnection(statementLog);stmt = handler.prepare(connection, transaction.getTimeout());putStatement(sql, stmt);}handler.parameterize(stmt);return stmt;
}

那statement对象是什么时候关闭的呢？当事物提交回滚或者关闭时都需要关闭这些缓存的Statement对象，在BaseExecutor.commit(),rollback(),close()方法中都会掉用doFlushStatement()方法，所以在改方法中实现关闭Statement对象是非常合适。具体如下：

@Override
public List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException {// 遍历map集合并关闭其中的Statement对象for (Statement stmt : statementMap.values()) {closeStatement(stmt);}// 清空缓存statementMap.clear();// 返回空集合return Collections.emptyList();
}

2.3 BatchExecutor

BatchExecutor实现了批处理多条SQL语句的功能，需要注意的是在批处理执行SQL语句时，每次向数据库发送的SQL语句条数是有上限，超过上限会抛出异常，所以批量发送SQL语句的时机是很重要的。

其中的核心字段含义如下：

//缓存多个Statement对象，每个Statement对象中都缓存了多条SQL语句private final List<Statement> statementList = new ArrayList<Statement>();//记录批处理的结果 BatchResult中通过updateCounts字段（int[]）记录每个Statement执行批处理的结果private final List<BatchResult> batchResultList = new ArrayList<BatchResult>();// 记录当前执行的SQL语句private String currentSql;// 记录当前的MappedStatement对象private MappedStatement currentStatement;

方法实现如下：

@Override
public int doUpdate(MappedStatement ms, Object parameterObject) throws SQLException {final Configuration configuration = ms.getConfiguration();final StatementHandler handler = configuration.newStatementHandler(this, ms, parameterObject, RowBounds.DEFAULT, null, null);final BoundSql boundSql = handler.getBoundSql();// 本次执行的sqlfinal String sql = boundSql.getSql();final Statement stmt;// 如果当前执行的SQL与上一次执行的SQL相同且对应的MappedStatement对象相同if (sql.equals(currentSql) && ms.equals(currentStatement)) {int last = statementList.size() - 1;// 已经存在Statement，取出最后一个Statement，有序stmt = statementList.get(last);applyTransactionTimeout(stmt);handler.parameterize(stmt);//fix Issues 322BatchResult batchResult = batchResultList.get(last);batchResult.addParameterObject(parameterObject);} else {// 尚不存在，新建StatementConnection connection = getConnection(ms.getStatementLog());stmt = handler.prepare(connection, transaction.getTimeout());handler.parameterize(stmt);    //fix Issues 322currentSql = sql;currentStatement = ms;// 放到statementList缓存statementList.add(stmt);batchResultList.add(new BatchResult(ms, sql, parameterObject));}
// handler.parameterize(stmt);// 将sql以addBatch()的方式，添加到Statement中（该步骤由StatementHandler内部完成）handler.batch(stmt);return BATCH_UPDATE_RETURN_VALUE;
}

需要注意的是sql.equals(currentSql)和statementList.get(last)，充分说明了其有序逻辑：AABB，将生成2个Statement对象；AABBAA，将生成3个Statement对象，而不是2个。因为，只要sql有变化，将导致生成新的Statement对象。

缓存了这么多Statement批处理对象，何时执行它们？在doFlushStatements()方法中完成执行stmt.executeBatch()，随即关闭这些Statement对象。

2.4 CachingExecutor

CachingExecutor是一个Executor接口的装饰器，它为Executor对象增加了二级缓存的相关功能。

//委托的执行器对象，可以是SimpleExecutor、ReuseExecutor、BatchExecutor任一一个
private final Executor delegate;
//管理使用的二级缓存对像
private final TransactionalCacheManager tcm = new TransactionalCacheManager();

query方法执行的查询操作步骤：

(1)获取BoundSql对象，创建查询语句对应的CacheKey对象，

(2)检测是否开启了二级缓存，如果没有，则指教调用delegate对象的query()方法查询，如果开启了，则继续后面的步骤

(3)检测查询是否包含输出类型的参数，如果是，则报错

(4)调用TransactionalCacheManager.getObject()方法查询二级缓存，如果二级缓存中查找到相应的结果，则直接返回结果。

(5)如果二级缓存没有相应的结果对象，在调用delegate对象的query()方法查询。最后将得到的结果放入

TransactionalCache.entriesToAddOnCommit集合中保存。

@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {// (1)BoundSql boundSql = ms.getBoundSql(parameterObject);CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)throws SQLException {Cache cache = ms.getCache();if (cache != null) {// (2)flushCacheIfRequired(ms);if (ms.isUseCache() && resultHandler == null) {// (3)ensureNoOutParams(ms, boundSql);// (4)@SuppressWarnings("unchecked")List<E> list = (List<E>) tcm.getObject(cache, key);if (list == null) {// (5)list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);tcm.putObject(cache, key, list); // issue #578 and #116}return list;}}// 没有启动二级缓存，只调用底层Executor查询return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}