public interface ResultSetHandler {
  // 處理結(jié)果集，返回結(jié)果列表
  <E> List<E> handleResultSets(Statement stmt) throws SQLException;

  // 處理游標(biāo)結(jié)果集，返回Cursor對象（用于流式處理）
  <E> Cursor<E> handleCursorResultSets(Statement stmt) throws SQLException;

  // 處理存儲過程的輸出參數(shù)
  void handleOutputParameters(CallableStatement cs) throws SQLException;
}

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

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

      // 獲取第一個結(jié)果集
      ResultSetWrapper rsw = getFirstResultSet(stmt);
      // 獲取MappedStatement中定義的結(jié)果集映射（可能有多個，對應(yīng)多結(jié)果集）
      List<ResultMap> resultMaps = mappedStatement.getResultMaps();
      int resultMapCount = resultMaps.size();
      validateResultMapsCount(rsw, resultMapCount);

      // 第一部分：處理 MappedStatement 中定義的 resultMaps 對應(yīng)的結(jié)果集
      while (rsw != null && resultSetCount < resultMaps.size()) {
        ResultMap resultMap = resultMaps.get(resultSetCount);
        // 處理當(dāng)前結(jié)果集，映射為Java對象
        handleResultSet(rsw, resultMap, multipleResults, null);
        // 獲取下一個結(jié)果集（用于存儲過程多結(jié)果集場景）
        rsw = getNextResultSet(stmt);
        cleanUpAfterHandlingResultSet();
        resultSetCount++;
      }

      // 第二部分：處理MappedStatement中resultSets指定的附加結(jié)果集（用于解決N+1）
      String[] resultSets = mappedStatement.getResultSets();
      if (resultSets != null) {
        while (rsw != null && resultSetCount < resultSets.length) {
          ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
          // 解決N+1，向父對象設(shè)置屬性。
          if (parentMapping != null) {
            String nestedResultMapId = parentMapping.getNestedResultMapId();
            ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
            handleResultSet(rsw, resultMap, multipleResults, parentMapping);
          }
          rsw = getNextResultSet(stmt);
          cleanUpAfterHandlingResultSet();
          resultSetCount++;
        }
      }

      // 合并結(jié)果（如果只有一個結(jié)果集，直接返回該列表）
      return collapseSingleResultList(multipleResults);
    }

private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
  try {
    if (parentMapping != null) {
      // 處理嵌套結(jié)果（就是上個步驟中的第二個循環(huán)）
      handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
    } else {
      if (resultHandler == null) {
        // 無自定義ResultHandler時，使用默認的DefaultResultHandler收集結(jié)果
        DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
        handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
        multipleResults.add(defaultResultHandler.getResultList());
      } else {
        // 有自定義ResultHandler時，使用其處理結(jié)果
        handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
      }
    }
  } finally {
    // 關(guān)閉結(jié)果集
    closeResultSet(rsw.getResultSet());
  }
}

    // 處理結(jié)果集中的行記錄
    public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
      if (resultMap.hasNestedResultMaps()) {
        // 處理嵌套結(jié)果映射（如包含association/collection）
        ensureNoRowBounds();
        checkResultHandler();
        handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
      } else {
        // 處理普通結(jié)果映射（無嵌套）
        handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
      }
    }

    // 處理普通結(jié)果映射（逐行映射）
    private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
      DefaultResultContext<Object> resultContext = new DefaultResultContext<>();
      // 跳過RowBounds指定的偏移量，內(nèi)存分頁
      skipRows(rsw.getResultSet(), rowBounds);
      // 循環(huán)處理每行記錄，直到達到RowBounds的限制或結(jié)果集結(jié)束
      while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
        // 解析鑒別器（discriminator），動態(tài)選擇ResultMap
        ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);
        // 將當(dāng)前行映射為Java對象
        Object rowValue = getRowValue(rsw, discriminatedResultMap);
        // 存儲對象（調(diào)用ResultHandler處理）
        storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
      }
    }

    // 將單行記錄映射為Java對象
    private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap) throws SQLException {
      final ResultLoaderMap lazyLoader = new ResultLoaderMap();
      // 創(chuàng)建結(jié)果對象（通過ObjectFactory）
      Object rowValue = createResultObject(rsw, resultMap, lazyLoader, null);
      if (rowValue != null && !typeHandlerRegistry.hasTypeHandler(rowValue.getClass())) {
        // 獲取結(jié)果對象的元信息（用于反射設(shè)置屬性）
        final MetaObject metaObject = configuration.newMetaObject(rowValue);
        boolean foundValues = this.useConstructorMappings;
        // 處理結(jié)果映射（ResultMapping），設(shè)置對象屬性
        if (shouldApplyAutomaticMappings(resultMap, false)) {
          // 自動映射（未在ResultMap中顯式配置的字段）
          foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, null) || foundValues;
        }
        // 顯式映射（ResultMap中配置的result/association/collection）
        foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, null) || foundValues;
        foundValues = lazyLoader.size() > 0 || foundValues;
        rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
      }
      return rowValue;
    }

private boolean applyAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, 
                                     MetaObject metaObject, String columnPrefix) throws SQLException {
  // 1. 創(chuàng)建自動映射列表：篩選出未顯式配置但存在匹配的字段
  List<UnMappedColumnAutoMapping> autoMappings = createAutomaticMappings(rsw, resultMap, metaObject, columnPrefix);
  if (autoMappings.isEmpty()) {
    return false;
  }

  boolean foundValues = false;
  // 2. 遍歷自動映射列表，逐個處理字段
  for (UnMappedColumnAutoMapping mapping : autoMappings) {
    // 2.1 通過 TypeHandler 從結(jié)果集獲取字段值（并轉(zhuǎn)換為 Java 類型）
    final Object value = mapping.typeHandler.getResult(rsw.getResultSet(), mapping.column);
    if (value != null) {
      foundValues = true;
    }
    // 2.2 通過 MetaObject 給對象屬性賦值（支持 null 值處理配置）
    if (value != null || configuration.isCallSettersOnNulls() && !mapping.primitive) {
      // 給屬性賦值（如 user.setName(value)）
      metaObject.setValue(mapping.property, value);
    }
  }
  return foundValues;
}