【源码解析】谈谈你对 MyBatis结果集映射和参数绑定的理解

曾经终败给现在 2023-10-09 13:31 10阅读 0赞

【文章较长，建议收藏】本文讲解MyBatis结果集映射源码解析，详细分析了 handleRowValuesForSimpleResultMap() 等方法实现映射的核心步骤  
Mybatis系列文章:  
[【深度好文】谈谈你对MyBatis的理解][MyBatis]：MyBatis整体架构  
[【源码解析】谈谈你对 MyBatis工作原理 的理解][MyBatis_] : MyBatis工作流程源码解析与MyBatis中的设计模式  
[【源码解析】谈谈你对 MyBatis动态SQL 的理解][MyBatis_SQL]：Mybatis动态sql源码解析及动态sql的执行原理

【总】MyBatis结果集映射是在MyBatis 解析 Mapper.xml 映射文件的过程中， <resultMap> 标签会被解析成 ResultMap 对象的，当 MyBatis 执行完一条 select 语句，**拿到 ResultSet 结果集之后，会将其交给关联的 ResultSetHandler 进行后续的映射处理**。ResultSetHandler 其中定义了三个方法，分别用来处理不同的查询返回值，**MyBatis 中只提供了一个 ResultSetHandler 接口实现，即 DefaultResultSetHandler。**

ResultSetHandler 接口以及 DefaultResultSetHandler 这个默认实现，其中单个结果集映射的入口在handleResultSets() 方法。handleRowValuesForSimpleResultMap() 方法实现简单映射的核心步骤，其中涉及预处理 ResultSet、查找并确定 ResultMap、创建并填充映射结果对象、自动映射、正常映射、存储映射结果对象这六大核心步骤。

public interface ResultSetHandler {
        // 将ResultSet映射成Java对象
        <E> List<E> handleResultSets(Statement stmt) throws SQLException;
        // 将ResultSet映射成游标对象
        <E> Cursor<E> handleCursorResultSets(Statement stmt) throws SQLException;
        // 处理存储过程的输出参数
        void handleOutputParameters(CallableStatement cs) throws SQLException;
    }

【分】MyBatis中ResultSet映射流程

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP5piO44Gu5a2m5Lmg5b-D5b6X_size_18_color_FFFFFF_t_70_g_se_x_16][]

**一、结果集处理入口**

DefaultResultSetHandler实现 **handleResultSets()** 方法，支持一个或多个ResultSet的处理。org.apache.ibatis.executor.resultset.DefaultResultSetHandler\#handleResultSets。

遍历多结果集时使用到的 getFirstResultSet() 方法和 getNextResultSet() 方法，这两个方法底层都是检测是否存在后续的 ResultSet 对象，检测成功之后，会通过 getResultSet() 方法获取下一个 ResultSet 对象。**这里获取到的 ResultSet 对象，会被包装成 ResultSetWrapper 对象返回。**

ResultSetWrapper 主要用于封装 ResultSet 的一些元数据，其中记录了 ResultSet 中每列的名称、对应的 Java 类型、JdbcType 类型以及每列对应的 **TypeHandler**。ResultSetWrapper 可以将底层 ResultSet 的列与一个 ResultMap 映射的列进行交集，得到参与映射的列和未被映射的列，分别记录到 mappedColumnNamesMap 集合和 unMappedColumnNamesMap 集合中。这两个集合都是 Map`<String, List<String>>` 类型，其中最外层的 Key 是 ResultMap 的 id，Value 分别是参与映射的列名集合和未被映射的列名集合。

public List<Object> handleResultSets(Statement stmt) throws SQLException {
            // 用于记录每个ResultSet映射出来的Java对象
            final List<Object> multipleResults = new ArrayList<>();
            int resultSetCount = 0;
    
            // 从Statement中获取第一个ResultSet，其中对不同的数据库有兼容处理逻辑,
            // 这里拿到的ResultSet会被封装成ResultSetWrapper对象返回
            ResultSetWrapper rsw = getFirstResultSet(stmt);
    
            // 获取这条SQL语句关联的全部ResultMap规则。如果一条SQL语句能够产生多个ResultSet，
            // 那么在编写Mapper.xml映射文件的时候，我们可以在SQL标签的resultMap属性中配置多个
            // <resultMap>标签的id，它们之间通过","分隔，实现对多个结果集的映射
            List<ResultMap> resultMaps = mappedStatement.getResultMaps();
    
            int resultMapCount = resultMaps.size();
            validateResultMapsCount(rsw, resultMapCount);
            while (rsw != null && resultMapCount > resultSetCount) { // 遍历ResultMap集合
                ResultMap resultMap = resultMaps.get(resultSetCount);
    
                // 根据ResultMap中定义的映射规则处理ResultSet，并将映射得到的Java对象添加到
                // multipleResults集合中保存
                handleResultSet(rsw, resultMap, multipleResults, null);
    
                // 获取下一个ResultSet
                rsw = getNextResultSet(stmt);
    
                // 清理nestedResultObjects集合，这个集合是用来存储中间数据的
                cleanUpAfterHandlingResultSet();
                resultSetCount++; // 递增ResultSet编号
            }
            // 下面这段逻辑是根据ResultSet的名称处理嵌套映射，你可以暂时不关注这段代码，
            // 嵌套映射会在后面详细介绍
            ... 
            // 返回全部映射得到的Java对象
            return collapseSingleResultList(multipleResults);
        }

