【MyBatis原理】 Mybatis中SqlSession及Executor工作过程解析

上一篇文章对MyBatis进行简单介绍，下面再继续对Mybatis中SqlSession及Executor工作过程深入解析。

首先，开启一个数据库访问会话，然后创建SqlSession对象，MyBatis使用SqlSession对象来封装对一次数据库的会话访问，通过SqlSession对象，实现事务的控制和数据查询等操作。

SqlSession sqlSession = factory.openSession(); 

然后为SqlSession传递一个配置的Sql语句的Statement Id和参数，然后返回结果：

List<Employee> result = sqlSession.selectList("com.framework.mybatis.dao.UserMapper.selectUser", params);

上述的"com.framework.mybatis.dao.UserMapper.selectUser"，是配置在UserMapper.xml 的Statement Id，params是传递的查询参数。

MyBatis在初始化的时候，会将MyBatis的配置信息全部加载到内存中，使用org.apache.ibatis.session.Configuration实例来维护。使用者可以使用sqlSession.getConfiguration()方法来获取，MyBatis的配置文件中配置信息的组织格式和内存中对象的组织格式几乎完全对应的。

<select id="selectUser" resultMap="BaseResultMap" parameterType="java.util.Map" >  
   select   
       USER_ID, NAME
   from PITT.USER  
   <if test="name != null">  
       where name = #{name, jdbcType=VARCHAR}  
   </if>  
</select>

Mapper文件中的SQL加载到内存中会生成一个对应的MappedStatement对象，然后会以key=“com.framework.mybatis.dao.UserMapper.selectUser” ，value为MappedStatement对象的形式维护到Configuration的一个Map中。当以后需要使用的时候，只需要通过Id值来获取就可以了。

让我们来看一下sqlSession.selectList()方法的定义：

public <E> List<E> selectList(String statement, Object parameter) {  
    return this.selectList(statement, parameter, RowBounds.DEFAULT);  
}  
 
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {  
    try {  
        // 根据Statement Id，在mybatis配置对象Configuration中查找和配置文件相对应的MappedStatement      
        MappedStatement ms = configuration.getMappedStatement(statement);  
        // 将查询任务委托给MyBatis的执行器(Executor)  
        List<E> result = executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);  
        return result;  
    } catch (Exception e) {  
        throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);  
    } finally {  
        ErrorContext.instance().reset();  
    }  
} 

由此可知道SqlSession可根据Statement Id， 在MyBatis配置对象Configuration中获取到对应的MappedStatement对象，然后调用MyBatis执行器Executor根据SqlSession传递的参数执行query()方法。那么Executor到底是什么？具体做了什么？

Executor解析

我们继续看下去，在BaseExecutor 里面是query方法的实现。

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
      // 根据具体传入的参数，动态地生成需要执行的SQL语句，用BoundSql对象表示    
      BoundSql boundSql = ms.getBoundSql(parameter);  
      // 为当前的查询创建一个缓存Key  
      CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);  
      return query(ms, parameter, rowBounds, resultHandler, key, boundSql);  
}  
 
@SuppressWarnings("unchecked")  
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.");  
       if (queryStack == 0 && ms.isFlushCacheRequired()) {  
           clearLocalCache();  
       }  
       List<E> list;  
       try {  
           queryStack++;  
           list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;  
           if (list != null) {  
               handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);  
           } else {  
               // 3.缓存中没有值，直接从数据库中读取数据    
               list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);  
           }  
       } finally {  
           queryStack--;  
       }  
       if (queryStack == 0) {  
           for (DeferredLoad deferredLoad : deferredLoads) {  
               deferredLoad.load();  
           }  
           deferredLoads.clear(); // issue #601  
           if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {  
               clearLocalCache(); // issue #482  
           }  
       }  
       return list;  
}

在query()方法中调用了queryFromDatabase()方法

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 结果，然后    将查询的结果放入缓存之中  
          list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);  
      } finally {  
          localCache.removeObject(key);  
      }  
      localCache.putObject(key, list);  
      if (ms.getStatementType() == StatementType.CALLABLE) {  
          localOutputParameterCache.putObject(key, parameter);  
      }  
      return list;  
} 

注：Executor有两个实现类：BaseExecutor和CachingExecutor
CachingExecutor用于二级缓存，BaseExecutor则用于一级缓存及基础的操作。
BaseExecutor是一个抽象类，提供了三个实现：SimpleExecutor，BatchExecutor，ReuseExecutor

doQuery()方法是一个abstract（抽象）方法，SimpleExecutor类的doQuery()方法实现如下：

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对象来执行查询操作  
          StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);  
          // 创建java.Sql.Statement对象，传递给StatementHandler对象  
          stmt = prepareStatement(handler, ms.getStatementLog());  
          // 调用StatementHandler.query()方法，返回List结果集  
          return handler.<E>query(stmt, resultHandler);  
       } finally {  
           closeStatement(stmt);  
       }  
}

上述的Executor.query()方法几经转折，最后会创建一个StatementHandler对象，然后将必要的参数传递给StatementHandler，使用StatementHandler来完成对数据库的查询，最终返回List结果集。

