mybatis中ResultSetHandler的设计与实现

最新推荐文章于 2024-07-08 18:09:40 发布
最新推荐文章于 2024-07-08 18:09:40 发布
阅读量1.3k 收藏
点赞数
分类专栏： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiexingshishu/article/details/108742901
版权

ResultSetHandler主要处理statement,cursor,callstatement三种类型的结果集，其接口定义如下：

public interface ResultSetHandler {

  <E> List<E> handleResultSets(Statement stmt) throws SQLException;

  <E> Cursor<E> handleCursorResultSets(Statement stmt) throws SQLException;

  void handleOutputParameters(CallableStatement cs) throws SQLException;

}

在介绍ResultSetHandler之前，先看下与ResultSet相关的一个类，ResultSetWrapper,其包含的成员有ResultSet,列名，及对应的jdbcType和javaType,其根据ResultMap的定义及结果集，得到映射和没有映射的列名集合

public List<String> getMappedColumnNames(ResultMap resultMap, String columnPrefix) throws SQLException {
    List<String> mappedColumnNames = mappedColumnNamesMap.get(getMapKey(resultMap, columnPrefix));
    if (mappedColumnNames == null) {
      loadMappedAndUnmappedColumnNames(resultMap, columnPrefix);
      mappedColumnNames = mappedColumnNamesMap.get(getMapKey(resultMap, columnPrefix));
    }
    return mappedColumnNames;
  }

private void loadMappedAndUnmappedColumnNames(ResultMap resultMap, String columnPrefix) throws SQLException {
    List<String> mappedColumnNames = new ArrayList<String>();
    List<String> unmappedColumnNames = new ArrayList<String>();
    final String upperColumnPrefix = columnPrefix == null ? null : columnPrefix.toUpperCase(Locale.ENGLISH);
    final Set<String> mappedColumns = prependPrefixes(resultMap.getMappedColumns(), upperColumnPrefix);
    for (String columnName : columnNames) {
      final String upperColumnName = columnName.toUpperCase(Locale.ENGLISH);
      if (mappedColumns.contains(upperColumnName)) {
        mappedColumnNames.add(upperColumnName);
      } else {
        unmappedColumnNames.add(columnName);
      }
    }
    mappedColumnNamesMap.put(getMapKey(resultMap, columnPrefix), mappedColumnNames);
    unMappedColumnNamesMap.put(getMapKey(resultMap, columnPrefix), unmappedColumnNames);
  }

1、DefaultRecordSetHandler对RecordSet的处理

其是mybatis中ResultSetHandler的唯一默认实现。

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 rsw = getFirstResultSet(stmt);
    //对于多结果集的，可以配置多个resultMap
    List<ResultMap> resultMaps = mappedStatement.getResultMaps();
    int resultMapCount = resultMaps.size();
    validateResultMapsCount(rsw, resultMapCount);
    while (rsw != null && resultMapCount > resultSetCount) {
      ResultMap resultMap = resultMaps.get(resultSetCount);
      //通过resultMap与recordSet映射
      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);
  }

单独处理recordSet是通过handleResultSet来实现的.

当配置的是多个recordsets,而只对应一个resultMap，但是resultMap中的其中一个映射到其中的一个recordSet时，会进入到第一个分支。

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) {
          DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
          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 {
    if (resultMap.hasNestedResultMaps()) {
      ensureNoRowBounds();
      checkResultHandler();
      handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    } else {
      handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    }
  }

简单映射的处理流程为

嵌套映射的处理流程为：前面与简单映射一样，跳到偏移所在的行，在没有到limit时，先根据discriminate找到ResultMap，如果有IdResultMapping就用此来创建CacheKey，否则使用 PropertyResultMapping来创建CacheKey。在嵌套结果对象没有时，创建metaobject,首先根据构造函数设置，根据是否需要自动映射来映射没有指定映射的列，然后映射指定的属性，接着作嵌套映射，在有嵌套结果对象时，直接作嵌套映射，最后调用callResultHandler存储对象

private void handleRowValuesForNestedResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
    final DefaultResultContext<Object> resultContext = new DefaultResultContext<Object>();
    skipRows(rsw.getResultSet(), rowBounds);
    Object rowValue = previousRowValue;
    while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
      final ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);
      final CacheKey rowKey = createRowKey(discriminatedResultMap, rsw, null);
      Object partialObject = nestedResultObjects.get(rowKey);
      // issue #577 && #542
      if (mappedStatement.isResultOrdered()) {
        if (partialObject == null && rowValue != null) {
          nestedResultObjects.clear();
          storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
        }
        rowValue = getRowValue(rsw, discriminatedResultMap, rowKey, null, partialObject);
      } else {
        rowValue = getRowValue(rsw, discriminatedResultMap, rowKey, null, partialObject);
        if (partialObject == null) {
          storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
        }
      }
    }
    if (rowValue != null && mappedStatement.isResultOrdered() && shouldProcessMoreRows(resultContext, rowBounds)) {
      storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
      previousRowValue = null;
    } else if (rowValue != null) {
      previousRowValue = rowValue;
    }
  }

