Mybatis学习系列（九）：select的执行

最新推荐文章于 2025-05-21 00:30:57 发布
原创 最新推荐文章于 2025-05-21 00:30:57 发布 · 1.2k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#mybatis #select

本文深入探讨了Mybatis中的select查询实现，包括返回void、集合、Map、Cursor及单一对象的情况。详细分析了sqlsession的select方法、缓存处理、数据库查询、SimpleExecutor的doQuery方法以及resultSetHandler如何解析结果。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

我们先看一下MapperMethod中有哪些select查询，都是如何实现的

case SELECT:
        //1.返回void
        if (method.returnsVoid() && method.hasResultHandler()) {
          executeWithResultHandler(sqlSession, args);
          result = null;
        } else if (method.returnsMany()) {
          //2.返回集合
          result = executeForMany(sqlSession, args);
        } else if (method.returnsMap()) {
          //3.返回map
          result = executeForMap(sqlSession, args);
        } else if (method.returnsCursor()) {
          //4.返回游标
          result = executeForCursor(sqlSession, args);
        } else {
          //5.返回单个对象
          Object param = method.convertArgsToSqlCommandParam(args);
          result = sqlSession.selectOne(command.getName(), param);
        }

1.返回void

private void executeWithResultHandler(SqlSession sqlSession, Object[] args) {
    //获取MappedStatement 
    MappedStatement ms = sqlSession.getConfiguration().getMappedStatement(command.getName());
    if (!StatementType.CALLABLE.equals(ms.getStatementType())
        && void.class.equals(ms.getResultMaps().get(0).getType())) {
      throw new BindingException("method " + command.getName()
          + " needs either a @ResultMap annotation, a @ResultType annotation,"
          + " or a resultType attribute in XML so a ResultHandler can be used as a parameter.");
    }
    //获取所有的入参
    Object param = method.convertArgsToSqlCommandParam(args);
    //是否包含分页信息
    //调用sqlSession的select方法
    if (method.hasRowBounds()) {
      RowBounds rowBounds = method.extractRowBounds(args);
      sqlSession.select(command.getName(), param, rowBounds, method.extractResultHandler(args));
    } else {
      sqlSession.select(command.getName(), param, method.extractResultHandler(args));
    }
  }

我们看下sqlsession的select方法：

  public void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
    try {
      //获取MappedStatement 
      MappedStatement ms = configuration.getMappedStatement(statement);
      //执行executor的query方法
      executor.query(ms, wrapCollection(parameter), rowBounds, handler);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

这里其实是调用了BaseExecuto的query方法：

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    //获取执行的sql信息
    BoundSql boundSql = ms.getBoundSql(parameter);
    //获取当前执行方法的缓存key
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    //执行方法
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
 }


public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List<E> list;
    try {
      queryStack++;
      //判断是否从走缓存
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
        //不走缓存 执行查询
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      queryStack--;
    }
    if (queryStack == 0) {
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }

我们先看一下取缓存数据后的对参数的操作：

private void handleLocallyCachedOutputParameters(MappedStatement ms, CacheKey key, Object parameter, BoundSql boundSql) {
    if (ms.getStatementType() == StatementType.CALLABLE) {
      final Object cachedParameter = localOutputParameterCache.getObject(key);
      if (cachedParameter != null && parameter != null) {
        final MetaObject metaCachedParameter = configuration.newMetaObject(cachedParameter);
        final MetaObject metaParameter = configuration.newMetaObject(parameter);
        for (ParameterMapping parameterMapping : boundSql.getParameterMappings()) {
          if (parameterMapping.getMode() != ParameterMode.IN) {
            final String parameterName = parameterMapping.getProperty();
            final Object cachedValue = metaCachedParameter.getValue(parameterName);
            metaParameter.setValue(parameterName, cachedValue);
          }
        }
      }
    }
  }

然后是不走缓存，查询数据库的操作：

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
      //执行查询操作
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
      localCache.removeObject(key);
    }
    //把当前查询结果放到缓存中
    localCache.putObject(key, list);
    if (ms.getStatementType() == StatementType.CALLABLE) {
      localOutputParameterCache.putObject(key, parameter);
    }
    return list;
  }

这里doquery其实是SimpleExecutor的方法：

