MyBatis - SQL执行过程（十四）ResultSetHandler

MyBatis - SQL执行过程（十四）ResultSetHandler

该系列文档是本人在学习 Mybatis 的源码过程中总结下来的，可能对各位读者会不太友好，阅读前需要对 MyBatis 和 Spring 有一定的了解。比较适合刚接触，会使用但是一直没去探究底层的同学。

MyBatis 版本：3.5.6

MyBatis-Spring 版本：2.0.3

MyBatis-Spring-Boot-Starter 版本：2.1.4

该系列其他文档请查看：《 MyBatis 系列 - 导读》

MyBatis的SQL执行过程

在前面一系列的文档中，我已经分析了 MyBatis 的基础支持层以及整个的初始化过程，此时 MyBatis 已经处于就绪状态了，等待使用者发号施令了

那么接下来我们来看看它执行SQL的整个过程，该过程比较复杂，涉及到二级缓存，将返回结果转换成 Java 对象以及延迟加载等等处理过程，这里将一步一步地进行分析：

• 《MyBatis - SQL执行过程（一）Executor》
• 《SQL执行过程（二）之StatementHandler》
• 《SQL执行过程（三）之ResultSetHandler》
• 《SQL执行过程（四）之延迟加载》

MyBatis中SQL执行的整体过程如下图所示：

在 SqlSession 中，会将执行 SQL 的过程交由Executor执行器去执行，过程大致如下：

1. 通过DefaultSqlSessionFactory创建与数据库交互的 SqlSession “会话”，其内部会创建一个Executor执行器对象
2. 然后Executor执行器通过StatementHandler创建对应的java.sql.Statement对象，并通过ParameterHandler设置参数，然后执行数据库相关操作
3. 如果是数据库更新操作，则可能需要通过KeyGenerator先设置自增键，然后返回受影响的行数
4. 如果是数据库查询操作，则需要将数据库返回的ResultSet结果集对象包装成ResultSetWrapper，然后通过DefaultResultSetHandler对结果集进行映射，最后返回 Java 对象

上面还涉及到一级缓存、二级缓存和延迟加载等其他处理过程

SQL执行过程（三）ResultSetHandler

DefaultResultSetHandler（结果集处理器）将数据库查询结果转换成 Java 对象是一个非常繁琐的过程，需要处理各种场景，如果继续往下看，请做好心理准备

可以先跳转到 DefaultResultSetHandler，查看流程图

在前面SQL执行过程一系列的文档中，已经详细地分析了在MyBatis的SQL执行过程中，SqlSession会话将数据库操作交由Executor执行器去完成，然后通过StatementHandler去执行数据库相关操作，并获取到数据库的执行结果

如果是数据库查询操作，则需要通过ResultSetHandler对查询返回的结果集进行映射处理，转换成对应的Java对象，算是SQL执行过程的最后一步，那么我们来看看MyBatis是如何完成这个繁杂的解析过程的

ResultSetHandler接口的实现类如下图所示：

先回顾一下ResultSetHandler在哪被调用，在PreparedStatementHandler的query方法中，代码如下：

@Override
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    // 执行
    ps.execute();
    // 结果处理器并返回结果
    return resultSetHandler.handleResultSets(ps);
}

• 属性resultSetHandler默认为DefaultResultSetHandler对象，可以回到《MyBatis - SQL执行过程（十三）StatementHandler》的BaseStatementHandler小节中的构造方法的第3步可以看到
• 调用resultSetHandler的handleResultSets(Statement stmt)方法，对结果集进行映射，转换成Java对象并返回

ResultSetWrapper

因为在DefaultResultSetHandler中，对ResultSet的操作更多的是它的ResultSetWrapper包装类，所以我们先来看看这个类

org.apache.ibatis.executor.resultset.ResultSetWrapper：java.sql.ResultSet的包装类，为DefaultResultSetHandler提供许多便捷的方法，直接来看它的代码

构造方法

public class ResultSetWrapper {

