MyBatis - SqlSession(下）-阿里云开发者社区

四、Executor

前面提到过，sqlsession只是一个门面，真正发挥作用的是executor，对sqlsession方法的访问最终都会落到executor的相应方法上去。Executor分成两大类，一类是CacheExecutor，另一类是普通Executor。Executor的创建前面已经介绍了，下面介绍下他们的功能：

1、CacheExecutor

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

public List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    if (ms != null) {
        Cache cache = ms.getCache();
        if (cache != null) {
           flushCacheIfRequired(ms);
           cache.getReadWriteLock().readLock().lock();
           try {
               if (ms.isUseCache() && resultHandler ==null) {
                   CacheKey key = createCacheKey(ms, parameterObject, rowBounds);
                   final List cachedList = (List)cache.getObject(key);
                   if (cachedList != null) {
                        return cachedList;
                   } else {
                       List list = delegate.query(ms,parameterObject, rowBounds, resultHandler);
                       tcm.putObject(cache,key, list);
                       return list;
                   }
               } else {
                   return delegate.query(ms,parameterObject, rowBounds, resultHandler);
               }
            } finally {
               cache.getReadWriteLock().readLock().unlock();
            }
        }
    }
    return delegate.query(ms,parameterObject, rowBounds, resultHandler);
}

2、普通 Executor

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

public List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    Statementstmt = null;
    try {
       Configuration configuration = ms.getConfiguration();
       StatementHandler handler = configuration.newStatementHandler(this, ms,parameter, rowBounds,resultHandler);
       stmt = prepareStatement(handler);
       return handler.query(stmt, resultHandler);
    } finally {
       closeStatement(stmt);
    }
}

可以看出，Executor本质上也是个甩手掌柜，具体的事情原来是StatementHandler来完成的。

五、StatementHandler

当Executor将指挥棒交给StatementHandler后，接下来的工作就是StatementHandler的事了。我们先看看StatementHandler是如何创建的。

1、创建

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement,
        Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) {
   StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler);
   statementHandler= (StatementHandler) interceptorChain.pluginAll(statementHandler);
   return statementHandler;
}

可以看到每次创建的StatementHandler都是RoutingStatementHandler，它只是一个分发者，他一个属性delegate用于指定用哪种具体的StatementHandler。可选的StatementHandler有SimpleStatementHandler、PreparedStatementHandler和CallableStatementHandler三种。选用哪种在mapper配置文件的每个statement里指定，默认的是PreparedStatementHandler。同时还要注意到StatementHandler是可以被拦截器拦截的，和Executor一样，被拦截器拦截后的对像是一个代理对象。由于mybatis没有实现数据库的物理分页，众多物理分页的实现都是在这个地方使用拦截器实现的，本文作者也实现了一个分页拦截器，在后续的章节会分享给大家，敬请期待。

2、初始化

StatementHandler创建后需要执行一些初始操作，比如statement的开启和参数设置、对于PreparedStatement还需要执行参数的设置操作等。代码如下：

private Statement prepareStatement(StatementHandler handler) throwsSQLException {
    Statement stmt;
    Connection connection = transaction.getConnection();
    stmt =handler.prepare(connection);
    handler.parameterize(stmt);
    return stmt;
}

statement的开启和参数设置没什么特别的地方，handler.parameterize倒是可以看看是怎么回事。handler.parameterize通过调用ParameterHandler的setParameters完成参数的设置，ParameterHandler随着StatementHandler的创建而创建，默认的实现是DefaultParameterHandler：

public ParameterHandler newParameterHandler(MappedStatement mappedStatement, ObjectparameterObject, BoundSql boundSql) {
   ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement,parameterObject,boundSql);
   parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
   return parameterHandler;
}

同Executor和StatementHandler一样，ParameterHandler也是可以被拦截的。

3、参数设置

DefaultParameterHandler里设置参数的代码如下：

