Mybatis 之 Executor

朱雀 2022-06-08 01:13 168阅读 0赞

DefaultSqlSession是SqlSession的实现类。我们来看一个具体的实现方法：

@Override  
    public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {  
      try {  
        MappedStatement ms = configuration.getMappedStatement(statement);  
        return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);  
      } catch (Exception e) {  
        throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);  
      } finally {  
        ErrorContext.instance().reset();  
      }  
    }

我们看到，真正执行的代码在Executor对象里面.

DefaultSqlSession类的成员executor是在构造函数里面给他赋值的。所以我们又要回头去查看一下是在什么时候实例化了DefaultSqlSession类。

DefaultSqlSession在SqlSessionFactory的实现类DefaultSqlSessionFactory中被创建：

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {  
      Transaction tx = null;  
      try {  
        final Environment environment = configuration.getEnvironment();  
        final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);  
        tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);  
        final Executor executor = configuration.newExecutor(tx, execType);  
        return new DefaultSqlSession(configuration, executor, autoCommit);  
      } catch (Exception e) {  
        closeTransaction(tx); // may have fetched a connection so lets call close()  
        throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);  
      } finally {  
        ErrorContext.instance().reset();  
      }  
    }  
      
    private SqlSession openSessionFromConnection(ExecutorType execType, Connection connection) {  
      try {  
        boolean autoCommit;  
        try {  
          autoCommit = connection.getAutoCommit();  
        } catch (SQLException e) {  
          // Failover to true, as most poor drivers  
          // or databases won't support transactions  
          autoCommit = true;  
        }        
        final Environment environment = configuration.getEnvironment();  
        final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);  
        final Transaction tx = transactionFactory.newTransaction(connection);  
        final Executor executor = configuration.newExecutor(tx, execType);  
        return new DefaultSqlSession(configuration, executor, autoCommit);  
      } catch (Exception e) {  
        throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);  
      } finally {  
        ErrorContext.instance().reset();  
      }  
    }

从源码中我们可以看到他是通过Configuration类的newExecutor方法来得到的，代码如下：

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
        executorType = executorType == null ? defaultExecutorType : executorType;
        executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
        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);
        }
        if (cacheEnabled) {
          executor = new CachingExecutor(executor);
        }
        executor = (Executor) interceptorChain.pluginAll(executor);
        return executor;
      }

Executor分成两大类，一类是CacheExecutor，另一类是普通Executor。

CacheExecutor有一个重要属性delegate，它保存的是某类普通的Executor，值在构照时传入。执行数据库update操作时，它直接调用delegate的update方法，执行query方法时先尝试从cache中取值，取不到再调用delegate的查询方法，并将查询结果存入cache中。代码如下：

@Override
      public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
          throws SQLException {
        Cache cache = ms.getCache();
        if (cache != null) {
          flushCacheIfRequired(ms);
          if (ms.isUseCache() && resultHandler == null) {
            ensureNoOutParams(ms, parameterObject, boundSql);
            @SuppressWarnings("unchecked")
            List<E> list = (List<E>) tcm.getObject(cache, key);
            if (list == null) {
              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);
      }

普通类又分为：

ExecutorType.SIMPLE: 这个执行器类型不做特殊的事情。它为每个语句的执行创建一个新的预处理语句。  
ExecutorType.REUSE: 这个执行器类型会复用预处理语句。  
ExecutorType.BATCH: 这个执行器会批量执行所有更新语句,如果 SELECT 在它们中间执行还会标定它们是 必须的,来保证一个简单并易于理解的行为。

分别对应SimpleExecutor，ReuseExecutor，BatchExecutor，他们都继承于BaseExecutor，BatchExecutor专门用于执行批量sql操作，ReuseExecutor会重用statement执行sql操作，SimpleExecutor只是简单执行sql没有什么特别的。下面以SimpleExecutor为例：

@Override
      public <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 handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
          stmt = prepareStatement(handler, ms.getStatementLog());
          return handler.<E>query(stmt, resultHandler);
        } finally {
          closeStatement(stmt);
        }
      }

可以看出，Executor本质上也是个中介，具体的事情原来是StatementHandler来完成的。