public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      //1.获取配置信息
      Configuration configuration = ms.getConfiguration();
      //2.获取StatementHandler 并初始化数据
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      //3.获取Statement 对象
      stmt = prepareStatement(handler, ms.getStatementLog());
      //4.执行StatementHandler 的query方法
      return handler.<E>query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }

我们可以看到这里的1,2,3步跟前面的insert,update,delete的操作是一致的，不做解析，我们主要看第4步的查询方法：

 public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    //执行PreparedStatement 的execute方法
    ps.execute();
    //解析返回的数据
    return resultSetHandler.<E> handleResultSets(ps);
  }

这里我们主要看返回数据的解析，这里调用的是resultSetHandler对象的handleResultSets的方法：这里的resultSetHandler也是在获取statementHandler的时候初始化的：调用的是configuration的方法

this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);

public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
      ResultHandler resultHandler, BoundSql boundSql) {
    //初始化一个DefaultResultSetHandler
    ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
    //在DefaultResultSetHandler上添加插件拦截器链
    resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
    return 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();
    //获取ResultMap个数，一般都是一个
    int resultMapCount = resultMaps.size();
    //校验查询数据是否有效
    validateResultMapsCount(rsw, resultMapCount);
    //循环解析每一个ResultSet  也就是必须设定了返回的ResultMap 
    //如果设定不是ResultMap 走后面的resultSets逻辑
    while (rsw != null && resultMapCount > resultSetCount) {
      //获取当前对应的ResultMap 数据  也就是返回字段的定义
      ResultMap resultMap = resultMaps.get(resultSetCount);
      //解析转换赋值
      handleResultSet(rsw, resultMap, multipleResults, null);
      //获取下一个ResultSet进行后续解析
      rsw = getNextResultSet(stmt);
      cleanUpAfterHandlingResultSet();
      resultSetCount++;
    }
    //这里判断是不是设置的resultType
    String[] resultSets = mappedStatement.getResultSets();
    if (resultSets != null) {
      //循环解析每个resultSet
      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);
        }
        //获取下一个resultSet
        rsw = getNextResultSet(stmt);
        cleanUpAfterHandlingResultSet();
        resultSetCount++;
      }
    }
    //返回解析后的数据
    return collapseSingleResultList(multipleResults);
  }

我们看一下每一个ResultSet数据的解析：

private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
    try {
      if (parentMapping != null) {
        //解析ResultSet数据
        handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
      } else {
        if (resultHandler == null) {
          DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
         //解析ResultSet数据
          handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
          //只有这种情况返回的是我们自定义的list 一般都是走的这里
          //把上一步的defaultResultHandler的list添加到multipleResults中
          multipleResults.add(defaultResultHandler.getResultList());
        } else {
          //解析ResultSet数据
          handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
        }
      }
    } finally {
      // issue #228 (close resultsets)
      closeResultSet(rsw.getResultSet());
    }
  }


//解析ResultSet数据
public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
    //ResultMap有子集关系的
    if (resultMap.hasNestedResultMaps()) {
      ensureNoRowBounds();
      checkResultHandler();
      handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    } else {
      //普通单一ResultMap
      handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    }
  }


//普通单一ResultMap
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);
    //循环解析每行数据
    while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
      ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);
      //获取行数据
      Object rowValue = getRowValue(rsw, discriminatedResultMap);
      //这里把行数据设置到resultContext里面
      storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
    }
  }

//这里把行数据设置到resultContext里面
private void storeObject(ResultHandler<?> resultHandler, DefaultResultContext<Object> resultContext, Object rowValue, ResultMapping parentMapping, ResultSet rs) throws SQLException {
    if (parentMapping != null) {
      linkToParents(rs, parentMapping, rowValue);
    } else {
      //rowValue设置到resultContext
      callResultHandler(resultHandler, resultContext, rowValue);
    }
  }

//rowValue设置到resultContext
private void callResultHandler(ResultHandler<?> resultHandler, DefaultResultContext<Object> resultContext, Object rowValue) {
    //把rowValue设置给resultContext的resultObject
    resultContext.nextResultObject(rowValue);
    把当前resultContext的resultObject设置到DefaultResultHandler的list中
    ((ResultHandler<Object>) resultHandler).handleResult(resultContext);
  }

