Mybatis源码分析(四大对象-ResultSetHandler结果集映射)

最新推荐文章于 2024-06-18 10:11:51 发布

smart哥

最新推荐文章于 2024-06-18 10:11:51 发布

阅读量851

点赞数 21

分类专栏： mybatis专题文章标签： mybatis

本文链接：https://blog.csdn.net/smart_an/article/details/138546876

版权

mybatis专题专栏收录该内容

44 篇文章 1 订阅

订阅专栏

作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬

学习必须往深处挖，挖的越深，基础越扎实！

阶段1、深入多线程

 阶段2、深入多线程设计模式

 阶段3、深入juc源码解析

阶段4、深入jdk其余源码解析

阶段5、深入jvm源码解析

码哥源码部分

码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场景题】

码哥讲源码【炸雷啦！炸雷啦！黄光头他终于跑路啦！】

码哥讲源码-【jvm课程前置知识及c/c++调试环境搭建】

码哥讲源码-原理源码篇【揭秘join方法的唤醒本质上决定于jvm的底层析构函数】

码哥源码-原理源码篇【Doug Lea为什么要将成员变量赋值给局部变量后再操作？】

码哥讲源码【你水不是你的错,但是你胡说八道就是你不对了！】

码哥讲源码【谁再说Spring不支持多线程事务，你给我抽他！】

终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！

打脸系列【020-3小时讲解MESI协议和volatile之间的关系，那些将x86下的验证结果当作最终结果的水货们请闭嘴】

四大对象-ResultSetHandler(结果集映射)

一、ResultSetHandler

ResultSetHandler在Mybatis四大对象中负责将数据库结果集转换为Java对象集合。它是一个接口，有且只有一个实现类DefaultResultSetHandler。

    public interface ResultSetHandler {
        /**
         * 将ResultSet映射成对应Java类集合
         */
        <E> List<E> handleResultSets(Statement stmt) throws SQLException;
    
        /**
         * 将ResultSet处理成Cursor对象
         */
        <E> Cursor<E> handleCursorResultSets(Statement stmt) throws SQLException;
    
        /**
         * 存储过程的处理
         */
        void handleOutputParameters(CallableStatement cs) throws SQLException;
    }

handleResultSets是处理数据库结果集最核心的方法。

二、DefaultResultSetHandler

DefaultResultSetHandler是ResultSetHandler结果的唯一实现类，结果集的处理基本是都在ResultSetHandler里面。我们通过ResultSetHandler来看看结果集的处理流程，因为处理过程中的细节非常多，需要考虑各种配置，嵌套之类的，因此我们梳理流程旨在弄清楚整个主流程，不会过于解析每一行代码。

2.1 DefaultResultSetHandler#handleResultSets