代理工厂设计的类层次图为

多结果集的处理

private Object getPropertyMappingValue(ResultSet rs, MetaObject metaResultObject, ResultMapping propertyMapping, ResultLoaderMap lazyLoader, String columnPrefix)
      throws SQLException {
    if (propertyMapping.getNestedQueryId() != null) {
      return getNestedQueryMappingValue(rs, metaResultObject, propertyMapping, lazyLoader, columnPrefix);
    } else if (propertyMapping.getResultSet() != null) {
      addPendingChildRelation(rs, metaResultObject, propertyMapping);   // TODO is that OK?
      return DEFERED;
    } else {
      final TypeHandler<?> typeHandler = propertyMapping.getTypeHandler();
      final String column = prependPrefix(propertyMapping.getColumn(), columnPrefix);
      return typeHandler.getResult(rs, column);
    }
  }

private void addPendingChildRelation(ResultSet rs, MetaObject metaResultObject, ResultMapping parentMapping) throws SQLException {
    CacheKey cacheKey = createKeyForMultipleResults(rs, parentMapping, parentMapping.getColumn(), parentMapping.getColumn());
    PendingRelation deferLoad = new PendingRelation();
    deferLoad.metaObject = metaResultObject;
    deferLoad.propertyMapping = parentMapping;
    List<PendingRelation> relations = pendingRelations.get(cacheKey);
    // issue #255
    if (relations == null) {
      relations = new ArrayList<DefaultResultSetHandler.PendingRelation>();
      pendingRelations.put(cacheKey, relations);
    }
    relations.add(deferLoad);
    ResultMapping previous = nextResultMaps.get(parentMapping.getResultSet());
    if (previous == null) {
      nextResultMaps.put(parentMapping.getResultSet(), parentMapping);
    } else {
      if (!previous.equals(parentMapping)) {
        throw new ExecutorException("Two different properties are mapped to the same resultSet");
      }
    }
  }

2、对Cursor的处理

其使用迭代器设计模式，基于DefaultCursor来处理游标的。使用内部类CursorIterator来作迭代，其类关系图为

public <E> Cursor<E> handleCursorResultSets(Statement stmt) throws SQLException {
    ErrorContext.instance().activity("handling cursor results").object(mappedStatement.getId());

    ResultSetWrapper rsw = getFirstResultSet(stmt);

    List<ResultMap> resultMaps = mappedStatement.getResultMaps();

    int resultMapCount = resultMaps.size();
    validateResultMapsCount(rsw, resultMapCount);
    if (resultMapCount != 1) {
      throw new ExecutorException("Cursor results cannot be mapped to multiple resultMaps");
    }

    ResultMap resultMap = resultMaps.get(0);
    return new DefaultCursor<E>(this, resultMap, rsw, rowBounds);
  }

//CursorIterator
 @Override
        public boolean hasNext() {
            if (object == null) {
                object = fetchNextUsingRowBound();
            }
            return object != null;
        }

protected T fetchNextUsingRowBound() {
        T result = fetchNextObjectFromDatabase();
        while (result != null && indexWithRowBound < rowBounds.getOffset()) {
            result = fetchNextObjectFromDatabase();
        }
        return result;
    }

protected T fetchNextObjectFromDatabase() {
        if (isClosed()) {
            return null;
        }

        try {
            status = CursorStatus.OPEN;
            resultSetHandler.handleRowValues(rsw, resultMap, objectWrapperResultHandler, RowBounds.DEFAULT, null);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }

        T next = objectWrapperResultHandler.result;
        if (next != null) {
            indexWithRowBound++;
        }
        // No more object or limit reached
        if (next == null || (getReadItemsCount() == rowBounds.getOffset() + rowBounds.getLimit())) {
            close();
            status = CursorStatus.CONSUMED;
        }
        objectWrapperResultHandler.result = null;

        return next;
    }

public T next() {
            // Fill next with object fetched from hasNext()
            T next = object;

            if (next == null) {
                next = fetchNextUsingRowBound();
            }

            if (next != null) {
                object = null;
                iteratorIndex++;
                return next;
            }
            throw new NoSuchElementException();
        }

3、对存储过程的处理

对绑定的sql的参数映射处理，参数类型为out或者inout类型。