二、简单映射

handleResultSet() 方法，其中会根据第四个参数，也就是 parentMapping，判断当前要处理的 ResultSet 是嵌套映射，还是外层映射。**都会依赖 handleRowValues() 方法完成结果集的处理**（通过方法名也可以看出，handleRowValues() 方法是处理多行记录的，也就是一个结果集）。

至于 handleRowValues() 方法，其中会通过 handleRowValuesForNestedResultMap() 方法处理包含嵌套映射的 ResultMap，通过 handleRowValuesForSimpleResultMap() 方法处理不包含嵌套映射的简单 ResultMap，如下所示：

public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
            if (resultMap.hasNestedResultMaps()) { // 判断是否包含嵌套映射的处理流程
                ensureNoRowBounds();
                checkResultHandler();
                handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
            } else { // 简单映射的处理
                handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
            }
        }

**handleRowValuesForSimpleResultMap()** 方法如何映射一个 ResultSet 的，该方法的核心步骤可总结为如下。

private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
                throws SQLException {
            DefaultResultContext<Object> resultContext = new DefaultResultContext<Object>();
            // 1.执行 skipRows() 方法跳过多余的记录，定位到指定的行。
            skipRows(rsw.getResultSet(), rowBounds);
            // 2.通过 shouldProcessMoreRows() 方法，检测是否还有需要映射的数据记录。
            while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
                // 3.如果存在需要映射的记录，则先通过 resolveDiscriminatedResultMap() 方法处理映射中用到的 Discriminator，决定此次映射实际使用的 ResultMap。
                ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);
                // 4.通过 getRowValue() 方法对 ResultSet 中的一行记录进行映射，映射规则使用的就是步骤 3 中确定的 ResultMap。
                Object rowValue = getRowValue(rsw, discriminatedResultMap);
                // 5.执行 storeObject() 方法记录步骤 4 中返回的、映射好的 Java 对象。
                storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
            }
        }

**handleRowValuesForSimpleResultMap()** 方法如何映射一个 ResultSet 总结下来：**第一步1.** ResultSet 的预处理（）；**第二步**2. 确定 ResultMap，**通过 resolveDiscriminatedResultMap() 方法处理 `<discriminator>` 标签，确定此次映射操作最终使用的 ResultMap 对象**；**第三步**3. 创建映射结果对象，经过 resolveDiscriminatedResultMap() 方法解析，我们最终确定了当前记录使用哪个 ResultMap 进行映射。接下来**按照 ResultMap 规则进行各个列的映射，得到最终的 Java 对象**，这部分逻辑是在下面要介绍的 getRowValue() 方法完成的，其核心步骤如下：

private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, String columnPrefix) throws SQLException {
            final ResultLoaderMap lazyLoader = new ResultLoaderMap();
            // 根据ResultMap的type属性值创建映射的结果对象
            Object rowValue = createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
            if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
                final MetaObject metaObject = configuration.newMetaObject(rowValue);
                boolean foundValues = this.useConstructorMappings;
                // 根据ResultMap的配置以及全局信息，决定是否自动映射ResultMap中未明确映射的列
                if (shouldApplyAutomaticMappings(resultMap, false)) {
                    foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
                }
                // *根据ResultMap映射规则，将ResultSet中的列值与结果对象中的属性值进行映射*
                foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
                // 如果没有映射任何属性，需要根据全局配置决定如何返回这个结果值，
                // 这里不同场景和配置，可能返回完整的结果对象、空结果对象或是null
                foundValues = lazyLoader.size() > 0 || foundValues;
                rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
            }
            return rowValue;
        }

**由于我们重点分析的是简单 ResultSet 的映射流程，所以接下来我们重点看 createResultObject() 重载方法是如何创建映射结果对象的。**