  /**
   * ResultSet 对象
   */
  private final ResultSet resultSet;
  /**
   * 类型处理器注册表
   */
  private final TypeHandlerRegistry typeHandlerRegistry;
  /**
   * ResultSet 中每列的列名
   */
  private final List<String> columnNames = new ArrayList<>();
  /**
   * ResultSet 中每列对应的 Java Type
   */
  private final List<String> classNames = new ArrayList<>();
  /**
   * ResultSet 中每列对应的 Jdbc Type
   */
  private final List<JdbcType> jdbcTypes = new ArrayList<>();
  /**
   * 记录每列对应的 TypeHandler 对象
   * key：列名
   * value：TypeHandler 集合
   */
  private final Map<String, Map<Class<?>, TypeHandler<?>>> typeHandlerMap = new HashMap<>();
  /**
   * 记录了被映射的列名
   * key：ResultMap 对象的 id {@link #getMapKey(ResultMap, String)}
   * value：ResultMap 对象映射的列名集合
   */
  private final Map<String, List<String>> mappedColumnNamesMap = new HashMap<>();
  /**
   * 记录了未映射的列名
   * key：ResultMap 对象的 id {@link #getMapKey(ResultMap, String)}
   * value：ResultMap 对象未被映射的列名集合
   */
  private final Map<String, List<String>> unMappedColumnNamesMap = new HashMap<>();

  public ResultSetWrapper(ResultSet rs, Configuration configuration) throws SQLException {
    super();
    this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
    this.resultSet = rs;
    // 获取 ResultSet 的元信息
    final ResultSetMetaData metaData = rs.getMetaData();
    final int columnCount = metaData.getColumnCount();
    for (int i = 1; i <= columnCount; i++) {
      // 获得列名或者通过 AS 关键字指定列名的别名
      columnNames.add(configuration.isUseColumnLabel() ? metaData.getColumnLabel(i) : metaData.getColumnName(i));
      // 获得该列对应的 Jdbc Type
      jdbcTypes.add(JdbcType.forCode(metaData.getColumnType(i)));
      // 获得该列对应的 Java Type
      classNames.add(metaData.getColumnClassName(i));
    }
  }
}

• resultSet：被包装的ResultSet结果集对象
• typeHandlerRegistry：类型处理器注册表，因为需要进行Java Type与Jdbc Type之间的转换
• columnNames：结果集中的所有列名
• classNames：结果集中的每列的对应的Java Type的名称
• jdbcTypes：结果集中的每列对应的Jdbc Type
• typeHandlerMap：结果集中每列对应的类型处理器
• mappedColumnNamesMap：保存每个ResultMap对象中映射的列名集合，也就是我们在标签下的子标签配置的column属性
• unMappedColumnNamesMap：保存每个ResultMap对象中未映射的列名集合，也就是没有在标签下配置过，但是查询结果返回了

在构造方法中，会初始化上面的columnNames、classNames和jdbcTypes属性

getTypeHandler方法

getTypeHandler(Class propertyType, String columnName)：通过列名和Java Type获取对应的TypeHandler类型处理器，方法如下：

public TypeHandler<?> getTypeHandler(Class<?> propertyType, String columnName) {
    TypeHandler<?> handler = null;
    // 获取列名对应的类型处理器
    Map<Class<?>, TypeHandler<?>> columnHandlers = typeHandlerMap.get(columnName);
    if (columnHandlers == null) {
      columnHandlers = new HashMap<>();
      typeHandlerMap.put(columnName, columnHandlers);
    } else {
      handler = columnHandlers.get(propertyType);
    }
    if (handler == null) {
      // 获取该列对应的 Jdbc Type
      JdbcType jdbcType = getJdbcType(columnName);
      // 根据 Java Type 和 Jdbc Type 获取对应的 TypeHandler 类型处理器
      handler = typeHandlerRegistry.getTypeHandler(propertyType, jdbcType);
      // Replicate logic of UnknownTypeHandler#resolveTypeHandler
      // See issue #59 comment 10
      if (handler == null || handler instanceof UnknownTypeHandler) {
        // 从 ResultSet 中获取该列对应的 Java Type 的 Class 对象
        final int index = columnNames.indexOf(columnName);
        final Class<?> javaType = resolveClass(classNames.get(index));
        if (javaType != null && jdbcType != null) {
          handler = typeHandlerRegistry.getTypeHandler(javaType, jdbcType);
        } else if (javaType != null) {
          handler = typeHandlerRegistry.getTypeHandler(javaType);
        } else if (jdbcType != null) {
          handler = typeHandlerRegistry.getTypeHandler(jdbcType);
        }
      }
      if (handler == null || handler instanceof UnknownTypeHandler) {
        // 最差的情况，设置为 ObjectTypeHandler
        handler = new ObjectTypeHandler();
      }
      // 将生成的 TypeHandler 存放在 typeHandlerMap 中
      columnHandlers.put(propertyType, handler);
    }
    return handler;
}