handleResultSets方法将ResultSet结果集转换为对应的Java类对象集合，在在StatementHandler里面的query方法会调用该方法。

    /**
       * 处理结果集的方法，在StatementHandler里面的query方法会调用该方法
       * PS：该方法可以处理Statement，PreparedStatement和存储过程的CallableStatement返回的结果集。而CallableStatement是支持返回多结
       * 果集的，普通查询一般是单个结果集
       * */
      @Override
      public List<Object> handleResultSets(Statement stmt) throws SQLException {
        ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
    
        //1.保存结果集对象。普通的查询，实际就一个ResultSet，也就是说，multipleResults最多就一个元素。在多ResultSet的
        //结果集合一般在存储过程出现，此时每个ResultSet对应一个Object对象，每个Object是 List<Object>对象。
        final List<Object> multipleResults = new ArrayList<Object>();
    
        int resultSetCount = 0;
        //2.Statement可能返回多个结果集对象，先处理第一个结果集，封装成ResultSetWrapper对象
        ResultSetWrapper rsw = getFirstResultSet(stmt);
        //3.将结果集转换需要知道转换规则，而记录和JavaBean的转换规则都在resultMap里面，这里获取resultMap，注意获取
        //的是全部的resultMap，是一个list，但是对于普通查询，resultMaps只有一个元素(普通查询一个响应只有一个ResultSet，存储过程可能有多个)
        List<ResultMap> resultMaps = mappedStatement.getResultMaps();
        int resultMapCount = resultMaps.size();
        //4.结果集和转换规则均不能为空，否则抛异常
        validateResultMapsCount(rsw, resultMapCount);
        //5.一个一个处理（普通查询其实就处理一次）
        while (rsw != null && resultMapCount > resultSetCount) {
          //6.获取当前结果集对应的resultMap(注意前面是全部的resultMap，这里是获取到自己需要的，普通查询就是获取一个，一般也就只有一个)
          ResultMap resultMap = resultMaps.get(resultSetCount);
          //7.根据规则(resultMap)处理 ResultSet，将结果集转换为Object列表,并保存到multipleResults
          //这是获取结果集的最核心的方法步骤
          handleResultSet(rsw, resultMap, multipleResults, null);
          //8.获取下一个结果集
          rsw = getNextResultSet(stmt);
          //9.清空nestedResultObjects对象
          cleanUpAfterHandlingResultSet();
          resultSetCount++;
        }
    
        //10.获取多结果集。一般出现在存储过程中，不分析了...
        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++;
          }
        }
        //11.如果是multipleResults只有一个元素，则取首元素返回(collapseSingleResultList中会判断如果只有一个元素就获取并返回)
        return collapseSingleResultList(multipleResults);
      }

核心流程

    1.mappedStatement.getResultMaps(); //获取ResultMap
    2.handleResultSet(rsw, resultMap, multipleResults, null);//根据规则(resultMap)处理 ResultSet，将结果集转换为Object列表
    3.return collapseSingleResultList(multipleResults);//返回结果集
    
    PS：后面重点解析第二步handleResultSet里面的细节。

2.2 DefaultResultSetHandler#handleResultSet

handleResultSet根据规则(resultMap)处理 ResultSet，将结果集转换为Object列表,并保存到multipleResults

    /**
       * 根据规则(resultMap)处理 ResultSet，将结果集转换为Object列表,并保存到multipleResults
       *
       * */
      private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
        try {
            //1.非存储过程的情况，parentMapping为null。handleResultSets方法的第一个while循环传参就是null
          if (parentMapping != null) {
            handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
          } else {
            //1.2如果没有自定义的resultHandler，则使用默认的DefaultResultHandler对象
            if (resultHandler == null) {
              //1.3创建DefaultResultHandler对象
              DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
              //1.4(核心方法)处理ResultSet返回的每一行Row，里面会循环处理全部的结果集
              handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
              //1.5将defaultResultHandler的处理结果，添加到multipleResults中
              multipleResults.add(defaultResultHandler.getResultList());
            } else {
              //1.6 和1.4一样，处理每一行,里面会循环处理全部的结果集
              handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
            }
          }
        } finally {
          // issue #228 (close resultsets)
          //关闭ResultSet对象
          closeResultSet(rsw.getResultSet());
        }
      }

核心流程

    1.handleRowValues //处理结果集 
    2.multipleResults.add //添加结果集到对应集合
    PS：这一步主要是做一些逻辑的判断，主要处理是在handleRowValues方法里面

2.3 DefaultResultSetHandler#handleRowValues

    public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
          //1.处理嵌套映射的情况
        if (resultMap.hasNestedResultMaps()) {
          //1.1 校验RowBounds
          ensureNoRowBounds();
          //1.2 校验自定义resultHandler
          checkResultHandler();
          //1.3 处理嵌套映射的结果集
          handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
        } else {
          //2.简单映射的情况
          handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
        }
      }

核心流程

    1.handleRowValuesForNestedResultMap //处理嵌套映射
    2.handleRowValuesForSimpleResultMap //处理简单映射
    PS：这一步做一些简单的判断，分两种情况处理

