mybatis源码解析9---执行器Executor解析

从前面分析我们知道了sql的具体执行是通过调用SqlSession接口的对应的方法去执行的，而SqlSession最终都是通过调用了自己的Executor对象的query和update去执行的。本文就分析下sql的执行器-----Executor

Executor是mybatis的sql执行器，SqlSession是面向程序的，而Executor则就是面向数据库的，先看下Executor接口的方法有哪些，源码如下：

 public interface Executor {

   ResultHandler NO_RESULT_HANDLER = null;

   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;

   List<BatchResult> flushStatements() throws SQLException;

   void commit(boolean required) throws SQLException;

   void rollback(boolean required) throws SQLException;

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

   void setExecutorWrapper(Executor executor);

和SqlSession一样定义了各种各样的sql执行的方法，有查询的query方法，有更新的update方法，以及和事务有关的commit方法和rollback方法等，接下来就以query方法为例，看下具体是如何执行的。

Executor接口共有两个实现类，分别是BaseExecutor和CachingExecutor，CachingExecutor是缓存执行器，后面会提到，现在先看下BaseExecutor

BaseExecutor的属性有：

 1   protected Transaction transaction;//事务
   protected Executor wrapper;//执行器包装者

   protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;//线程安全队列
   protected PerpetualCache localCache;//本地缓存
   protected PerpetualCache localOutputParameterCache;
   protected Configuration configuration;

   protected int queryStack = 0;//查询次数栈
   private boolean closed;//是否已关闭(回滚的时候会被关闭)

再看下BaseExecutor执行query方法的源码：

 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());
       if (closed) {//判断执行器是否已关闭
         throw new ExecutorException("Executor was closed.");
       }
       //如果查询次数栈为0并且MappedStatement可以清除缓存,则清除本地缓存
       if (queryStack == 0 && ms.isFlushCacheRequired()) {
         clearLocalCache();
       }
       List<E> list;
       try {
         queryStack++;//查询次数+1
         list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;//从缓存中根据缓存key查询是否有缓存
         if (list != null) {
           //如果缓存中有数据,则处理缓存
           handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
         } else {
           //如果缓存中没有数据,则从数据库查询数据
           list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
         }
       } finally {
           //查询次数-1
         queryStack--;
       }
       if (queryStack == 0) {
         for (DeferredLoad deferredLoad : deferredLoads) {
           deferredLoad.load();
         }
         // issue #601
         deferredLoads.clear();
         if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
           // issue #482
           clearLocalCache();
         }
       }
       return list;
     }

可以看出BaseExecutor会优先从缓存中查询数据，如果缓存不为空再从数据库数据。在这里有一个queryStack会进行自增自减，它的作用是什么呢？

先看下如果没有缓存的话，BaseExecutor是怎么从数据库查询数据的：

 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);//执行doQuery方法
     } finally {
       localCache.removeObject(key);
     }
     localCache.putObject(key, list);//将查询结果放入缓存
     if (ms.getStatementType() == StatementType.CALLABLE) {//如果callable类型查询
       localOutputParameterCache.putObject(key, parameter);//将参数放入缓存中
     }
     return list;
   }

可见该方法是调用了doQuery方法从数据库查询了数据，然后将查询的结果及查询用的参数放入了缓存中，而doQuery方法是BaseExecutor中的抽象方法，具体的实现是由BaseExecutor的子类进行实现

  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;

   protected void closeStatement(Statement statement) {
     if (statement != null) {
       try {
         statement.close();
       } catch (SQLException e) {
         // ignore
       }
     }
   }

BaseExecutor共有SimpleExecutor、ReuseExecutor、BatchExecutor以及ClosedExecutor四个子类，这个后面再分析，现在我们以及知道了SqlSession是调用了Executor的方法来执行sql，而Executor的默认实现类的BaseExecutor，而BaseExecutor又是调用了其子类的方法。而BaseExecutor则对查询的结果进行了缓存处理以及查询的时候会从缓存中进行查询。