MyBatis原理（2）-执行流程 3 处理结果集

DefaultResultSetHandler#handleResultSets 处理结果集

@Override
  public List<Object> handleResultSets(Statement stmt) throws SQLException {
    ErrorContext.instance().activity("handling results").object(mappedStatement.getId());

    final List<Object> multipleResults = new ArrayList<Object>();

    int resultSetCount = 0;
   //获取第一个结果集，屏蔽数据库驱动造成的不同，
  //ResultSetWrapper是对ResultSet元数据的封装
    ResultSetWrapper rsw = getFirstResultSet(stmt);
   //获取返回类型-resultType会被转换为Inline的ResultMap（id变为namespace+“Inline” see MapperBuilderAssistant#getStatementResultMaps）
    List<ResultMap> resultMaps = mappedStatement.getResultMaps();
    int resultMapCount = resultMaps.size();
  //如果结果集不为空，resultMapCount<1抛出异常
    validateResultMapsCount(rsw, resultMapCount);
   //循环处理结果集
    while (rsw != null && resultMapCount > resultSetCount) {
      //取出当前映射关系
      ResultMap resultMap = resultMaps.get(resultSetCount);
     // 处理当前结果集
      handleResultSet(rsw, resultMap, multipleResults, null);
    //设置下一个结果集,如果支撑的话
      rsw = getNextResultSet(stmt);
      cleanUpAfterHandlingResultSet();
      resultSetCount++;
    }

    String[] resultSets = mappedStatement.getResultSets();
    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);
  }
//处理当前结果集
private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
    try {
      if (parentMapping != null) {
        handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
      } else {
        if (resultHandler == null) {
           //结果处理器为空resultHandler从构造Executor传入
          //构造默认的结果处理器，使用objectFactory创建结果集
          DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
          //处理当前ResultMap中每一行 
          handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
          multipleResults.add(defaultResultHandler.getResultList());
        } else {
          handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
        }
      }
    } finally {
      //
      // issue #228 (close resultsets)
      closeResultSet(rsw.getResultSet());
    }
  }

  public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
   //如果有嵌套的（子句中包含select属性）
    if (resultMap.hasNestedResultMaps()) {
     //确保字句中没有分页
      ensureNoRowBounds();
    //确保子句中没有ResultHandler
      checkResultHandler();
    //处理嵌套的ResultMap
      handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    } else {
      handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    }
  }

 private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
      throws SQLException {
    //初始化结果上下文--用于存储当前返回对象和结果条数，实际上就是一个计数器
    DefaultResultContext<Object> resultContext = new DefaultResultContext<Object>();
    //跳过指定偏移量---分页
    skipRows(rsw.getResultSet(), rowBounds);
    //context中结果条数小于rowBounds的limit获取结果集下一个
    while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
     //首先循环处理嵌套鉴别器，将解析后的最后一个resultMap作为当前resultMap，无鉴别器则返回当前resultMap
      ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);
       //获取当前行的值
      Object rowValue = getRowValue(rsw, discriminatedResultMap);
      //如过parentMapping不为空，将rowvalue设置给parent，否则回调自己的ResultHandler
      storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
    }
  }

 private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap) throws SQLException {
     //ResultLoaderMap存储了LoadPair的hashMap，对应一个对象，每一个LoadPair则对应
   //对象的每一个属性和其延迟加载器 ResultLoader，ResultLoader封装了executor，parameterObject，objectFactory，cacheKey等必要的一切属性用来再次执行sql（包括当前线程和其他线程）
    final ResultLoaderMap lazyLoader = new ResultLoaderMap();
  //初始化返回对象，如过有嵌套查询则创建lazyLoader的代理对象，并返回
    Object rowValue = createResultObject(rsw, resultMap, lazyLoader, null);
    // 给rowvalue设置值
    if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
      final MetaObject metaObject = configuration.newMetaObject(rowValue);
      boolean foundValues = this.useConstructorMappings;
      if (shouldApplyAutomaticMappings(resultMap, false)) {
        foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, null) || foundValues;
      }
      foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, null) || foundValues;
      foundValues = lazyLoader.size() > 0 || foundValues;
      rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
    }
    return rowValue;
  }