Mybatis-DefaultResultSetHandler(一)源码解析

Mybatis3.5.1源码分析

1. Mybatis-SqlSessionFactoryBuilder，XMLConfigBuilder，XPathParser源码解析
2. Mybatis-Configuration源码解析
3. Mybatis-事务对象源码解析
4. Mybatis-数据源源码解析
5. Mybatis缓存策略源码解析
6. Mybatis-DatabaseIdProvider源码解析
7. Mybatis-TypeHandler源码解析
8. Mybatis-Reflector源码解析
9. Mybatis-ObjectFactory，ObjectWrapperFactory源码分析
10. Mybatis-Mapper各类标签封装类源码解析
11. Mybatis-XMLMapperBuilder,XMLStatmentBuilder源码分析
12. Mybatis-MapperAnnotationBuilder源码分析
13. [Mybatis-MetaObject,MetaClass源码解析]https://www.jianshu.com/p/f51fa552f30a)
14. Mybatis-LanguageDriver源码解析
15. Mybatis-SqlSource源码解析
16. Mybatis-SqlNode源码解析
17. Mybatis-KeyGenerator源码解析
18. Mybatis-Executor源码解析
19. Mybatis-ParameterHandler源码解析
20. Mybatis-StatementHandler源码解析
21. Mybatis-DefaultResultSetHandler(一)源码解析
22. Mybatis-DefaultResultSetHandler(二)源码解析
23. Mybatis-ResultHandler,Cursor,RowBounds 源码分析
24. Mybatis-MapperProxy源码解析
25. Mybatis-SqlSession源码解析
26. Mybatis-Interceptor源码解析

DefaultResultSetHandler

package org.apache.ibatis.executor.resultset;

/**
 * 默认的结果集处理器
 * 

 *     别名说明：
 *     

 *         
Mapper.xml的resultMap标签信息封装类对象 简称 resultMap标签对象
 *         
根据resultMap对象与结果集构建出来的java类型对象，简称为 结果对象
 *     
 *
 * 

 * 
参考博客：https://my.oschina.net/u/3768341/blog/3040013
 * 
https://my.oschina.net/heweipo/blog/621613
 * @author Clinton Begin
 * @author Eduardo Macarron
 * @author Iwao AVE!
 * @author Kazuki Shimizu
 */
public class DefaultResultSetHandler implements ResultSetHandler {

  /**
   * 标记着待定的对象
   */
  private static final Object DEFERRED = new Object();

  /**
   * 执行器
   */
  private final Executor executor;
  /**
   * mybatis全局配置信息
   */
  private final Configuration configuration;
  /**
   *  Mapper.xml文件的select,delete,update,insert这些DML标签的封装类
   */
  private final MappedStatement mappedStatement;
  /**
   * Mybatis的分页对象
   */
  private final RowBounds rowBounds;
  /**
   * 参数处理器
   */
  private final ParameterHandler parameterHandler;
  /**
   * 结果处理器
   */
  private final ResultHandler resultHandler;
  /**
   * 参数映射与可执行SQL封装类对象
   */
  private final BoundSql boundSql;
  /**
   * 类型处理器注册器对象
   */
  private final TypeHandlerRegistry typeHandlerRegistry;
  /**
   * 对象工厂，从mybatis全局配置信息中获取
   */
  private final ObjectFactory objectFactory;
  /**
   * 反射工厂,从mybatis全局配置信息中获取
   */
  private final ReflectorFactory reflectorFactory;

  // nested resultmaps
  /**
   * key=缓存Key,value=嵌套的结果对象
   */
  private final Map nestedResultObjects = new HashMap<>();
  private final Map ancestorObjects = new HashMap<>();
  /**
   * 上一次嵌套的resultMap对象所构建出来的对象
   */
  private Object previousRowValue;

  // multiple resultsets
  private final Map nextResultMaps = new HashMap<>();
  /**
   * PendingRelation是DefaultResultSetHandler的内部静态类，记录了当前结果对象对应的MetaObject对象以及parentMapping对象
   * 该对象就为CacheKey对象跟全部的PendingRelation对象的映射
   */
  private final Map> pendingRelations = new HashMap<>();

  // Cached Automappings
  /**
   * 自动映射关系缓存Map
   */
  private final Map> autoMappingsCache = new HashMap<>();

  // temporary marking flag that indicate using constructor mapping (use field to reduce memory usage)
  // 表明使用构造函数映射关系的临时标志标记（使用成员变量来减少内存开销)
  /**
   * 当前结果对象是否使用了非无参构造函数进行构建的标记
   */
  private boolean useConstructorMappings;