2.返回集合

private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
    List<E> result;
    //获取入参
    Object param = method.convertArgsToSqlCommandParam(args);
    //有没有分页信息
    if (method.hasRowBounds()) {
      RowBounds rowBounds = method.extractRowBounds(args);
      //调用sqlSession.selectList方法 最终都是走的query方法，跟返回void一致不在说明
      result = sqlSession.<E>selectList(command.getName(), param, rowBounds);
    } else {
      //调用sqlSession.selectList方法，跟返回void一致不在说明
      result = sqlSession.<E>selectList(command.getName(), param);
    }
    // issue #510 Collections & arrays support
    if (!method.getReturnType().isAssignableFrom(result.getClass())) {
      //返回数据是数组
      if (method.getReturnType().isArray()) {
        return convertToArray(result);
      } else {
        //集合
        return convertToDeclaredCollection(sqlSession.getConfiguration(), result);
      }
    }
    return result;
  }

//返回数据是数组
private <E> Object convertToArray(List<E> list) {
    Class<?> arrayComponentType = method.getReturnType().getComponentType();
    Object array = Array.newInstance(arrayComponentType, list.size());
    if (arrayComponentType.isPrimitive()) {
      for (int i = 0; i < list.size(); i++) {
        Array.set(array, i, list.get(i));
      }
      return array;
    } else {
      return list.toArray((E[])array);
    }
  }

//集合
 private <E> Object convertToDeclaredCollection(Configuration config, List<E> list) {
    Object collection = config.getObjectFactory().create(method.getReturnType());
    MetaObject metaObject = config.newMetaObject(collection);
    metaObject.addAll(list);
    return collection;
  }

3.返回map

private <K, V> Map<K, V> executeForMap(SqlSession sqlSession, Object[] args) {
    Map<K, V> result;
    //获取入参
    Object param = method.convertArgsToSqlCommandParam(args);
    if (method.hasRowBounds()) {
      RowBounds rowBounds = method.extractRowBounds(args);
      //调用sqlSession.selectMap方法
      result = sqlSession.<K, V>selectMap(command.getName(), param, method.getMapKey(), rowBounds);
    } else {
      result = sqlSession.<K, V>selectMap(command.getName(), param, method.getMapKey());
    }
    return result;
  }

//调用sqlSession.selectMap方法
public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) {
    //这里调用的是selectList方法 上面已经解析过 不在解析
    final List<? extends V> list = selectList(statement, parameter, rowBounds);
    //这里把数据转换成map格式
    final DefaultMapResultHandler<K, V> mapResultHandler = new DefaultMapResultHandler<K, V>(mapKey,
        configuration.getObjectFactory(), configuration.getObjectWrapperFactory(), configuration.getReflectorFactory());
    final DefaultResultContext<V> context = new DefaultResultContext<V>();
    for (V o : list) {
      context.nextResultObject(o);
      mapResultHandler.handleResult(context);
    }
    return mapResultHandler.getMappedResults();
  }

4.返回Cursor

private <T> Cursor<T> executeForCursor(SqlSession sqlSession, Object[] args) {
    Cursor<T> result;
    //获取入参
    Object param = method.convertArgsToSqlCommandParam(args);
    if (method.hasRowBounds()) {
      RowBounds rowBounds = method.extractRowBounds(args);
      //调用sqlSession.selectCursor方法
      result = sqlSession.<T>selectCursor(command.getName(), param, rowBounds);
    } else {
      //调用sqlSession.selectCursor方法
      result = sqlSession.<T>selectCursor(command.getName(), param);
    }
    return result;
  }

//调用sqlSession.selectCursor方法
public <T> Cursor<T> selectCursor(String statement, Object parameter, RowBounds rowBounds) {
    try {
      //获取MappedStatement 
      MappedStatement ms = configuration.getMappedStatement(statement);
      //调用executor.queryCursor方法
      Cursor<T> cursor = executor.queryCursor(ms, wrapCollection(parameter), rowBounds);
      //把当前cursor添加到cursorList中
      registerCursor(cursor);
      return cursor;
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

//调用executor.queryCursor方法
public <E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException {
    //获取执行SQL信息
    BoundSql boundSql = ms.getBoundSql(parameter);
    //调用simpleexecutor.doQueryCursor方法
    return doQueryCursor(ms, parameter, rowBounds, boundSql);
  }

//调用simpleexecutor.doQueryCursor方法
protected <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql) throws SQLException {
    Configuration configuration = ms.getConfiguration();
    StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, null, boundSql);
    Statement stmt = prepareStatement(handler, ms.getStatementLog());
    //这里把获取的数据转换成Cursor
    return handler.<E>queryCursor(stmt);
  }

