mybatis——Executor

映射器了解完了，sqlSession.select()实际上是Executor.query()，所以sql执行实际是executor执行的。

一、BaseExecutor——实际的执行器（包含一级缓存实现）

BaseExecutor是一个Executor的顶级抽象类，实现了Executor接口，定义sql执行的执行器。

模板设计模式的运用，将一部分方法逻辑延迟给子类来实现。（专业术语：钩子）

BaseExecutor有4个实现子类：

下面介绍下BaseExecutor的实现

1、变量与构造方法

/* org.apache.ibatis.executor.BaseExecutor */
  protected Transaction transaction;//事务
  protected Executor wrapper;//一个指向自己(this)的指针

  protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
  
  //mybatis的一级缓存
  protected PerpetualCache localCache;
  protected PerpetualCache localOutputParameterCache;
  //configuration对象
  protected Configuration configuration;

  protected int queryStack;
  //关闭状态哨兵
  private boolean closed;

  protected BaseExecutor(Configuration configuration, Transaction transaction) {
    this.transaction = transaction;
    this.deferredLoads = new ConcurrentLinkedQueue<DeferredLoad>();
    this.localCache = new PerpetualCache("LocalCache");
    this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");
    this.closed = false;
    this.configuration = configuration;
    this.wrapper = this;
  }

2、主要方法

由于没有注释，所以方法作用不是很清楚，简单分了下类

/* org.apache.ibatis.executor.Executor */
  ResultHandler NO_RESULT_HANDLER = null;

  /* 
   * sql执行方法CRUD
   */
  int update(MappedStatement ms, Object parameter) throws SQLException;

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

  /*
   * BatchExecutor:执行所有的statement并关闭
   * ReuseExecutor：关闭所有复用的statemet
   */
  List<BatchResult> flushStatements() throws SQLException;

  /*  
   * 事务相关
   */ 
  void commit(boolean required) throws SQLException;

  void rollback(boolean required) throws SQLException;
  
  Transaction getTransaction();

  /*  
   * 缓存相关
   */
  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);

  /*  
   * 自身状态相关
   */
  void close(boolean forceRollback);

  boolean isClosed();

  void setExecutorWrapper(Executor executor);

① sql方法执行相关

方法过多，选取一个doQuery执行ff

/* 方法过多，选取一个方法研究 */
/* org.apache.ibatis.executor.BaseExecutor#query(org.apache.ibatis.mapping.MappedStatement, java.lang.Object, org.apache.ibatis.session.RowBounds, org.apache.ibatis.session.ResultHandler) */
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    //获取sql
    BoundSql boundSql = ms.getBoundSql(parameter);
    //创建缓存key
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
 }

  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    //sql校验是否存在
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    //关闭哨兵，如果executor已关闭，抛出异常
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    //清除缓存（mybatis一级缓存）
    //queryStack == 0 ：正在执行的select类型的sql的个数
    //并且 mappedStatement的flushCacheRequired属性为true，对应前面<sql>中的flushCache属性默认：<select> : false ; 非<select> true
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List<E> list;
    try {
      queryStack++;
      //根据cacheKey获取缓存
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        //缓存存在，由于默认preparedStatement，这里相当于空方法
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
        //数据库查询
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      queryStack--;
    }
    if (queryStack == 0) {
      //延迟加载，什么时候需要延迟加载
      //关联映射时，select返回的resultMap中嵌套了子select查询，延迟加载将select与嵌套的子select查询的结果resultMap关联起来。
      //具体例子 订单查询的结果中嵌套订单详情查询。
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        // 一级缓存的作用域是statement级别，清除缓存；默认的是session会话级别，不清楚缓存
        clearLocalCache();
      }
    }
    return list;
  }

list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql)：数据库查询

  private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    //正在执行的哨兵
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
      //抽象方法（钩子）：具体实现延迟到了子类
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
      localCache.removeObject(key);
    }
    //放入缓存到baseExecutor.localCache中
    localCache.putObject(key, list);
    if (ms.getStatementType() == StatementType.CALLABLE) {
      localOutputParameterCache.putObject(key, parameter);
    }
    return list;
  }

  protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
      throws SQLException;