大致逻辑如下：

1. 先从Map, TypeHandler>> typeHandlerMap属性中获取类型处理器
2. 如果从缓存中没有获取到，则尝试根据Jdbc Type和Java Type从typeHandlerRegistry注册表获取
3. 如果还是没有获取到，则根据classNames中拿到结果集中该列的Java Type，然后在从typeHandlerRegistry注册表获取
4. 还是没有获取到，则设置为ObjectTypeHandler
5. 最后将其放入typeHandlerMap缓存中

loadMappedAndUnmappedColumnNames方法

loadMappedAndUnmappedColumnNames(ResultMap resultMap, String columnPrefix)方法，初始化mappedColumnNamesMap和unMappedColumnNamesMap两个属性，分别为映射的列名和未被映射的列名，方法如下：

private void loadMappedAndUnmappedColumnNames(ResultMap resultMap, String columnPrefix) throws SQLException {
    List<String> mappedColumnNames = new ArrayList<>();
    List<String> unmappedColumnNames = new ArrayList<>();
    // <1> 获取配置的列名的前缀，全部大写
    final String upperColumnPrefix = columnPrefix == null ? null : columnPrefix.toUpperCase(Locale.ENGLISH);
    /*
     * <2> 获取 ResultMap 中配置的所有列名，并添加前缀
     * 如果在  上面配置的是 resultType 属性，则返回的是空集合，因为它生成的 ResultMap 只有 Java Type 属性
     */
    final Set<String> mappedColumns = prependPrefixes(resultMap.getMappedColumns(), upperColumnPrefix);
    /*
     * <3> 遍历数据库查询结果中所有的列名
     * 将所有列名分为两类：是否配置了映射
     */
    for (String columnName : columnNames) {
      final String upperColumnName = columnName.toUpperCase(Locale.ENGLISH);
      if (mappedColumns.contains(upperColumnName)) {
        mappedColumnNames.add(upperColumnName);
      } else {
        unmappedColumnNames.add(columnName);
      }
    }
    // <4> 将上面两类的列名保存
    mappedColumnNamesMap.put(getMapKey(resultMap, columnPrefix), mappedColumnNames);
    unMappedColumnNamesMap.put(getMapKey(resultMap, columnPrefix), unmappedColumnNames);
}
 
  
 
   
 
获取配置的列名的前缀，全部大写，通常是没有配置的
 
 
   
 
获取ResultMap中配置的所有列名，并添加前缀
 
如果在上面配置的是resultType属性，则返回的是空集合，因为它创建的ResultMap对象中只有Java Type属性
  
   
 
遍历结果集中所有的列名，如果在标签中的子标签配置的column属性有包含这个列名，则属于映射的列名
 
 
   
 
否则就属于未被映射的列名
 
 
   
  
ResultSetHandler
 
  
org.apache.ibatis.executor.resultset.ResultSetHandler：结果集映射接口，代码如下：
 
  
public interface ResultSetHandler {
  /**
   * 处理 {@link java.sql.ResultSet} 成映射的对应的结果
   *
   * @param stmt Statement 对象
   * @param   泛型
   * @return 结果数组
   * @throws SQLException SQL异常
   */
  <E> List<E> handleResultSets(Statement stmt) throws SQLException;

  /**
   * 处理 {@link java.sql.ResultSet} 成 Cursor 对象
   *
   * @param stmt Statement 对象
   * @param   泛型
   * @return Cursor 对象
   * @throws SQLException SQL异常
   */
  <E> Cursor<E> handleCursorResultSets(Statement stmt) throws SQLException;

