mybatis源码阅读(五) ---执行器Executor-白红宇

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

阅读量：6913 次

发布时间：2019-06-27

本文共 9729 字，大约阅读时间需要 32 分钟。

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

public interface Executor {  ResultHandler NO_RESULT_HANDLER = null;  // 执行update，delete，insert三种类型的sql语句  int update(MappedStatement ms, Object parameter) throws SQLException;  // 执行select类型的SQL语句，返回值分为结果对象列表和游标对象  
    
      List
     
       query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;  
      
        List
       
         query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;  
        
          Cursor
         
           queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException; // 批量执行SQL语句 List
          
            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
    
      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
    
      doFlushStatements(boolean isRollback)    throws SQLException;protected abstract 
     
       List
      
        doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)    throws SQLException;protected abstract 
       
         Cursor
        
          doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql)    throws SQLException;

2.1 SimpleExecutor

@Overridepublic 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);  }}@Overridepublic 
    
      List
     
       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.
      
       query(stmt, resultHandler);  } finally {    closeStatement(stmt);//关闭statement对象  }}

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

2.2 ReuseExecutor

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

// 缓存使用过的Statement对象，key是SQL语句，value是SQL对应的Statement对象private final Map
    
      statementMap = new HashMap
     
      ();

/** * 准备获取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对象是非常合适。具体如下：

@Overridepublic List
    
      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
    
      statementList = new ArrayList
     
      (); //记录批处理的结果 BatchResult中通过updateCounts字段（int[]）记录每个Statement执行批处理的结果 private final List
      
        batchResultList = new ArrayList
       
        (); // 记录当前执行的SQL语句 private String currentSql; // 记录当前的MappedStatement对象 private MappedStatement currentStatement;

方法实现如下：

@Overridepublic 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();  // 本次执行的sql  final 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 322    BatchResult batchResult = batchResultList.get(last);    batchResult.addParameterObject(parameterObject);  } else {    // 尚不存在，新建Statement    Connection connection = getConnection(ms.getStatementLog());    stmt = handler.prepare(connection, transaction.getTimeout());    handler.parameterize(stmt);    //fix Issues 322    currentSql = 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集合中保存。

@Overridepublic 
    
      List
     
       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);}@Overridepublic 
      
        List
       
         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
        
          list = (List
         
          ) tcm.getObject(cache, key); if (list == null) {// (5) list = delegate.
          
            query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); tcm.putObject(cache, key, list); // issue #578 and #116 } return list; } } // 没有启动二级缓存，只调用底层Executor查询 return delegate.
           
             query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);}

转载于:https://my.oschina.net/u/3737136/blog/1812422

你可能感兴趣的文章