查看了下BaseExecutor类，钩子方法只有4个，都是与sql执行相关的方法。

  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;

这里看看各个子类是怎样执行的，还是以doQuery()方法为研究点

SimpleExecutor（默认的BaseExecutor）：每创建一个statement，执行完sql后，关闭statement

  public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      //获取configuration对象
      Configuration configuration = ms.getConfiguration();
      //应用configuration的设置--<settings>标签，驼峰命名等
      //另外还会执行拦截器
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      stmt = prepareStatement(handler, ms.getStatementLog());
      //sql执行 statement.execute()
      //查询结果处理resultHandler.handleResultSet();result-->resultMap(处理嵌套sql)
      return handler.<E>query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }

  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    //获取连接
    Connection connection = getConnection(statementLog);
    //创建statement,并设置sql，默认是PreparedStatement
    stmt = handler.prepare(connection, transaction.getTimeout());
    //设置参数parameters
    handler.parameterize(stmt);
    return stmt;
  }

/* org.apache.ibatis.session.Configuration#newStatementHandler */

  public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    //应用configuration的一些设置
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
    //拦截器执行
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    return statementHandler;
  }

ReuseExecutor：创建一个statement，放入到一个statementMap<sql,statement>中实现statement复用，会设置一个事务超时时间，防止事务一直开启

statement关闭时机：调用doFlushStatement()时，

调用doFlushStatement()时机：① 显式调用：sqlSession.flushStatement(); ② 事务的提交、回退 sqlSession.commit();

/* org.apache.ibatis.executor.ReuseExecutor#doQuery */
  public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Configuration configuration = ms.getConfiguration();
    StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
    Statement stmt = prepareStatement(handler, ms.getStatementLog());
    return handler.<E>query(stmt, resultHandler);
  }

  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    BoundSql boundSql = handler.getBoundSql();
    String sql = boundSql.getSql();
    if (hasStatementFor(sql)) {
      //statement复用
      stmt = getStatement(sql);
      //事务有效时间
      applyTransactionTimeout(stmt);
    } else {
      Connection connection = getConnection(statementLog);
      stmt = handler.prepare(connection, transaction.getTimeout());
      putStatement(sql, stmt);
    }
    handler.parameterize(stmt);
    return stmt;
  }

  /* 
   * doFlushStatments关闭所有的statement
   * 执行时机：显式调用：sqlSession.flushStatements()
   */
  public List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException {
    for (Statement stmt : statementMap.values()) {
      closeStatement(stmt);
    }
    statementMap.clear();
    return Collections.emptyList();
  }

BatchExecutor：doQuery()创建一个statement，执行完sql，关闭statement，与SimpleExecutor不同主要在于doUpdate方法：

BatchExecutor的doUpdate方法不是立即执行，而是将各种statement放入到一个list中，并且一个statement也可能存储多个sql(执行sql时必须连续，不连续，会生成两个statement）

然后在调用doFlushStatement()时执行所有的statement并且关闭statement：

调用doFlushStatement的时机：① 显式调用：sqlSession.flushStatement() ② 每次执行查询之前。③ 事务提交，sqlSession.commit()

/* org.apache.ibatis.executor.SimpleExecutor#doUpdate 与doQuery没有区别 */
  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);
    }
  }