public void handleOutputParameters(CallableStatement cs) throws SQLException {
    final Object parameterObject = parameterHandler.getParameterObject();
    final MetaObject metaParam = configuration.newMetaObject(parameterObject);
    final List<ParameterMapping> 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) {
        if (ResultSet.class.equals(parameterMapping.getJavaType())) {
          handleRefCursorOutputParameter((ResultSet) cs.getObject(i + 1), parameterMapping, metaParam);
        } else {
          final TypeHandler<?> typeHandler = parameterMapping.getTypeHandler();
          metaParam.setValue(parameterMapping.getProperty(), typeHandler.getResult(cs, i + 1));
        }
      }
    }
  }

private void handleRefCursorOutputParameter(ResultSet rs, ParameterMapping parameterMapping, MetaObject metaParam) throws SQLException {
    if (rs == null) {
      return;
    }
    try {
      final String resultMapId = parameterMapping.getResultMapId();
      final ResultMap resultMap = configuration.getResultMap(resultMapId);
      final DefaultResultHandler resultHandler = new DefaultResultHandler(objectFactory);
      final ResultSetWrapper rsw = new ResultSetWrapper(rs, configuration);
      handleRowValues(rsw, resultMap, resultHandler, new RowBounds(), null);
      metaParam.setValue(parameterMapping.getProperty(), resultHandler.getResultList());
    } finally {
      // issue #228 (close resultsets)
      closeResultSet(rs);
    }
  }

 