public <E> Cursor<E> queryCursor(Statement statement) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    return resultSetHandler.<E> handleCursorResultSets(ps);
  }

//这里跟前面的解析基本一致  主要是把ResultMap 转换成DefaultCursor
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);
  }

//把ResultMap 转换成DefaultCursor
public DefaultCursor(DefaultResultSetHandler resultSetHandler, ResultMap resultMap, ResultSetWrapper rsw, RowBounds rowBounds) {
        this.resultSetHandler = resultSetHandler;
        this.resultMap = resultMap;
        this.rsw = rsw;
        this.rowBounds = rowBounds;
    }

5.返回单一对象：这里直接调用的sqlsession.selectOne方法：主要是调用selectList方法

public <T> T selectOne(String statement, Object parameter) {
    // 调用selectList方法
    List<T> list = this.<T>selectList(statement, parameter);
    //这里判断  必须只能返回一条数据 如果多于1条  抛出异常
    if (list.size() == 1) {
      return list.get(0);
    } else if (list.size() > 1) {
      throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
    } else {
      return null;
    }
  }

 

Mybatis游标Cursor查询
WannaRunning的博客
12-14 1万+
通常对一张表中大量数据处理时由于数据量太大都要使用分页分批查询处理，否则数据量太大会导致OOM等问题。 Cursor查询适用于这种场景下可以替代分页查询的方案，Cursor实现了Closeable和Iterable接口，我们可以通过迭代器来获取数据进行处理。 public interface Cursor<T> extends Closeable, Iterable<T> { boolean isOpen();//用于在取数据之前判断 Cursor 对象是否是打开状态。
MyBatis系列五: 动态SQL
你好, 我在学java的博客
03-26 1051
MyBatis系列四: 动态SQL
mybatis-cursor:mybatis光标问题（https
05-13
Mybatis光标 mybatis光标问题
JdbcCursor流式查询导出数据库千万级数据
最新发布
weixin_42304484的博客
05-21 412
mybatis的cursor流式查询研究及自定义JdbcCursor流式查询，数据库大量数据导出
MySQL环境下，mybatis使用Cursor
liangbo7的博客
02-07 861
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档。
【小笔记】MyBaits的Cursor
积
11-07 1015
流式查询 指的是查询成功后不是返回一个集合而是返回一个迭代器，应用可以通过迭代器每次取一条查询结果。流式查询的好处是能够降低内存使用。例如我们想要从数据库取 1000 万条记录而又没有足够的内存时，就不得不分页查询。而分页查询就需要我们按照顺序查询并设置一个参数来记录当前进度并在下次查询时将进度作为参数传入（比如按id升序查询，记录每次查询结果的最大id, 下次查询将这个最大id传入只查询大于这个id的），否则就会出现深度分页的情况。
Mybatis游标查询Cursor(滚动查询)
小高同学要努力吖
06-06 8304
Mybatis游标查询Cursor(滚动查询)
myBatis系列之一：搭建开发环境
08-14
本教程将引导你一步步搭建MyBatis的开发环境，为后续的深入学习和实践打下基础。 首先，我们需要了解MyBatis的核心概念。MyBatis是一个轻量级的框架，它不包含任何JDBC模板或实体管理功能，而是专注于SQL映射。通过...
mybatis-sample:学习mybatis
05-20
在这个名为"mybatis-sample"的学习项目中，作者创建了一系列示例程序来深入理解MyBatis的工作原理和用法。通过这个项目，我们可以学习以下几个关键知识点： 1. **MyBatis配置**：在MyBatis中，配置文件通常包含数据...
深入Mybatis练习与实践：掌握关键操作技巧
从文件名称"mybatis05"可以看出，这可能是一个系列学习MyBatis的练习文件，第5个练习可能包含了一些具体的操作，如映射文件的编写、SQL的动态构建、缓存的使用等，这些内容是MyBatis框架学习中的常见练习点，有助于...
MyBatis字符串问题：深入解析与实战技巧
一个做过前端开发的产品经理，经历过睿智产品的折磨导致脱发之后，励志要翻身"农奴"把歌唱，一边打入敌人内部一边持续提升自己，为我们广大开发同胞谋福祉，坚决抵制睿智产品折磨我们码农兄弟！
07-05 1136
MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集，可以使用简单的XML或注解进行配置和原始映射，将接口和Java的POJOs(Plain Old Java Objects，普通的Java对象)映射成数据库中的记录。在MyBatis中处理字符串问题时，核心在于理解框架的动态SQL机制，并结合具体业务需求灵活运用。上述示例和技巧不仅能够帮助你构建出高效、安全的SQL语句，还能提升代码的可读性和维护性。
mybatis 游标查询_Mybatis 3.4.0 Cursor的使用
weixin_42513601的博客
01-27 2540
在mybatis 3.4.0版本中新增了一个功能，查询可以返回Cusror类型的数据，类似于JDBC里的ResultSet类，当查询百万级的数据的时候，使用游标可以节省内存的消耗，不需要一次性取出所有数据，可以进行逐条处理或逐条取出部分批量处理。在使用方式上没有太大变化mybatis单独使用XML mapping :select id,name,salary,skill from employee...
Mybatis的Cursor如何避免OOM异常
Azir_的博客
06-25 1356
类型如何获取数据返回值是否关闭Statement、ResultSetCursor用户自行根据Cursor迭代器获取Cursor游标类型不关闭，需要一直持有普通搜索Mybatis内部操控JDBC指针，获取所有查询数据后返回。具体实体类型获取完数据后关闭。
mybatis cursor游标查询
congcong7267的博客
05-30 2182
mybatis cursor游标查询
Mybatis的Cursor避免OOM异常的方法详解
chinaherolts2008的博客
08-10 357
在Mybatis中,有一个特殊的对象Cursor,这个对象的注释上清晰的说明了,这个类的用途,在Mybatis中使用Cursor非常简单,只要在Mapper文件中将方法的返回值设置成Cursor即可,本文给大家介绍了Mybatis的Cursor避免OOM异常的方法,需要的朋友可以参考下。可以对比一下两个实际执行的方法，比较明显的区别就是在批量搜索中，显式关闭了打开的Statement，而在Cursor查询中，并没有关闭与数据库的连接。在调用Mapper方法的方法上标注@Transactional事务注解。
MyBatis游标Cursor的正确用法和百万数据传输的内存测试
热门推荐
偶尔记一下 - mybatis.io
03-25 1万+
很早以前为了处理大量数据想过使用Cursor，当时发现没有效果，就没有继续深入。这次为了搞清楚Cursor是否真的有用，找些资料和源码发现是有效果的，只是缺了必要的配置。
Mybatis源码分析之Select返回数据分析
u012734441的专栏
01-07 2136
Mybatis源码分析之Select返回数据分析 在之前的一篇文章中分析了@Select注解的使用方法,在查询方法中我们知可以返回Map类型，也可以返回指针，或者是list集合，或是单条记录，今天就对这几种返回做一个源码分析。 Select查询 在这里就不需要再写一个demo演示了，用法无非这么多，直接看查询的源码吧。 首先在看对应select的查询源码时先看下MyBatis是怎么定义metho...
mybatis在指定库建表_mybatis快速入门
weixin_39958248的博客
01-12 776
1 开发环境搭建1、项目使用maven构建，在pom.xml中引入以下依赖org.mybatismybatis3.4.0mysqlmysql-connector-java5.1.39junitjunit4.12在基础篇开篇中，我们提到过mybatis在工作过程中，依赖数据源(DataSource)，由于mybatis自带了几个简单的DataSource实现，这里我们直接使用mybatis自带的即可...
MyBatis初学者指南：连接MySQL数据库
这篇资源适合刚刚完成Java Web学习并希望进一步学习MyBatis框架的初学者。资源将引导你通过一系列步骤，了解如何在IntelliJ IDEA中使用Maven构建项目，并配置MyBatis来连接MySQL数据库进行数据查询。 首先，你需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值