/* org.apache.ibatis.executor.BatchExecutor#doUpdate */
  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();
    final String sql = boundSql.getSql();
    final Statement stmt;
    if (sql.equals(currentSql) && ms.equals(currentStatement)) {
      //当执行sql，sql与当前sql相同，并且mappedStatement也相同
      //刷新preparedStatement的事务时间
      //追加parameter到preparedStatement中
      //追加resultMap到batchResult中
      //即同一个prepareStatement中放了多个sql，这些sql仅参数不同
      int last = statementList.size() - 1;
      stmt = statementList.get(last);
      applyTransactionTimeout(stmt);
     handler.parameterize(stmt);//fix Issues 322
      BatchResult batchResult = batchResultList.get(last);
      batchResult.addParameterObject(parameterObject);
    } else {
      //初次执行sql时与当前sql或mappedStatement不同时
      //创建connect连接
      //创建statement并设置有效时间
      //记录当前sql、mappedStatement
      //记录添加statement到statementList中
      //记录添加resultMap到batchResultList中
      Connection connection = getConnection(ms.getStatementLog());
      stmt = handler.prepare(connection, transaction.getTimeout());
      handler.parameterize(stmt);    //fix Issues 322
      currentSql = sql;
      currentStatement = ms;
      statementList.add(stmt);
      batchResultList.add(new BatchResult(ms, sql, parameterObject));
    }
    //可以看出是将多个sql放入list实现的队列中（FIFO）
    //并没有执行，执行doFlushStatements()方法时才会执行
  // handler.parameterize(stmt);
    handler.batch(stmt);
    return BATCH_UPDATE_RETURN_VALUE;
  }

  /* 执行doFlushStatements的时机：比ReuseExecutor多一个。
   * 显式调用：sqlSession.flushStatements()
   * 执行doQuery时会先执行doFlushStatements()后查询
   * 事务提交：sqlSession.commit();
   */
  public List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException {
    try {
      List<BatchResult> results = new ArrayList<BatchResult>();
      if (isRollback) {
        return Collections.emptyList();
      }
      for (int i = 0, n = statementList.size(); i < n; i++) {
        Statement stmt = statementList.get(i);
        applyTransactionTimeout(stmt);
        BatchResult batchResult = batchResultList.get(i);
        try {
          batchResult.setUpdateCounts(stmt.executeBatch());
          MappedStatement ms = batchResult.getMappedStatement();
          List<Object> parameterObjects = batchResult.getParameterObjects();
          KeyGenerator keyGenerator = ms.getKeyGenerator();
          if (Jdbc3KeyGenerator.class.equals(keyGenerator.getClass())) {
            Jdbc3KeyGenerator jdbc3KeyGenerator = (Jdbc3KeyGenerator) keyGenerator;
            jdbc3KeyGenerator.processBatch(ms, stmt, parameterObjects);
          } else if (!NoKeyGenerator.class.equals(keyGenerator.getClass())) { //issue #141
            for (Object parameter : parameterObjects) {
              keyGenerator.processAfter(this, ms, stmt, parameter);
            }
          }
          // Close statement to close cursor #1109
          closeStatement(stmt);
        } catch (BatchUpdateException e) {
          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);
        }
        results.add(batchResult);
      }
      return results;
    } finally {
      for (Statement stmt : statementList) {
        closeStatement(stmt);
      }
      currentSql = null;
      statementList.clear();
      batchResultList.clear();
    }
  }

ResultLoaderMap.ClosedExecutor：ResultLoaderMap的一个私有内部类，仅供ResultLoaderMap对象使用，不支持sql操作，仅close状态控制。

    protected <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
      throw new UnsupportedOperationException("Not supported.");
    }

 ② 事务相关

  //开启事务
  public Transaction getTransaction() {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    return transaction;
  }
   
  //提交事务
  public void commit(boolean required) throws SQLException {
    if (closed) {
      throw new ExecutorException("Cannot commit, transaction is already closed");
    }
    //清空缓存
    clearLocalCache();
    //清空statement，BatchExecutor会清空，清空前先执行
    flushStatements();
    if (required) {
      transaction.commit();
    }
  }
  
  //回退
  public void rollback(boolean required) throws SQLException {
    if (!closed) {
      try {
        //清空缓存
        clearLocalCache();
        //清空statement，BatchExecutor不会清空。
        flushStatements(true);
      } finally {
        if (required) {
          transaction.rollback();
        }
      }
    }
  }

③ 缓存相关