public void setParameters(PreparedStatement ps) throws SQLException {
   ErrorContext.instance().activity("settingparameters").object(mappedStatement.getParameterMap().getId());
   List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if(parameterMappings != null) {
       MetaObject metaObject = parameterObject == null ? null : configuration.newMetaObject(parameterObject);
        for (int i = 0; i< parameterMappings.size(); i++) {
           ParameterMapping parameterMapping = parameterMappings.get(i);
            if(parameterMapping.getMode() != ParameterMode.OUT) {
               Object value;
               String propertyName = parameterMapping.getProperty();
               PropertyTokenizer prop = new PropertyTokenizer(propertyName);
               if (parameterObject == null) {
                   value = null;
               } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())){
                   value = parameterObject;
               } else if (boundSql.hasAdditionalParameter(propertyName)){
                   value = boundSql.getAdditionalParameter(propertyName);
               } else if(propertyName.startsWith(ForEachSqlNode.ITEM_PREFIX)
                        && boundSql.hasAdditionalParameter(prop.getName())){
                   value = boundSql.getAdditionalParameter(prop.getName());
                   if (value != null) {
                        value = configuration.newMetaObject(value).getValue(propertyName.substring(prop.getName().length()));
                   }
               } else {
                   value = metaObject == null ? null :metaObject.getValue(propertyName);
               }
               TypeHandler typeHandler = parameterMapping.getTypeHandler();
               if (typeHandler == null) {
                   throw new ExecutorException("Therewas no TypeHandler found for parameter " + propertyName  + " of statement " + mappedStatement.getId());
                }
               typeHandler.setParameter(ps, i + 1, value,parameterMapping.getJdbcType());
            }
        }
    }
}

这里面最重要的一句其实就是最后一句代码，它的作用是用合适的TypeHandler完成参数的设置。那么什么是合适的TypeHandler呢，它又是如何决断出来的呢？BaseStatementHandler的构造方法里有这么一句：

this.boundSql= mappedStatement.getBoundSql(parameterObject);

它触发了sql 的解析，在解析sql的过程中，TypeHandler也被决断出来了，决断的原则就是根据参数的类型和参数对应的JDBC类型决定使用哪个TypeHandler。比如：参数类型是String的话就用StringTypeHandler，参数类型是整数的话就用IntegerTypeHandler等。

参数设置完毕后，执行数据库操作（update或query）。如果是query最后还有个查询结果的处理过程。

六、ResultSetHandler

1、结果处理

结果处理使用ResultSetHandler来完成，默认的ResultSetHandler是FastResultSetHandler，它在创建StatementHandler时一起创建，代码如下：

public ResultSetHandler newResultSetHandler(Executor executor, MappedStatementmappedStatement,
RowBoundsrowBounds, ParameterHandler parameterHandler, ResultHandler resultHandler, BoundSqlboundSql) {
   ResultSetHandler resultSetHandler = mappedStatement.hasNestedResultMaps() ? newNestedResultSetHandler(executor, mappedStatement, parameterHandler,resultHandler, boundSql, rowBounds): new FastResultSetHandler(executor,mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
   resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
   return resultSetHandler;
}

可以看出ResultSetHandler也是可以被拦截的，可以编写自己的拦截器改变ResultSetHandler的默认行为。

// ResultSetHandler内部一条记录一条记录的处理，在处理每条记录的每一列时会调用TypeHandler转换结果，如下：
protected boolean applyAutomaticMappings(ResultSet rs, List<String> unmappedColumnNames,MetaObject metaObject) throws SQLException {
    boolean foundValues = false;
    for (StringcolumnName : unmappedColumnNames) {
        final Stringproperty = metaObject.findProperty(columnName);
        if (property!= null) {
            final ClasspropertyType = metaObject.getSetterType(property);
            if (typeHandlerRegistry.hasTypeHandler(propertyType)) {
               final TypeHandler typeHandler = typeHandlerRegistry.getTypeHandler(propertyType);
               final Object value = typeHandler.getResult(rs,columnName);
               if (value != null) {
                   metaObject.setValue(property, value);
                   foundValues = true;
               }
            }
        }
    }
    return foundValues;
}