2.4 DefaultResultSetHandler#handleRowValuesForSimpleResultMap

    /**
       *  简单ResultMap映射的情况下处理结果行
       * */
      private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
          throws SQLException {
        //1.创建DefaultResultContext
        DefaultResultContext<Object> resultContext = new DefaultResultContext<Object>();
        //2.获得ResultSet对象，并跳到 rowBounds 指定的开始位置
        skipRows(rsw.getResultSet(), rowBounds);
        //3.循环处理结果集(shouldProcessMoreRows校验context是否已经关闭和是否达到limit，rsw获取下一条记录)
        while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
          //4.根据该行记录和ResultMap.discriminator ，决定映射使用的 ResultMap 对象
          ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);
          //5.根据确定的ResultMap将ResultSet中的该行记录映射为Java对象(处理一行)
          Object rowValue = getRowValue(rsw, discriminatedResultMap);
          //6.将映射得到的Java对象添加到ResultHandler.resultList中
          storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
        }
      }

核心流程

    1.skipRows //定位到正确位置
    2.shouldProcessMoreRows //校验，并判断是否超过limit限制
    3.resolveDiscriminatedResultMap //处理鉴别器信息
    3.getRowValue //将一行记录转换为一个Java对象
    4.storeObject //将转化得到的Java对象保存
    
    PS：这一步做了更细节的处理，到了将数据库记录转换为Java对象的部分了。注意这里会循环处理，并且会处理分页的信息。getRowValue是获取记录的核心方法

2.5 DefaultResultSetHandler#getRowValue()

    /**
         * 根据确定的ResultMap将ResultSet中的记录映射为Java对象(处理一行)
         * */
      private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap) throws SQLException {
        //创建ResultLoaderMap，和懒加载相关
        final ResultLoaderMap lazyLoader = new ResultLoaderMap();
        //1.创建结果对象
        Object resultObject = createResultObject(rsw, resultMap, lazyLoader, null);
        //2.如果hasTypeHandlerForResultObject(rsw, resultMap.getType())返回 true ，意味着rowValue是基本类型，无需执行下列逻辑。
        if (resultObject != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
          //3.创建MetaObject对象，用于访问rowValue对象
          final MetaObject metaObject = configuration.newMetaObject(resultObject);
          //4.foundValues代表，是否成功映射任一属性。若成功，则为true ，若失败，则为false
          boolean foundValues = !resultMap.getConstructorResultMappings().isEmpty();
          //5.判断是否开启自动映射功能
          if (shouldApplyAutomaticMappings(resultMap, false)) {
            //6.自动映射未明确的列
            foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, null) || foundValues;
          }
          //7.映射ResultMap中明确映射的列,至此，ResultSet的该行记录的数据已经完全映射到结果对象resultObject的对应属性中
          foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, null) || foundValues;
          foundValues = lazyLoader.size() > 0 || foundValues;
          //8.如果映射属性失败，则置空 resultObject 对象。
          resultObject = foundValues ? resultObject : null;
          return resultObject;
        }
        return resultObject;
      }

核心流程

    1.createResultObject //根据映射规则(resultMap的type信息)创建Java对象
    2.shouldApplyAutomaticMappings->applyAutomaticMappings //如果使用了自动映射，那么就会处理未明确映射关系的属性 
    3.applyPropertyMappings //处理映射关系明确的属性
    4.映射失败则会把结果置为null
    
    PS：getRowValue方法是处理一行记录，再前面的handleRowValuesForSimpleResultMap中会循环调用该方法。getRowValue方法内部会处理映射明确和不明确的列，不明确的列只有在开启了自动映射的情况才会处理，如果存在映射失败，就会将结果置为null，避免错误。

2.6 DefaultResultSetHandler#applyAutomaticMappings