从上面的代码中我们可以看出，Executor的功能主要是：
1.根据传递的参数，完成SQL语句的动态解析，生成BoundSql对象，供StatementHandler使用；
2.为查询创建缓存，以提高性能；
3.创建JDBC的Statement连接对象，传递给StatementHandler对象，返回List查询结果；

StatementHandler

StatementHandler对象负责设置Statement对象中的查询参数、处理JDBC返回的resultSet，将resultSet加工为List 集合返回

接着上面的Executor第六步，看一下：prepareStatement() 方法的实现：

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
      Statement stmt;  
      Connection connection = getConnection(statementLog);  
      stmt = handler.prepare(connection);  
      // 对创建的Statement对象设置参数，即设置SQL语句中 ? 设置为指定的参数  
      handler.parameterize(stmt);  
      return stmt;  
}

StatementHandler对象主要完成两个工作：
1.对于JDBC的PreparedStatement类型的对象，创建的过程中，我们使用的是SQL语句字符串会包含若干个? 占位符，我们其后再对占位符进行设值。StatementHandler通过parameterize(statement)方法对Statement进行设值；

2.StatementHandler通过List query(Statement statement, ResultHandler resultHandler)方法来完成执行Statement，和将Statement对象返回的resultSet封装成List；

StatementHandler 的parameterize(statement) 方法的实现：

public void parameterize(Statement statement) throws SQLException {  
      // 使用ParameterHandler对象来完成对Statement的设值    
      parameterHandler.setParameters((PreparedStatement) statement);  
}

public void setParameters(PreparedStatement ps) throws SQLException {  
      ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());  
      List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();  
      if (parameterMappings != null) {  
          for (int i = 0; i < parameterMappings.size(); i++) {  
              ParameterMapping parameterMapping = parameterMappings.get(i);  
              if (parameterMapping.getMode() != ParameterMode.OUT) {  
                  Object value;  
                  String propertyName = parameterMapping.getProperty();  
                  if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params  
                      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);  
                  }       
                  // 每一个Mapping都有一个TypeHandler，根据TypeHandler来对preparedStatement进行设置参数  
                  TypeHandler typeHandler = parameterMapping.getTypeHandler();  
                  JdbcType jdbcType = parameterMapping.getJdbcType();  
                  if (value == null && jdbcType == null) jdbcType = configuration.getJdbcTypeForNull();  
                  // 设置参数  
                  typeHandler.setParameter(ps, i + 1, value, jdbcType);  
              }  
          }  
      }  
}  

从上述的代码可以看到，StatementHandler的parameterize(Statement) 方法调用了 ParameterHandler的setParameters(statement) 方法，ParameterHandler的setParameters(Statement)方法负责根据我们输入的参数，对statement对象的 ? 占位符处进行赋值。

StatementHandler 的List query(Statement statement, ResultHandler resultHandler)方法的实现：

public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {  
      // 调用preparedStatemnt的execute()方法，然后将resultSet交给ResultSetHandler处理    
      PreparedStatement ps = (PreparedStatement) statement;  
      ps.execute();  
      // 使用ResultHandler来处理ResultSet  
      return resultSetHandler.<E> handleResultSets(ps);  
}  

从上述代码我们可以看出，StatementHandler 的List query(Statement statement, ResultHandler resultHandler)方法的实现，是调用了ResultSetHandler的handleResultSets(Statement) 方法。

ResultSetHandler的handleResultSets(Statement) 方法会将Statement语句执行后生成的resultSet 结果集转换成List 结果集，ResultSetHandler类的handleResultSets()方法实现如下：

public List<Object> handleResultSets(Statement stmt) throws SQLException {  
      final List<Object> multipleResults = new ArrayList<Object>();  
 
      int resultSetCount = 0;  
      ResultSetWrapper rsw = getFirstResultSet(stmt);  
 
      List<ResultMap> resultMaps = mappedStatement.getResultMaps();  
      int resultMapCount = resultMaps.size();  
      validateResultMapsCount(rsw, resultMapCount);  
     
      while (rsw != null && resultMapCount > resultSetCount) {  
          ResultMap resultMap = resultMaps.get(resultSetCount);  
       
          //将resultSet  
          handleResultSet(rsw, resultMap, multipleResults, null);  
          rsw = getNextResultSet(stmt);  
          cleanUpAfterHandlingResultSet();  
          resultSetCount++;  
      }
 
      String[] resultSets = mappedStatement.getResulSets();  
      if (resultSets != null) {  
          while (rsw != null && resultSetCount < resultSets.length) {  
              ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);  
              if (parentMapping != null) {  
                  String nestedResultMapId = parentMapping.getNestedResultMapId();  
                  ResultMap resultMap = configuration.getResultMap(nestedResultMapId);  
                  handleResultSet(rsw, resultMap, null, parentMapping);  
              }  
              rsw = getNextResultSet(stmt);  
              cleanUpAfterHandlingResultSet();  
              resultSetCount++;  
          }  
      }  
 
      return collapseSingleResultList(multipleResults);  
}  

参考文章：终结篇：MyBatis原理深入解析（一）