/* org.apache.ibatis.executor.BaseExecutor */
  //生成缓存key,
  //用sql、parameters、environmentId、mappedStatementId、offset+limit生成一个hashCode
  public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    CacheKey cacheKey = new CacheKey();
    cacheKey.update(ms.getId());
    cacheKey.update(rowBounds.getOffset());
    cacheKey.update(rowBounds.getLimit());
    cacheKey.update(boundSql.getSql());
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
    // mimic DefaultParameterHandler logic
    for (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) {
          value = null;
        } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
          value = parameterObject;
        } else {
          MetaObject metaObject = configuration.newMetaObject(parameterObject);
          value = metaObject.getValue(propertyName);
        }
        cacheKey.update(value);
      }
    }
    if (configuration.getEnvironment() != null) {
      // issue #176
      cacheKey.update(configuration.getEnvironment().getId());
    }
    return cacheKey;
  }

　//判断sql是否有缓存
  public boolean isCached(MappedStatement ms, CacheKey key) {
    return localCache.getObject(key) != null;
  }

  //清空缓存（mybatis一级缓存）
  public void clearLocalCache() {
    if (!closed) {
      localCache.clear();
      localOutputParameterCache.clear();
    }
  }

④ 关闭

  public void close(boolean forceRollback) {
    try {
      try {
        rollback(forceRollback);
      } finally {
        if (transaction != null) {
          transaction.close();
        }
      }
    } catch (SQLException e) {
      // Ignore.  There's nothing that can be done at this point.
      log.warn("Unexpected exception on closing transaction.  Cause: " + e);
    } finally {
      transaction = null;
      deferredLoads = null;
      localCache = null;
      localOutputParameterCache = null;
      closed = true;
    }
  }

  public boolean isClosed() {
    return closed;
  }

  public void setExecutorWrapper(Executor wrapper) {
    this.wrapper = wrapper;
  }

3、总结

① Executor接口实现功能包括四个模块：sql执行模块、事务模块、缓存模块、状态模块(关闭状态)

② 4个功能的具体实现都在BaseExecutor抽象类中，注意以下说的缓存就是mybatis的一级缓存。

• sql执行模块：先查询缓存，无缓存后执行sql，执行完成后，将结果放入到缓存中，具体执行sql的方法是钩子方法，延迟到子类中。
• 事务模块：开启事务，事务提交，事务回退。需要注意的是事务提交和事务回退会清空一级缓存，还会清空statement
• 缓存模块：生成cacheKey，判断是否存在缓存，清空缓存，chachKey的hashCode是多个属性联合生成的，包括id、sql、parameters、offset+limit、environmentId。
• 状态模块：关闭Executor，清空所有资源；判断关闭状态。

③ 执行sql的具体实现延迟到了4个子类中，注意statement创建之前，会应用configuration对象的设置<setting>，及执行拦截器方法<plugin>中

• SimpleExecutor：每次执行sql时，创建一个statement，执行sql，关闭statement
• ReuseExecutor：初次执行sql时，创建一个statement，后续此sql的执行都是用此statement执行，调用doFlushStatement会清空所有statement。（statement复用）
• BatchExecutor ：执行update的sql时，创建一个statement放入到一个队列中，不立即执行，另外如果执行的sql与队尾的statement相同，将sql放入到statement中，注意是队尾statement。在调用doFlushStatement()时才会执行statement。执行query的sql时，先执行doFlushStatement(),然后与SimpleExecutor一致
• closeExecutor：一个无用的Executor

④ doFlushStatement的时机：

• SimpleExecutor：由于statement创建执行后直接关闭了，所以doFlushStatement方法无用。
• ReuseExecutor：显式调用sqlSession.flushStatement；事务提交与回退；Executor关闭
• BatchExecutor：显式调用sqlSession.flushStatement；事务提交；Executor关闭；每次查询sql执行之前

⑤ 关联映射时，延迟加载的使用。

二、CachingExecutor——二级缓存执行器

缓存执行器：mybatis二级缓存的实现，下面是CachingExecutor简单结构图

 CachingExecutor声明了一个Executor对象和一个缓存管理对象TransactionCacheManager。

CachingExecutor执行sql时，会先使用先校验二级缓存，后使用BaseExecutor（内含一级缓存）执行sql。

