public interface Executor {/*** ResultHandler 空对象*/ResultHandler NO_RESULT_HANDLER = null;/*** 更新或者插入或者删除* 由传入的 MappedStatement 的 SQL 所决定*/int update(MappedStatement ms, Object parameter) throws SQLException;/*** 查询，带 ResultHandler + CacheKey + BoundSql*/<E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler,CacheKey cacheKey, BoundSql boundSql) throws SQLException;/*** 查询，带 ResultHandler*/<E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler)throws SQLException;/*** 查询，返回 Cursor 游标*/<E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException;/*** 刷入批处理语句*/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();/*** 关闭事务*/void close(boolean forceRollback);/*** 判断事务是否关闭*/boolean isClosed();/*** 设置包装的 Executor 对象*/void setExecutorWrapper(Executor executor);
}

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;

public abstract class BaseExecutor implements Executor {private static final Log log = LogFactory.getLog(BaseExecutor.class);/*** 事务对象*/protected Transaction transaction;/*** 包装的 Executor 对象*/protected Executor wrapper;/*** DeferredLoad（延迟加载）队列*/protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;/*** 本地缓存，即一级缓存，内部就是一个 HashMap 对象*/protected PerpetualCache localCache;/*** 本地输出类型参数的缓存，和存储过程有关*/protected PerpetualCache localOutputParameterCache;/*** 全局配置*/protected Configuration configuration;/*** 记录当前会话正在查询的数量*/protected int queryStack;/*** 是否关闭*/private boolean closed;protected BaseExecutor(Configuration configuration, Transaction transaction) {this.transaction = transaction;this.deferredLoads = new ConcurrentLinkedQueue<>();this.localCache = new PerpetualCache("LocalCache");this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");this.closed = false;this.configuration = configuration;this.wrapper = this;}
}

@Override
public void clearLocalCache() {if (!closed) {localCache.clear();localOutputParameterCache.clear();}
}

@Override
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {if (closed) {throw new ExecutorException("Executor was closed.");}// <1> 创建 CacheKey 对象CacheKey cacheKey = new CacheKey();// <2> 设置 id、offset、limit、sql 到 CacheKey 对象中cacheKey.update(ms.getId());cacheKey.update(rowBounds.getOffset());cacheKey.update(rowBounds.getLimit());cacheKey.update(boundSql.getSql());// <3> 设置 ParameterMapping 数组的元素对应的每个 value 到 CacheKey 对象中List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();// mimic DefaultParameterHandler logicfor (ParameterMapping parameterMapping : parameterMappings) {if (parameterMapping.getMode() != ParameterMode.OUT) { // 该参数需要作为入参Object value;String propertyName = parameterMapping.getProperty();/** 获取该属性值*/if (boundSql.hasAdditionalParameter(propertyName)) {// 从附加参数中获取value = boundSql.getAdditionalParameter(propertyName);} else if (parameterObject == null) {// 入参对象为空则直接返回 nullvalue = null;} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {// 入参有对应的类型处理器则直接返回该参数value = parameterObject;} else {// 从入参对象中获取该属性的值MetaObject metaObject = configuration.newMetaObject(parameterObject);value = metaObject.getValue(propertyName);}cacheKey.update(value);}}// <4> 设置 Environment.id 到 CacheKey 对象中if (configuration.getEnvironment() != null) {// issue #176cacheKey.update(configuration.getEnvironment().getId());}return cacheKey;
}

@Override
public boolean equals(Object object) {if (this == object) {return true;} if (!(object instanceof CacheKey)) {
return false;
} final
CacheKey cacheKey = (CacheKey) object;if (hashcode != cacheKey.hashcode) {
return false;} if (checksum != cacheKey.checksum) {
return false;} if (count != cacheKey.count) {return false;
} for (int i = 0; i < updateList.size(); i++) {
Object thisObject = updateList.get(i);
Object thatObject = cacheKey.updateList.get(i);
if (!ArrayUtil.equals(thisObject, thatObject)) {
return false;
}
} return true;
}

@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler)throws SQLException {// <1> 获得 BoundSql 对象BoundSql boundSql = ms.getBoundSql(parameter);// <2> 创建 CacheKey 对象CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);// <3> 查询return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler,CacheKey key, BoundSql boundSql) throws SQLException {ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());// <1> 已经关闭，则抛出 ExecutorException 异常if (closed) {throw new ExecutorException("Executor was closed.");}// <2> 清空本地缓存，如果 queryStack 为零，并且要求清空本地缓存（配置了 flushCache = true）if (queryStack == 0 && ms.isFlushCacheRequired()) {clearLocalCache();}List<E> list;try {// <3> queryStack + 1queryStack++;// <4> 从一级缓存中，获取查询结果list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;if (list != null) { // <4.1> 获取到，则进行处理// 处理缓存存储过程的结果handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);} else { // <4.2> 获得不到，则从数据库中查询list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);}} finally {// <5> queryStack - 1queryStack--;}if (queryStack == 0) { // <6> 如果当前会话的所有查询执行完了// <6.1> 执行延迟加载for (DeferredLoad deferredLoad : deferredLoads) {deferredLoad.load();}// issue #601// <6.2> 清空 deferredLoadsdeferredLoads.clear();// <6.3> 如果缓存级别是 LocalCacheScope.STATEMENT ，则进行清理if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {// issue #482clearLocalCache();}}// <7> 返回查询结果return list;
}

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds,ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {List<E> list;// <1> 在缓存中，添加正在执行的占位符对象，因为正在执行的查询不允许提前加载需要延迟加载的属性，可见 DeferredLoad#canLoad() 方法localCache.putObject(key, EXECUTION_PLACEHOLDER);try {// <2> 执行读操作list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);} finally {// <3> 从缓存中，移除占位对象localCache.removeObject(key);}// <4> 添加到缓存中localCache.putObject(key, list);// <5> 如果是存储过程，则将入参信息保存保存，跟一级缓存处理存储过程相关if (ms.getStatementType() == StatementType.CALLABLE) {localOutputParameterCache.putObject(key, parameter);}// <6> 返回查询结果return list;
}