  /**
   * 待定关系
   */
  private static class PendingRelation {
    /**
     * 元对象
     */
    public MetaObject metaObject;
    /**
     * 结果映射
     */
    public ResultMapping propertyMapping;
  }

  private static class UnMappedColumnAutoMapping {
    /**
     * 字段名
     */
    private final String column;
    /**
     * 属性名
     */
    private final String property;
    /**
     * TypeHandler 处理器
     */
    private final TypeHandler typeHandler;
    /**
     * 是否为基本属性
     */
    private final boolean primitive;

    /**
     *
     * @param column 字段名
     * @param property 属性名
     * @param typeHandler TypeHandler 处理器
     * @param primitive 是否为基本属性
     */
    public UnMappedColumnAutoMapping(String column, String property, TypeHandler typeHandler, boolean primitive) {
      this.column = column;
      this.property = property;
      this.typeHandler = typeHandler;
      this.primitive = primitive;
    }
  }

  /**
   *
   * @param executor 执行器
   * @param mappedStatement Mapper.xml文件的select,delete,update,insert这些DML标签的封装类
   * @param parameterHandler 参数处理器
   * @param resultHandler 结果处理器
   * @param boundSql 参数映射与可执行SQL封装类对象
   * @param rowBounds Mybatis的分页对象
   */
  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;
  }

  //
  // HANDLE OUTPUT PARAMETER
  //

  @Override
  public void handleOutputParameters(CallableStatement cs) throws SQLException {
    //获取参数对象
    final Object parameterObject = parameterHandler.getParameterObject();
    //构建参数元对象
    final MetaObject metaParam = configuration.newMetaObject(parameterObject);
    //获取参数映射集合
    final List parameterMappings = boundSql.getParameterMappings();
    //遍历参数映射集合
    for (int i = 0; i < parameterMappings.size(); i++) {
      //获取参数映射
      final ParameterMapping parameterMapping = parameterMappings.get(i);
      //如果参数映射的模式为输出参数 或者 参数映射的模式为输入/输出参数
      if (parameterMapping.getMode() == ParameterMode.OUT || parameterMapping.getMode() == ParameterMode.INOUT) {
        //如果参数映射配置java类型是ResultSet
        if (ResultSet.class.equals(parameterMapping.getJavaType())) {
        //处理结果游标的输出参数，将结果对象集合赋值到参数对象对应的属性中
          handleRefCursorOutputParameter((ResultSet) cs.getObject(i + 1), parameterMapping, metaParam);
        } else {
          //获取类型处理器
          final TypeHandler typeHandler = parameterMapping.getTypeHandler();
          //通过typeHandler获取指定列位置的结果对象，然后赋值到参数对象对应的属性中
          metaParam.setValue(parameterMapping.getProperty(), typeHandler.getResult(cs, i + 1));
        }
      }
    }
  }

  /**
   * 处理结果游标的输出参数，将结果对象集合赋值到参数对象对应的属性中
   * @param rs 结果集
   * @param parameterMapping 对应于paramterMap的paramter标签参数映射封装类对象
   * @param metaParam 参数元对象
   */
  private void handleRefCursorOutputParameter(ResultSet rs, ParameterMapping parameterMapping, MetaObject metaParam) throws SQLException {
    //如果结果集为null
    if (rs == null) {
      return;
    }
    try {
      //获取参数映射配置的resultMap标签Id
      final String resultMapId = parameterMapping.getResultMapId();
      //获取resultMapId对应的ResultMap对象
      final ResultMap resultMap = configuration.getResultMap(resultMapId);
      //将rs进行包装
      final ResultSetWrapper rsw = new ResultSetWrapper(rs, configuration);
      //如果结果处理器为null
      if (this.resultHandler == null) {
        //默认ResultHandler，通过ObjectFactory去构建list来接收结果
        //构建一个默认结果处理器，里面就是通过objectFactory构建list对象,本质是一个list.
        final DefaultResultHandler resultHandler = new DefaultResultHandler(objectFactory);
        //处理结果集
        handleRowValues(rsw, resultMap, resultHandler, new RowBounds(), null);
        //将结果对象集合赋值到参数对象对应的属性中
        metaParam.setValue(parameterMapping.getProperty(), resultHandler.getResultList());
      } else {
        //处理结果集
        handleRowValues(rsw, resultMap, resultHandler, new RowBounds(), null);
      }
    } finally {
      // issue #228 (close resultsets) 关闭结果集,捕捉SQLException并不作任何处理
      closeResultSet(rs);
    }
  }

  //
  // HANDLE RESULT SETS
  //

  /**
   * 处理 {@code stmt} 中的所有结果集，返回结果对象集合
   * @param stmt SQL容器
   */
  @Override
  public List