private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, ResultLoaderMap lazyLoader, String columnPrefix) throws SQLException {
            this.useConstructorMappings = false; // reset previous mapping result
            final List<Class<?>> constructorArgTypes = new ArrayList<Class<?>>();
            final List<Object> constructorArgs = new ArrayList<Object>();
            Object resultObject = createResultObject(rsw, resultMap, constructorArgTypes, constructorArgs, columnPrefix);
            // 如果该信息不为空，则可以确定结果类型中的唯一构造函数。
            if (resultObject != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
                final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
                for (ResultMapping propertyMapping : propertyMappings) {
                    // issue gcode #109 && issue #149
                    if (propertyMapping.getNestedQueryId() != null && propertyMapping.isLazy()) {
                        resultObject = configuration.getProxyFactory().createProxy(resultObject, lazyLoader, configuration, objectFactory, constructorArgTypes, constructorArgs);
                        break;
                    }
                }
            }
            this.useConstructorMappings = (resultObject != null && !constructorArgTypes.isEmpty()); // set current mapping result
            return resultObject;
        }
    
        private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, List<Class<?>> constructorArgTypes, List<Object> constructorArgs, String columnPrefix)
                throws SQLException {
            final Class<?> resultType = resultMap.getType();
            // 获取 ResultMap 中 type 属性指定的结果对象的类型，并创建该类型对应的 MetaClass 对
            final MetaClass metaType = MetaClass.forClass(resultType, reflectorFactory);
            // 获取 ResultMap 中配置的 <constructor> 标签信息（也就是对应的 ResultMapping 对象集合）
            final List<ResultMapping> constructorMappings = resultMap.getConstructorResultMappings();
            // 根据四种不同的场景，使用不同的方式创建结果对象
            if (hasTypeHandlerForResultObject(rsw, resultType)) {
                // 场景一，ResultSet 中只有一列，并且能够找到一个 TypeHandler 完成该列到目标结果类型的映射，此时可以直接读取 ResultSet 中的列值并通过 TypeHandler 转换得到结果对象。
                // 这部分逻辑是在 createPrimitiveResultObject() 方法中实现的，该场景多用于 Java 原始类型的处理。
                return createPrimitiveResultObject(rsw, resultMap, columnPrefix);
            } else if (!constructorMappings.isEmpty()) {
                // 场景二，如果 ResultMap 中配置了 <constructor> 标签，就会先解析 <constructor> 标签中指定的构造方法参数的类型，并从待映射的数据行中获取对应的实参值，然后通过反射方式调用对应的构造方法来创建结果对象。
                // 这部分逻辑在 createParameterizedResultObject() 方法中实现。
                return createParameterizedResultObject(rsw, resultType, constructorMappings, constructorArgTypes, constructorArgs, columnPrefix);
            } else if (resultType.isInterface() || metaType.hasDefaultConstructor()) {
                // 场景三，如果不满足上述两个场景，则尝试查找默认构造方法来创建结果对象，这里使用前面介绍的 ObjectFactory.create() 方法实现，底层原理还是 Java 的反射机制。
                return objectFactory.create(resultType);
            } else if (shouldApplyAutomaticMappings(resultMap, false)) {
                // 场景四，最后会检测是否已经开启了自动映射功能，如果开启了，会尝试查找合适的构造方法创建结果对象。这里首先会查找 @AutomapConstructor 注解标注的构造方法，查找失败之后，则会尝试查找每个参数都有 TypeHandler 能与 ResultSet 列进行映射的构造方法，确定要使用的构造方法之后，也是通过 ObjectFactory 完成对象创建的。
                // 这部分逻辑在 createByConstructorSignature() 方法中实现。
                return createByConstructorSignature(rsw, resultType, constructorArgTypes, constructorArgs, columnPrefix);
            }
            throw new ExecutorException("Do not know how to create an instance of " + resultType);
        }

**第四步**4. 自动映射，创建完结果对象之后，下面就可以开始映射各个字段了。在简单映射流程中，会先通过 shouldApplyAutomaticMappings() 方法**检测是否开启了自动映射**，主要检测以下两个地方。当确定当前 ResultMap 需要进行自动映射的时候，会通过 applyAutomaticMappings() 方法进行自动映射。

private boolean applyAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, String columnPrefix) throws SQLException {
            // 创建 UnMappedColumnAutoMapping 对象将该列与对应的属性进行关联。在 UnMappedColumnAutoMapping 中记录了列名、属性名以及相关的 TypeHandler。
            List<UnMappedColumnAutoMapping> autoMapping = createAutomaticMappings(rsw, resultMap, metaObject, columnPrefix);
            boolean foundValues = false;
            if (!autoMapping.isEmpty()) {
                // 遍历上面得到 UnMappedColumnAutoMapping 集合，通过其中的 TypeHandler 读取列值并转换成相应的 Java 类型，再通过 MetaObject 设置到相应属性中。
                for (UnMappedColumnAutoMapping mapping : autoMapping) {
                    final Object value = mapping.typeHandler.getResult(rsw.getResultSet(), mapping.column);
                    if (value != null) {
                        foundValues = true;
                    }
                    if (value != null || (configuration.isCallSettersOnNulls() && !mapping.primitive)) {
                        // gcode issue #377, call setter on nulls (value is not 'found')
                        metaObject.setValue(mapping.property, value);
                    }
                }
            }
            return foundValues;
        }

