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;
}

public void update(Object object) {// 方法参数 object 的 hashcodeint baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object);this.count++;// checksum 为 baseHashCode 的求和this.checksum += baseHashCode;// 计算新的 hashcode 值baseHashCode *= this.count;this.hashcode = this.multiplier * this.hashcode + baseHashCode;// 添加 object 到 updateList 中this.updateList.add(object);
}

@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);
}

public class SimpleExecutor extends BaseExecutor {public SimpleExecutor(Configuration configuration, Transaction transaction) {super(configuration, transaction);}@Overridepublic int doUpdate(MappedStatement ms, Object parameter) throws SQLException {Statement stmt = null;try {Configuration configuration = ms.getConfiguration();// 创建 StatementHandler 对象StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);// 初始化 Statement 对象stmt = prepareStatement(handler, ms.getStatementLog());// 通过 StatementHandler 执行写操作return handler.update(stmt);} finally {// 关闭 Statement 对象closeStatement(stmt);}}@Overridepublic <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 对象StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);// 初始化 Statement 对象stmt = prepareStatement(handler, ms.getStatementLog());// 通过 StatementHandler 执行读操作return handler.query(stmt, resultHandler);} finally {// 关闭 Statement 对象closeStatement(stmt);}}@Overrideprotected <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql)throws SQLException {Configuration configuration = ms.getConfiguration();StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, null, boundSql);Statement stmt = prepareStatement(handler, ms.getStatementLog());Cursor<E> cursor = handler.queryCursor(stmt);stmt.closeOnCompletion();return cursor;}@Overridepublic List<BatchResult> doFlushStatements(boolean isRollback) {return Collections.emptyList();}private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {Statement stmt;// 获得 Connection 对象，如果开启了 Debug 模式，则返回的是一个代理对象Connection connection = getConnection(statementLog);// 创建 Statement 或 PrepareStatement 对象stmt = handler.prepare(connection, transaction.getTimeout());// 往 Statement 中设置 SQL 语句上的参数，例如 PrepareStatement 的 ? 占位符handler.parameterize(stmt);return stmt;}
}

// Configuration.java
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement,Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {/** 创建 RoutingStatementHandler 路由对象* 其中根据 StatementType 创建对应类型的 Statement 对象，默认为 PREPARED* 执行的方法都会路由到该对象*/StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);// 将 Configuration 全局配置中的所有插件应用在 StatementHandler 上面statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);return statementHandler;
}

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {Statement stmt;BoundSql boundSql = handler.getBoundSql();String sql = boundSql.getSql();/** 根据需要执行的 SQL 语句判断 是否已有对应的 Statement 并且连接未关闭*/if (hasStatementFor(sql)) {// 从缓存中获得 Statement 对象stmt = getStatement(sql);// 重新设置事务超时时间applyTransactionTimeout(stmt);} else {// 获得 Connection 对象Connection connection = getConnection(statementLog);// 初始化 Statement 对象stmt = handler.prepare(connection, transaction.getTimeout());// 将 Statement 添加到缓存中，key 值为 当前执行的 SQL 语句putStatement(sql, stmt);}// 往 Statement 中设置 SQL 语句上的参数，例如 PrepareStatement 的 ? 占位符handler.parameterize(stmt);return stmt;
}

public class BatchExecutor extends BaseExecutor {public static final int BATCH_UPDATE_RETURN_VALUE = Integer.MIN_VALUE + 1002;/*** Statement 数组*/private final List<Statement> statementList = new ArrayList<>();/*** BatchResult 数组** 每一个 BatchResult 元素，对应 {@link #statementList} 集合中的一个 Statement 元素*/private final List<BatchResult> batchResultList = new ArrayList<>();/*** 上一次添加至批处理的 Statement 对象对应的SQL*/private String currentSql;/*** 上一次添加至批处理的 Statement 对象对应的 MappedStatement 对象*/private MappedStatement currentStatement;public BatchExecutor(Configuration configuration, Transaction transaction) {super(configuration, transaction);}
}

public class BatchResult {/*** MappedStatement 对象*/private final MappedStatement mappedStatement;/*** SQL*/private final String sql;/*** 参数对象集合** 每一个元素，对应一次操作的参数*/private final List<Object> parameterObjects;/*** 更新数量集合** 每一个元素，对应一次操作的更新数量*/private int[] updateCounts;public BatchResult(MappedStatement mappedStatement, String sql) {super();this.mappedStatement = mappedStatement;this.sql = sql;this.parameterObjects = new ArrayList<>();}public BatchResult(MappedStatement mappedStatement, String sql, Object parameterObject) {this(mappedStatement, sql);addParameterObject(parameterObject);}public void addParameterObject(Object parameterObject) {this.parameterObjects.add(parameterObject);}
}

@Override
public int doUpdate(MappedStatement ms, Object parameterObject) throws SQLException {final Configuration configuration = ms.getConfiguration();// <1> 创建 StatementHandler 对象final StatementHandler handler = configuration.newStatementHandler(this, ms, parameterObject, RowBounds.DEFAULT, null, null);final BoundSql boundSql = handler.getBoundSql();final String sql = boundSql.getSql();final Statement stmt;// <2> 如果和上一次添加至批处理 Statement 对象对应的 currentSql 和 currentStatement 都一致，则聚合到 BatchResult 中if (sql.equals(currentSql) && ms.equals(currentStatement)) {// <2.1> 获取上一次添加至批处理 Statement 对象int last = statementList.size() - 1;stmt = statementList.get(last);// <2.2> 重新设置事务超时时间applyTransactionTimeout(stmt);// <2.3> 往 Statement 中设置 SQL 语句上的参数，例如 PrepareStatement 的 ? 占位符handler.parameterize(stmt);// fix Issues 322// <2.4> 获取上一次添加至批处理 Statement 对应的 BatchResult 对象，将本次的入参添加到其中BatchResult batchResult = batchResultList.get(last);batchResult.addParameterObject(parameterObject);} else { // <3> 否则，创建 Statement 和 BatchResult 对象// <3.1> 初始化 Statement 对象Connection connection = getConnection(ms.getStatementLog());stmt = handler.prepare(connection, transaction.getTimeout());handler.parameterize(stmt); // fix Issues 322// <3.2> 设置 currentSql 和 currentStatemencurrentSql = sql;currentStatement = ms;// <3.3> 添加 Statement 到 statementList 中statementList.add(stmt);// <3.4> 创建 BatchResult 对象，并添加到 batchResultList 中batchResultList.add(new BatchResult(ms, sql, parameterObject));}// <4> 添加至批处理handler.batch(stmt);// <5> 返回 Integer.MIN_VALUE + 1002return BATCH_UPDATE_RETURN_VALUE;
}

@Override
public List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException {try {List<BatchResult> results = new ArrayList<>();if (isRollback) { // <1> 如果 isRollback 为 true ，返回空数组return Collections.emptyList();}// <2> 遍历 statementList 和 batchResultList 数组，逐个提交批处理for (int i = 0, n = statementList.size(); i < n; i++) {// <2.1> 获得 Statement 和 BatchResult 对象Statement stmt = statementList.get(i);applyTransactionTimeout(stmt);BatchResult batchResult = batchResultList.get(i);try {// <2.2> 提交该 Statement 的批处理batchResult.setUpdateCounts(stmt.executeBatch());MappedStatement ms = batchResult.getMappedStatement();List<Object> parameterObjects = batchResult.getParameterObjects();/** <2.3> 获得 KeyGenerator 对象* 1. 配置了 <selectKey /> 则会生成 SelectKeyGenerator 对象* 2. 配置了 useGeneratedKeys="true" 则会生成 Jdbc3KeyGenerator 对象* 否则为 NoKeyGenerator 对象*/KeyGenerator keyGenerator = ms.getKeyGenerator();if (Jdbc3KeyGenerator.class.equals(keyGenerator.getClass())) {Jdbc3KeyGenerator jdbc3KeyGenerator = (Jdbc3KeyGenerator) keyGenerator;// <2.3.1> 批处理入参对象集合，设置自增键jdbc3KeyGenerator.processBatch(ms, stmt, parameterObjects);} else if (!NoKeyGenerator.class.equals(keyGenerator.getClass())) { // issue #141for (Object parameter : parameterObjects) {// <2.3.1> 一次处理每个入参对象，设置自增键keyGenerator.processAfter(this, ms, stmt, parameter);}}// Close statement to close cursor #1109// <2.4> 关闭 Statement 对象closeStatement(stmt);} catch (BatchUpdateException e) {// 如果发生异常，则抛出 BatchExecutorException 异常StringBuilder message = new StringBuilder();message.append(batchResult.getMappedStatement().getId()).append(" (batch index #").append(i + 1).append(")").append(" failed.");if (i > 0) {message.append(" ").append(i).append(" prior sub executor(s) completed successfully, but will be rolled back.");}throw new BatchExecutorException(message.toString(), e, results, batchResult);}// <2.5> 添加到结果集results.add(batchResult);}return results;} finally {// <3.1> 关闭 Statement 们for (Statement stmt : statementList) {closeStatement(stmt);}// <3.2> 置空 currentSql、statementList、batchResultList 属性currentSql = null;statementList.clear();batchResultList.clear();}
}

<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;
}