kgduu
关注
专栏目录
手撕Mybatis源码，自己动手实现Mybatis
11-14
要动手实现一个类似Mybatis的框架，首先需要设计和实现上述组件。理解每个组件的功能和它们之间的协作关系至关重要。你可以从以下几个步骤开始： 1. 设计并实现基础架构，包括SqlSessionFactory、Configuration、...
带你学习Mybatis之ResultSetHandler结果集处理
Lxn2zh的博客
06-18 540
当真正要使用延迟加载的属性时，会通过代理对象执行数据库加载操作，得到真正的数据。Javassist是一个开源的生成java字节码的类库，其主要优点在于简单、快速，直接使用Javassist提供的API就可以动态的修改类的结构，或是动态的生成类。CGLIB采用字节码技术实现动态代理功能，原理是通过字节码技术为目标类生成子类，并在子类中采用方法拦截的方式拦截所有父类方法的调用，从而实现代理的功能。延迟加载使用动态代理实现的，由于映射的结果对象都为普通的类，没有使用接口，所以无法使用JDK代理。
mybatis-ResultHandler解析
qq_28695733的博客
07-08 1万+
概述 结果值的处理相当于参数的处理会复杂一些，负责结果值转换的类是 ResultSetHandler public interface ResultSetHandler { /** * 处理数据集并返回 * @param stmt * @param <E> * @return * @throws SQLException */ <E> List<E> handleResultSets(Statement stmt) throw
Mybatis拦截器(Interceptor)的理解与实践
最新发布
weixin_61478518的博客
07-08 1349
MyBatis 的拦截器是一个十分强大的特性，它可以让我们在 MyBatis 调用数据库操作的过程中插入自己的逻辑，非常适合做一些数据操作的审计、性能优化、事务管理、执行日志输出等。
【MyBatis】MyBatis 核心配置综述之 ResultSetHandler
九师兄
05-14 2048
1.概述 转载：核心配置综述之 ResultSetHandler 我们之前介绍过了MyBatis 四大核心配置之 Executor、StatementHandler、 ParameterHandler，今天本文的主题是介绍一下 MyBatis 最后一个神器也就是 ResultSetHandler。那么开始我们的讨论 2.ResultSetHandler 简介 回想一下，一条 SQL 的请求过程会经过哪几个步骤？ 首先会经过 Executor 执行器，它主要负责管理创建 StatementHandler 对.
Mybatis 中 ResultHandler 的用法（获取大结果集，实现结果流式输出）
长安明月的博客
09-20 5135
Mybatis 中的 ResultHandler 相当于数据结果集的处理器，它是一个回调函数（Callback），用来处理每一行数据的结果，这个回调函数可以在查询结果处理到一定量时触发，对结果集数据进行定制化处理。ResultHandler 的使用可以大幅提升数据处理的效率，当我们需要处理大量的数据时，一般会使用 ResultHandler 来进行结果的处理，避免一次查询就全部返回结果，浪费内存资源或造成 OOM。import org// SQL 返回值为 void，所以我们并没有接收这个返回值。
MyBatis3源码深度解析(五)ResultSet
挑灯日记 记录自己
03-08 1455
上一节中，在执行方法时均会返回一个ResultSet对象，并且在方法中还可以对ResultSet对象的处理逻辑进行配置。本节来详细研究一下ResultSet对象的特性。
Mybatis流式查询之ResultHanlde
relife
07-22 7198
0.前言 如果目标数据量过大，又需要全量查询，不能分页的情况，例如导出excel，就需要流式查询 1. 实例 1.1.Mybaits的jar包引入 注：idea必须配置build，否则扫描不到src下的xml文件 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSche
Mybatis 架构设计分享.pdf
10-24
Mybatis的主要目标是简化数据持久层操作，它将SQL语句与Java代码分离，通过XML或注解方式定义SQL语句，实现了SQL与Java对象的映射，使得数据库操作更为便捷。 **Mybatis与JDBC的关系**： Mybatis是对JDBC的封装和...
简单了解mybatis拦截器实现原理及实例
08-25
MyBatis拦截器设计的一个初衷是为了供用户在某些时候可以实现自己的逻辑而不必去动MyBatis固有的逻辑。 三、自定义拦截器 要实现自定义拦截器，需要三步骤： 1. 实现Interceptor接口 自定义拦截器需要实现...
深入浅出MyBatis技术原理与实战
06-05
在实际项目中，MyBatis常与Spring框架结合使用，通过Spring的依赖注入和事务管理功能，实现更高效的开发。此外，MyBatis还可以应用于微服务架构，作为服务间数据交互的工具。 **最佳实践** 1. 尽量避免在Mapper XML...
my-mybatis:mybatis功能简单实现 - 手写
05-14
在MyBatis中，插件的工作原理是利用Java的动态代理，对Executor、StatementHandler、ParameterHandler和ResultSetHandler这四个接口的实例进行拦截。开发者可以通过定义自己的Plugin类，使用这些拦截器来扩展MyBatis...
Mybatise---ResultSet关联查询（Mybatis查询多条数据返回ResultSet ）
qq_45657986的博客
04-11 1470
Mybatis查询多条数据返回ResultSet 1.封装为List ResultType如果返回的是一个集合，则返回的是集合中元素的类型，非List类Mybatis会自动将所查询到的数据进行封装，封装为List EmployeeMapper.java EmployeeMapper.xml MybatisTest.java 2.封装为Map key是列名，value值对应值 多条记录封装一个map：Map<Integer,Employee>:键是这条记录的主键，值是封装后的javaBean
MyBatis中mapper.xml其属性resultSets的作用及研究
热门推荐
qq_40233503的博客
07-02 1万+
在完成一个需求的时候，意外发现了resultSets这一属性，以前都没有接触过，现在在学习经历写下了做一次总结与分享 除了resultType，resultMap做映射外，Mybatis还提供了开放的API来做映射的处理。 resultType和resultMap 首先来说说MyBatis的resultType和resultMp，这个两个实际上就是对数据库中的列名和我们的Java实体中做了一对...
1. 使用MyBatis的ResultHandler实现流式查询，避免大数据量一次加载
大头鱼
03-11 2100
使用MyBatis的ResultHandler实现流式查询，避免大数据量一次加载
Mybatis的ResultHandle用法
杭川奇迹的博客
09-27 3181
ResultHandle用法创建实体类sql，返回值类型要写Mapper，返回值必须是voidTest ResultHandler，顾名思义，对返回的结果进行处理，最终得到自己想要的数据格式或类型。也就是说，可以自定义返回类型。下面通过一个例子讲解它的使用方法： 创建实体类 package com.ccb.demossm.entity; import com.ccb.demossm.annotation.MyAnnotation; import org.springframework.stereotype
Mybatis 获取ResultSet
weixin_39855499的博客
10-21 9027
Mybatis通过映射直接返回，有时候我们需要其元数据或映射前的ResultSet值，Mybatis中有拦截器类 @Intercepts({@Signature(type = ResultSetHandler.class, method = &quot;handleResultSets&quot;, args = {Statement.class})}) public class Demoimplements Int...
MyBatis入门系列(19) -MyBatis四大组件之ResultSetHandler源码及流程解析
记录知识、锤炼自我
06-28 1186
ResultSetHandler 之前说过在创建StatementHandler处理器时会同时创建ParameterHandler及ResultSetHandler。 ResultSetHandler是Mybatis的核心组件，主要负责将结果集resultSets转化成结果列表（或cursor）和处理储存过程的输出。 源码分析 ResultSet 在原生JDBC查询的代码中，使用Statement进行操作，会返回ResultSet对象 。 ResultSet也是java.sql中的接口，它表示通过执行查询数
Mybatis源码之ResultSet结果集处理
m0_58559010的博客
08-30 1938
时序图 详细步骤 PreparedStatementHandler#query @Override public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException { PreparedStatement ps = (PreparedStatement) statement; // 执行SQL ps.execute();
深入解析Mybatis源码：设计模式与工作流程
"Mybatis源码分析主要涵盖了Mybatis的工作流程、设计模式应用以及源码解析，旨在深入理解Mybatis的内部机制。" 在Mybatis的源码分析中，我们可以看到以下几个关键知识点： 1. **Mybatis工作流程**： Mybatis的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

kgduu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值