  /**
   * 暂时忽略，和存储过程相关
   *
   * @param cs CallableStatement 对象
   * @throws SQLException SQL异常
   */
  void handleOutputParameters(CallableStatement cs) throws SQLException;
}
 
  
DefaultResultSetHandler
 
  
org.apache.ibatis.executor.resultset.DefaultResultSetHandler：实现ResultSetHandler接口，处理数据库的查询结果，对结果集进行映射，将结果转换成Java对象
 
  
 
   
由于该类嵌套的方法太多了，可能一个方法会有十几层的嵌套，所以本分不会进行全面的分析
 
   
因为我查看这个类的时候是从下面的方法一层一层往上看的，注释我全部添加了，所以可以参考我的注释一步一步查看
 
   
接下来的描述可能有点混乱，请按照我在方法前面表明的顺序进行查看，参考：DefaultResultSetHandler.java
 
  
 
  
先来看下DefaultResultSetHandler处理结果集的方法的流程图：
 
  
 
  
构造方法
 
  
public class DefaultResultSetHandler implements ResultSetHandler {
    /**
     * 延迟加载默认对象
     */
    private static final Object DEFERRED = new Object();
    /**
     * 执行器
     */
    private final Executor executor;
    /**
     * 全局配置对象
     */
    private final Configuration configuration;
    /**
    * 本次查询操作对应的 MappedStatement 对象
    */
    private final MappedStatement mappedStatement;
    /**
     * 分页对象
     */
    private final RowBounds rowBounds;
    /**
     * 参数处理器，默认为 DefaultParameterHandler
     */
    private final ParameterHandler parameterHandler;
    /**
     * 结果处理器，默认为 DefaultResultHandler
     */
    private final ResultHandler<?> resultHandler;
    /**
     * SQL 相关信息
     */
    private final BoundSql boundSql;
    /**
     * 类型处理器注册表
     */
    private final TypeHandlerRegistry typeHandlerRegistry;
    /**
     * 对象实例工厂
     */
    private final ObjectFactory objectFactory;
    /**
     * Reflector 工厂
     */
    private final ReflectorFactory reflectorFactory;

	// nested resultmaps
	private final Map<CacheKey, Object> nestedResultObjects = new HashMap<>();
	private final Map<String, Object> ancestorObjects = new HashMap<>();
	private Object previousRowValue;

	// multiple resultsets
	private final Map<String, ResultMapping> nextResultMaps = new HashMap<>();
	private final Map<CacheKey, List<PendingRelation>> pendingRelations = new HashMap<>();

	// Cached Automappings
	private final Map<String, List<UnMappedColumnAutoMapping>> autoMappingsCache = new HashMap<>();

	// temporary marking flag that indicate using constructor mapping (use field to reduce memory usage)
	private boolean useConstructorMappings;

	public DefaultResultSetHandler(Executor executor, MappedStatement mappedStatement,
			ParameterHandler parameterHandler, ResultHandler<?> resultHandler, BoundSql boundSql, RowBounds rowBounds) {
		this.executor = executor;
		this.configuration = mappedStatement.getConfiguration();
		this.mappedStatement = mappedStatement;
		this.rowBounds = rowBounds;
		this.parameterHandler = parameterHandler;
		this.boundSql = boundSql;
		this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
		this.objectFactory = configuration.getObjectFactory();
		this.reflectorFactory = configuration.getReflectorFactory();
		this.resultHandler = resultHandler;
	}
}
 
  
 
   
上面的属性有点多，可以先根据注释进行理解，也可以在接下来的方法中逐步理解
 
  
 
  
1.handleResultSets方法
 
  
handleResultSets(Statement stmt)方法，处理结果集的入口
 
  
/**
 * 1.处理结果集
 */
@Override
public List<Object> handleResultSets(Statement stmt) throws SQLException {
    ErrorContext.instance().activity("handling results").object(mappedStatement.getId());

    /*
     * <1> 用于保存映射结果集得到的结果队形
     * 多 ResultSet 的结果集合，每个 ResultSet 对应一个 Object 对象，而实际上，每个 Object 是 List