@Override
public int update(MappedStatement ms, Object parameter) throws SQLException {ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());// <1> 已经关闭，则抛出 ExecutorException 异常if (closed) {throw new ExecutorException("Executor was closed.");}// <2> 清空本地缓存clearLocalCache();// <3> 执行写操作return doUpdate(ms, parameter);
}

<configuration><settings><setting name="cacheEnabled" value="false" /></settings>
</configuration>

public class CachingExecutor implements Executor {/*** 被委托的 Executor 对象*/private final Executor delegate;/*** TransactionalCacheManager 对象*/private final TransactionalCacheManager tcm = new TransactionalCacheManager();public CachingExecutor(Executor delegate) {this.delegate = delegate;// 设置 delegate 被当前执行器所包装delegate.setExecutorWrapper(this);}
}

@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds,ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {// <1> 获取 Cache 二级缓存对象Cache cache = ms.getCache();// <2> 如果配置了二级缓存if (cache != null) {// <2.1> 如果需要清空缓存，则进行清空flushCacheIfRequired(ms);// <2.2> 如果当前操作需要使用缓存（默认开启）if (ms.isUseCache() && resultHandler == null) {// <2.2.1> 如果是存储过程相关操作，保证所有的参数模式为 ParameterMode.INensureNoOutParams(ms, boundSql);// <2.2.2> 从二级缓存中获取结果，会装饰成 TransactionalCacheList<E> list = (List<E>) tcm.getObject(cache, key);if (list == null) {// <2.2.3> 如果不存在，则从数据库中查询list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);// <2.2.4> 将缓存结果保存至 TransactionalCachetcm.putObject(cache, key, list); // issue #578 and #116}// <2.2.5> 直接返回结果return list;}}// <3> 没有使用二级缓存，则调用委托对象的方法return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

@Override
public int update(MappedStatement ms, Object parameterObject) throws SQLException {// 如果需要清空缓存，则进行清空flushCacheIfRequired(ms);// 执行 delegate 对应的方法return delegate.update(ms, parameterObject);
}private void flushCacheIfRequired(MappedStatement ms) {Cache cache = ms.getCache();if (cache != null && ms.isFlushCacheRequired()) {tcm.clear(cache);}
}

@Override
public void commit(boolean required) throws SQLException {// 执行 delegate 对应的方法delegate.commit(required);// 提交 TransactionalCacheManagertcm.commit();
}

@Override
public void rollback(boolean required) throws SQLException {try {// 执行 delegate 对应的方法delegate.rollback(required);} finally {if (required) {// 回滚 TransactionalCacheManagertcm.rollback();}}
}

@Override
public void close(boolean forceRollback) {try {// issues #499, #524 and #573if (forceRollback) {tcm.rollback();} else {tcm.commit();}} finally {delegate.close(forceRollback);}
}

public class TransactionalCacheManager {/*** Cache 和 TransactionalCache 的映射*/private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<>();public void clear(Cache cache) {getTransactionalCache(cache).clear();}public Object getObject(Cache cache, CacheKey key) {return getTransactionalCache(cache).getObject(key);}public void putObject(Cache cache, CacheKey key, Object value) {// 首先，获得 Cache 对应的 TransactionalCache 对象// 然后，添加 KV 到 TransactionalCache 对象中getTransactionalCache(cache).putObject(key, value);}public void commit() {for (TransactionalCache txCache : transactionalCaches.values()) {txCache.commit();}}public void rollback() {for (TransactionalCache txCache : transactionalCaches.values()) {txCache.rollback();}}private TransactionalCache getTransactionalCache(Cache cache) {return transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);}}

public class TransactionalCache implements Cache {private static final Log log = LogFactory.getLog(TransactionalCache.class);/*** 委托的 Cache 对象。** 实际上，就是二级缓存 Cache 对象。*/private final Cache delegate;/*** 提交时，清空 {@link #delegate}** 初始时，该值为 false* 清理后{@link #clear()} 时，该值为 true ，表示持续处于清空状态** 因为可能事务还未提交，所以不能直接清空所有的缓存，而是设置一个标记，获取缓存的时候返回 null 即可* 先清空下面这个待提交变量，待事务提交的时候才真正的清空缓存**/private boolean clearOnCommit;/*** 待提交的 Key-Value 映射*/private final Map<Object, Object> entriesToAddOnCommit;/*** 查找不到的 KEY 集合*/private final Set<Object> entriesMissedInCache;public TransactionalCache(Cache delegate) {this.delegate = delegate;this.clearOnCommit = false;this.entriesToAddOnCommit = new HashMap<>();this.entriesMissedInCache = new HashSet<>();}@Overridepublic Object getObject(Object key) {// issue #116// <1> 从 delegate 中获取 key 对应的 valueObject object = delegate.getObject(key);if (object == null) {// <2> 如果不存在，则添加到 entriesMissedInCache 中entriesMissedInCache.add(key);}// issue #146if (clearOnCommit) {// <3> 如果 clearOnCommit 为 true ，表示处于持续清空状态，则返回 nullreturn null;} else {return object;}}@Overridepublic void putObject(Object key, Object object) {// 暂存 KV 到 entriesToAddOnCommit 中entriesToAddOnCommit.put(key, object);}@Overridepublic void clear() {// <1> 标记 clearOnCommit 为 trueclearOnCommit = true;// <2> 清空 entriesToAddOnCommitentriesToAddOnCommit.clear();}public void commit() {// <1> 如果 clearOnCommit 为 true ，则清空 delegate 缓存if (clearOnCommit) {delegate.clear();}// 将 entriesToAddOnCommit、entriesMissedInCache 刷入 delegate 中flushPendingEntries();// 重置reset();}public void rollback() {// <1> 从 delegate 移除出 entriesMissedInCacheunlockMissedEntries();// <2> 重置reset();}private void reset() {clearOnCommit = false;entriesToAddOnCommit.clear();entriesMissedInCache.clear();}private void flushPendingEntries() {for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {delegate.putObject(entry.getKey(), entry.getValue());}for (Object entry : entriesMissedInCache) {if (!entriesToAddOnCommit.containsKey(entry)) {delegate.putObject(entry, null);}}}private void unlockMissedEntries() {for (Object entry : entriesMissedInCache) {try {delegate.removeObject(entry);} catch (Exception e) {log.warn("Unexpected exception while notifiying a rollback to the cache adapter."+ "Consider upgrading your cache adapter to the latest version.  Cause: " + e);}}}
}

public class DefaultSqlSessionFactory implements SqlSessionFactory {private final Configuration configuration;@Overridepublic SqlSession openSession() {return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);}private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level,boolean autoCommit) {Transaction tx = null;try {// 获得 Environment 对象final Environment environment = configuration.getEnvironment();// 创建 Transaction 对象final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);// 创建 Executor 对象final Executor executor = configuration.newExecutor(tx, execType);// 创建 DefaultSqlSession 对象return new DefaultSqlSession(configuration, executor, autoCommit);} catch (Exception e) {// 如果发生异常，则关闭 Transaction 对象closeTransaction(tx); // may have fetched a connection so lets call close()throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);} finally {ErrorContext.instance().reset();}}
}

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {// <1> 获得执行器类型executorType = executorType == null ? defaultExecutorType : executorType;executorType = executorType == null ? ExecutorType.SIMPLE : executorType;// <2> 创建对应实现的 Executor 对象Executor executor;if (ExecutorType.BATCH == executorType) {executor = new BatchExecutor(this, transaction);} else if (ExecutorType.REUSE == executorType) {executor = new ReuseExecutor(this, transaction);} else {executor = new SimpleExecutor(this, transaction);}// <3> 如果开启缓存，创建 CachingExecutor 对象，进行包装if (cacheEnabled) {executor = new CachingExecutor(executor);}// <4> 应用插件executor = (Executor) interceptorChain.pluginAll(executor);return executor;
}