我们看一看DefaultResultSetHandler#applyAutomaticMappings中处理未明确映射关系的列是怎么处理的，对于明确关系的列也比较类似。

    /**
       * 自动映射未明确的列
       * */
      private boolean applyAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, String columnPrefix) throws SQLException {
          //1.获得UnMappedColumnAutoMapping数组
        List<UnMappedColumnAutoMapping> autoMapping = createAutomaticMappings(rsw, resultMap, metaObject, columnPrefix);
        boolean foundValues = false;
        if (autoMapping.size() > 0) {
        //2.遍历UnMappedColumnAutoMapping数组
          for (UnMappedColumnAutoMapping mapping : autoMapping) {
              //3.获得指定字段的值
            final Object value = mapping.typeHandler.getResult(rsw.getResultSet(), mapping.column);
              //4.若非空，标记foundValues有值
            if (value != null) {
              foundValues = true;
            }
            //5.通过metaObject设置到parameterObject中，
            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;
      }

核心流程

    1.首先会在一个集合里面讲未明确映射的列保存起来，先将他获取出来。
    2.然后从数据库记录中，根据列的名称获取到列对应的Value
    3.通过反射模块提供的metaObject设值到parameterObject中。注意metaObject是Mybatis反射模块以及封装好的相关类，给属性设值提供简单的使用方式
    PS：未明确映射关系的列处理方法就是把属性名当做列名，去数据库记录中获取值，获取到之后通过反射设置到结果对象(有映射关系那么就是通过映射列名去获取值了)。

三、辅助类

3.1 ResultSetWrapper

ResultSetWrapper内部包装了ResultSet，提供了一些相关的操作，这些操作会在DefaultResultSetHandler中被使用到。在前面的DefaultResultSetHandler#applyAutomaticMappings中我们看到是通过
ResultSetWrapper变量rsw.getResultSet()来获得指定字段的值。其实ResultSetWrapper可以理解为对原始的结果集进行了包装。在DefaultResultSetHandler#handleResultSets中：

    ResultSetWrapper rsw = getFirstResultSet(stmt);

通过Statement获取结果集并封装成ResultSetWrapper对象，ResultSetWrapper对象实际上就包含了一次访问数据库得到的全部结果，并且封装了相关属性，便于ResultSetHandler中进行处理。

3.2 DefaultResultSetHandler#getFirstResultSet

    /**
       * 从Statement获取第一个ResultSet结果集对象，封装成ResultSetWrapper对象
       * */
      private ResultSetWrapper getFirstResultSet(Statement stmt) throws SQLException {
        //1.获取ResultSet
        ResultSet rs = stmt.getResultSet();
        while (rs == null) {
          // move forward to get the first resultset in case the driver
          // doesn't return the resultset as the first result (HSQLDB 2.1)
          //2.true代表有ResultSet ，false代表没有ResultSet或者是一个更新的结果
          if (stmt.getMoreResults()) {
            //2.1有就获取ResultSet
            rs = stmt.getResultSet();
          } else {
            //2.2没有就break
            if (stmt.getUpdateCount() == -1) {
              // no more results. Must be no resultset
              break;
            }
          }
        }
        //3.返回包装后的ResultSetWrapper
        return rs != null ? new ResultSetWrapper(rs, configuration) : null;
      }

核心流程

    1. 获取ResultSet
    2. 将ResultSet和Configuration配置对象封装到ResultSetWrapper对象中去，后续ResultSetHandler操作结果集实际上是操作ResultSetWrapper。

四、小结

本文给出了ResultSetHandler处理数据库结果集的大体流程，并未细致的分析每一行代码，有兴趣可以自行研究，在掌握了主要的流程之后，在使用的时候遇到问题我们也能够有思路去应对。
下面是前面代码的一个简单流程图展示：

smart哥

关注

21
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
Mybatis源码分析(四大对象-ResultSetHandler结果集映射)

作者简介：大家好，我是哥，前中兴通讯、美团架构师，现某互联网公司联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！
复制链接

扫一扫

专栏目录