**第五步**5. 正常映射 完成自动映射之后，MyBatis 会执行 applyPropertyMappings() 方法处理 ResultMap 中明确要映射的列。在 getPropertyMappingValue() 方法中，主要处理了三种场景的映射，第一种是基本类型的映射，这种场景直接可以通过 TypeHandler 从 ResultSet 中读取列值，并在转化之后返回；第二种和第三种场景分别是嵌套映射和多结果集的映射

private boolean applyPropertyMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, ResultLoaderMap lazyLoader, String columnPrefix)
                throws SQLException {
            final List<String> mappedColumnNames = rsw.getMappedColumnNames(resultMap, columnPrefix);
            boolean foundValues = false;
            // 首先从 ResultSetWrapper 中明确需要映射的列名集合，以及 ResultMap 中定义的 ResultMapping 对象集合。
            final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
            // 遍历全部 ResultMapping 集合，针对每个 ResultMapping 对象为 column 属性值添加指定的前缀，得到最终的列名，然后执行 getPropertyMappingValue() 方法完成映射，得到对应的属性值。
            for (ResultMapping propertyMapping : propertyMappings) {
                String column = prependPrefix(propertyMapping.getColumn(), columnPrefix);
                if (propertyMapping.getNestedResultMapId() != null) {
                    // the user added a column attribute to a nested result map, ignore it
                    column = null;
                }
                // 如果成功获取到了属性值，则通过结果对象关联的 MetaObject 对象设置到对应属性中。
                if (propertyMapping.isCompositeResult()
                        || (column != null && mappedColumnNames.contains(column.toUpperCase(Locale.ENGLISH)))
                        || propertyMapping.getResultSet() != null) {
                    // 主要处理了三种场景的映射
                    // 第一种是基本类型的映射，这种场景直接可以通过 TypeHandler 从 ResultSet 中读取列值，并在转化之后返回；
                    // 第二种是嵌套映射
                    // 第三种多结果集的映射
                    Object value = getPropertyMappingValue(rsw.getResultSet(), metaObject, propertyMapping, lazyLoader, columnPrefix);
                    // issue #541 make property optional
                    final String property = propertyMapping.getProperty();
                    if (property == null) {
                        continue;
                    } else if (value == DEFERED) {
                        foundValues = true;
                        continue;
                    }
                    if (value != null) {
                        foundValues = true;
                    }
                    if (value != null || (configuration.isCallSettersOnNulls() && !metaObject.getSetterType(property).isPrimitive())) {
                        // gcode issue #377, call setter on nulls (value is not 'found')
                        metaObject.setValue(property, value);
                    }
                }
            }
            return foundValues;
        }

**第六步**6. 存储对象，通过上述 5 个步骤，我们已经完成简单映射的处理，得到了一个完整的结果对象。接下来，我们就要**通过 storeObject() 方法把这个结果对象保存到合适的位置**。如果是一个嵌套映射中的子映射，那么我们就需要将结果对象保存到外层对象的属性中；如果是一个普通映射或是外层映射的结果对象，那么我们就需要将结果对象保存到 ResultHandler 中。

private void storeObject(ResultHandler<?> resultHandler, DefaultResultContext<Object> resultContext, Object rowValue, ResultMapping parentMapping, ResultSet rs) throws SQLException {
            if (parentMapping != null) {
                // 嵌套查询或嵌套映射的场景，此时需要将结果对象保存到外层对象对应的属性中
                linkToParents(rs, parentMapping, rowValue);
            } else {
                // 普通映射(没有嵌套映射)或是嵌套映射中的外层映射的场景，此时需要将结果对象保存到ResultHandler中
                callResultHandler(resultHandler, resultContext, rowValue);
            }
        }

**总结：**这一讲我们重点介绍了结果集映射，首先我们介绍了 ResultSetHandler 接口以及 DefaultResultSetHandler 这个默认实现，并讲解了单个结果集映射的入口：handleResultSet() 方法。详细分析了 handleRowValuesForSimpleResultMap() 方法实现映射的核心步骤，其中涉及预处理 ResultSet、查找并确定 ResultMap、创建并填充映射结果对象、自动映射、正常映射、存储映射结果对象这六大核心步骤。

[MyBatis]: https://blog.csdn.net/FMC_WBL/article/details/120470699
[MyBatis_]: https://blog.csdn.net/FMC_WBL/article/details/120477242
[MyBatis_SQL]: https://blog.csdn.net/FMC_WBL/article/details/120476703
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5bCP5piO44Gu5a2m5Lmg5b-D5b6X_size_18_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/593a46c7ab2647249a118b139bf04779.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5bCP5piO44Gu5a2m5Lmg5b-D5b6X,size_18,color_FFFFFF,t_70,g_se,x_16