实际使用时：开启一次会话sqlSession时，创建的Executor是new CachingExecutor(new SimpleExecutor);

 1、变量与构造方法

  private final Executor delegate;
  private final TransactionalCacheManager tcm = new TransactionalCacheManager();

  public CachingExecutor(Executor delegate) {
    this.delegate = delegate;
    delegate.setExecutorWrapper(this);
  }

2、方法实现

CachingExecutor的大部分方法都使用策略模式调用内部变量executor的方法。选取几个重要的方法。

①缓存相关方法的实现：

最终调用的都是BaseExecutor的方法

意味着：一级缓存与二级缓存的cacheKey相同；CachingExecutor.clearLocalCache()清理的是一级缓存

/* org.apache.ibatis.executor.CachingExecutor#createCacheKey */
  public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    //BaseExecutor.createCacheKey()
    return delegate.createCacheKey(ms, parameterObject, rowBounds, boundSql);
  }
  //调用baseExecutor.isCached
  public boolean isCached(MappedStatement ms, CacheKey key) {
    return delegate.isCached(ms, key);
  }
  //调用baseExecutor.clearLocalCache():注意这里是清空一级缓存
  public void clearLocalCache() {
    delegate.clearLocalCache();
  }

② 查询方法

  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    //跟一级缓存相比，生成的boundSql一致，生成的cacheKey一致
    BoundSql boundSql = ms.getBoundSql(parameterObject);
    CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
    return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    //获取二级缓存，二级缓存对应mappedStatement.cache
    //前面<mapper>标签解析时漏掉了，<mapper>里有<cache>标签
    //在解析<cache>标签时会创建一个cache对象放入到configuration.caches中同时会关联到mapperStatement.cache
    //二级缓存有多个cache实例，一个mapper.xml对应一个cache实例
    Cache cache = ms.getCache();
    if (cache != null) {
      //mappedStatement.flushCacheRequired == true ，删除缓存mappedStatement.cache.clear()
      //复习下mappedStatement.flushCacheRequired，对应<sql>上的flushCache属性，默认<select>:false；非<select>:true
      flushCacheIfRequired(ms);
      //mappedStatement.useCache == true时才使用缓存
      //复习下mappedStatement.userCache,对应<sql>上的useCache属性，默认<select>:true；非<select>:false
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")
        //从缓存中获取cacheKey对应的value
        //mappedStatement.cache.get(cacheKey)
        List<E> list = (List<E>) tcm.getObject(cache, key);
        if (list == null) {
          //缓存中没有调用BaseExecutor执行sql，这里会查询一级缓存，若不存在，查询数据库，并更新一级缓存
          list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          //放入二级缓存中
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

3、总结

① cacheExecutor采用策略模式，组合了一个BaseExecutor，执行的方法也是BaseExecutor的方法

② 由于CachingExecutor.createCacheKey()最终调用的是BaseExecutor.createCacheKey，所以一级缓存与二级缓存的cacheKey相同

③ 开启二级缓存后，sql执行先从查询二级缓存，后查询一级缓存，最后查询数据库。

④ 一级缓存 : BaseExecutor.localCache；二级缓存 : configuration.caches<namespace,cache>以namespace；两种cache最终数据存储在PerpetualCache.cache（Map类型）中

⑤ 虽然configuration默认的Executor是new CachingExecutor(new SimpleExecutor)，但是由于在解析mapper.xml时，有<cache>或<cache-ref>标签才会创建一个cache到configuration.caches中，所以二级缓存默认是关闭的，需要到mapper.xml里面加入<cache><cache-ref>开启二级缓存

⑥ <cache>与<cache-ref>：<cache>创建一个LruCache实例，管理二级缓存的开启关闭，里面有一个PerpetualCache类型变量(装饰者模式)，<cache-ref>作用主要是：一个mapper.xml可以引用另一mapper.xml的缓存达到缓存共享。

补充：LruCache与CachingExecutor的UML图类似，为什么判断一个是装饰者模式，一个是策略模式。

装饰者模式设计目的是原对象（PerpetualCache）的功能增强；策略默认设计目的原对象（Executor）抽象，可使用多个子对象（SimpleExecutor、ReuseExecutor、BatchExecutor）替换