关于mybatis:Mybatis查询结果为空时为什么返回值为NULL或空集合

3次阅读

共计 12302 个字符，预计需要花费 31 分钟才能阅读完成。

背景

一行数据记录如何映射成一个 Java 对象，这种映射机制是 MyBatis 作为 ORM 框架的外围性能之一，也是咱们这篇文章须要学习的内容。

开始前咱们先看一个问题：

你是否已经在学习 Mybatis 的时候跟我有一样的疑难，什么状况下返回 null，什么时候是空集合，为什么会是这种后果？那么你感觉上述这种答复能压服你嘛？

我想应该不能吧，除非亲眼所见，否则真的很难确认他人说的是对还是错（毕竟网上的答案真的千奇百怪，啥都有，曾经不是第一次发现一些谬误的说法被宽泛流传了），那么这篇文章咱们就简略的剖析一下。

看完这篇你就晓得查问后果为空时候为什么汇合会是空集合而不是 NULL，而对象为什么会是 NULL 了。

PS：对过程不感兴趣的能够间接跳到最初看论断。

JDBC 中的 ResultSet 简介

你如果有 JDBC 编程教训的话，应该晓得在数据库中执行一条 Select 语句通常只能拿到一个 ResultSet，而后果集 ResultSet 是数据中查问后果返回的一种对象，能够说后果集是一个存储查问后果的对象。

然而后果集并不仅仅具备存储的性能，他同时还具备操纵数据的性能，可能实现对数据的更新等，咱们能够通过 next() 办法将指针挪动到下一行记录，而后通过 getXX() 办法来获取值。

while(rs.next()){
    // 获取数据
    int id = rs.getInt(1);
    String name = rs.getString("name");

    System.out.println(id + "---" + name);
}

后果集解决入口 ResultSetHandler

当 MyBatis 执行完一条 select 语句，拿到 ResultSet 后果集之后，会将其交给关联的 ResultSetHandler 进行后续的映射解决。

在 MyBatis 中只提供了一个 ResultSetHandler 接口实现，即 DefaultResultSetHandler。

上面咱们就以 DefaultResultSetHandler 为核心，介绍 MyBatis 中 ResultSet 映射的外围流程。

它的构造如下：

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;

}

| handleResultSets

DefaultResultSetHandler 实现的 handleResultSets() 办法就反对多个 ResultSet 的解决，外面所调用的 handleResultSet() 办法就是负责解决单个 ResultSet。

通过 while 循环来实现多个 ResultSet 的解决：

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);
}

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);
                // 将该 ResultSet 后果集解决完后的 List 对象放入 multipleResults 中，这样就能够反对返回多个后果集了
                multipleResults.add(defaultResultHandler.getResultList());
            } else {handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
            }
        }
    } finally {// issue #228 (close resultsets)
        closeResultSet(rsw.getResultSet());
    }
}

这里获取到的 ResultSet 对象，会被包装成 ResultSetWrapper 对象，而 ResultSetWrapper 次要用于封装 ResultSet 的一些元数据，其中记录了 ResultSet 中每列的名称、对应的 Java 类型、JdbcType 类型以及每列对应的 TypeHandler。

| DefaultResultHandler 和 DefaultResultContext

在开始具体介绍映射流程中的每一步之前，咱们先来看一下贯通整个映射过程的两个辅助对象 DefaultResultHandler 和 DefaultResultContext。

在 DefaultResultSetHandler 中保护了一个 resultHandler 字段（ResultHandler 接口类型），它默认状况下为空。

比方 DefaultSqlSession#selectList() 中传递的值就是 ResultHandler NO_RESULT_HANDLER = null;

它有两个实现类：

  • DefaultResultHandler 实现的底层应用 ArrayList<Object> 存储单个后果集映射失去的 Java 对象列表。
  • DefaultMapResultHandler 实现的底层应用 Map<K, V> 存储映射失去的 Java 对象，其中 Key 是从后果对象中获取的指定属性的值，Value 就是映射失去的 Java 对象。

DefaultResultContext 对象，它的生命周期与一个 ResultSet 雷同，每从 ResultSet 映射失去一个 Java 对象都会暂存到 DefaultResultContext 中的 resultObject 字段，期待后续应用。

同时 DefaultResultContext 还能够计算从一个 ResultSet 映射进去的对象个数（依附 resultCount 字段统计）。

| 多后果集返回

数据库反对同时返回多个 ResultSet 的场景，例如在存储过程中执行多条 Select 语句。

MyBatis 作为一个通用的长久化框架，不仅要反对罕用的根底性能，还要对其余应用场景进行全面的反对。

而反对多后果集返回的逻辑就在 collapseSingleResultList 办法中：

private List<Object> collapseSingleResultList(List<Object> multipleResults) {
    // 如果只有一个后果集就返回一个，否则间接通过 List 列表返回多个后果集
    return multipleResults.size() == 1 ? (List<Object>) multipleResults.get(0) : multipleResults;
}

multipleResults 里有多少个 List 列表取决于 handleResultSet() 办法里的 resultHandler == null 的判断。

默认状况下没有设置 resultHandler 的话，那每解决一个 ResultSet 就会增加后果到 multipleResults 中，此时 multipleResults.size() == 1 必然是不等于 1 的。

注：感兴趣的能够自行查看 resultHandler 什么时候会不为空。

简略映射

DefaultResultSetHandler 是如何解决单个后果集的，这部分逻辑的入口是 handleResultSet() 办法，其中会依据第四个参数，也就是 parentMapping，判断以后要解决的 ResultSet 是嵌套映射，还是外层映射。

无论是解决外层映射还是嵌套映射，都会依赖 handleRowValues() 办法实现后果集的解决。

通过办法名也能够看出，handleRowValues() 办法是解决多行记录的，也就是一个后果集。

handleRowValuesForNestedResultMap() 办法解决蕴含嵌套映射的 ResultMap，是否为嵌套查问后果集，看 <resultMap> 申明时，是否蕴含 association、collection、case 关键字。

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);
    }
}

private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
    throws SQLException {DefaultResultContext<Object> resultContext = new DefaultResultContext<>();
    ResultSet resultSet = rsw.getResultSet();
    // 跳过多余的记录
    skipRows(resultSet, rowBounds);
    // 检测是否还有须要映射的数据
    while (shouldProcessMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next()) {
        // 解决映射中用到的 Discriminator，决定此次映射理论应用的 ResultMap。ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(resultSet, resultMap, null);
        Object rowValue = getRowValue(rsw, discriminatedResultMap, null);
        storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);
    }
}

该办法的外围步骤可总结为如下：

  • 执行 skipRows() 办法跳过多余的记录，定位到指定的行。
  • 通过 shouldProcessMoreRows() 办法，检测是否还有须要映射的数据记录。
  • 如果存在须要映射的记录，则先通过 resolveDiscriminatedResultMap() 办法解决映射中用到的 Discriminator，决定此次映射理论应用的 ResultMap。
  • 通过 getRowValue() 办法对 ResultSet 中的一行记录进行映射，映射规定应用的就是步骤 3 中确定的 ResultMap。
  • 执行 storeObject() 办法记录步骤 4 中返回的、映射好的 Java 对象。

| ResultSet 的预处理

咱们能够通过 RowBounds 指定 offset、limit 参数实现分页的成果。

这里的 skipRows() 办法就会依据 RowBounds 挪动 ResultSet 的指针到指定的数据行，这样后续的映射操作就能够从这一行开始。

通过上述剖析咱们能够看出，通过 RowBounds 实现的分页性能实际上还是会将全副数据加载到 ResultSet 中，而不是只加载指定范畴的数据所以咱们能够认为 RowBounds 实现的是一种“假分页”。

这种“假分页”在数据量大的时候，性能就会很差，在解决大数据量分页时，倡议通过 SQL 语句 where 条件 + limit 的形式实现分页。

| 确定 ResultMap

在实现 ResultSet 的预处理之后，接下来会通过 resolveDiscriminatedResultMap() 办法解决标签，确定此次映射操作最终应用的 ResultMap 对象。

public ResultMap resolveDiscriminatedResultMap(ResultSet rs, ResultMap resultMap, String columnPrefix) throws SQLException {
    // 用于保护解决过的 ResultMap 惟一标识
    Set<String> pastDiscriminators = new HashSet<>();
    // 获取 ResultMap 中的 Discriminator 对象，这是通过 <resultMap> 标签中的 <discriminator> 标签解析失去的
    Discriminator discriminator = resultMap.getDiscriminator();
    while (discriminator != null) {
        // 获取以后待映射的记录中 Discriminator 要检测的列的值
        final Object value = getDiscriminatorValue(rs, discriminator, columnPrefix);
        // 根据上述列值确定要应用的 ResultMap 的惟一标识
        final String discriminatedMapId = discriminator.getMapIdFor(String.valueOf(value));
        if (configuration.hasResultMap(discriminatedMapId)) {
            // 从全局配置对象 Configuration 中获取 ResultMap 对象
            resultMap = configuration.getResultMap(discriminatedMapId);
            // 记录以后 Discriminator 对象
            Discriminator lastDiscriminator = discriminator;
            // 获取 ResultMap 对象中的 Discriminator
            discriminator = resultMap.getDiscriminator();
            // 检测 Discriminator 是否呈现了环形援用
            if (discriminator == lastDiscriminator || !pastDiscriminators.add(discriminatedMapId)) {break;}
        } else {break;}
    }
    // 返回最终要应用的 ResultMap
    return resultMap;
}

至于 ResultMap 对象是怎么创立的，感兴趣的能够自行从 XMLMapperBuilder#resultMapElements() 办法去理解一下，这里不再赘述。

| 创立映射后果对象

确定了以后记录应用哪个 ResultMap 进行映射之后，要做的就是依照 ResultMap 规定进行各个列的映射，失去最终的 Java 对象，这部分逻辑是在 getRowValue() 办法实现的。

其外围步骤如下：

  • 首先依据 ResultMap 的 type 属性值创立映射的后果对象。
  • 而后依据 ResultMap 的配置以及全局信息，决定是否主动映射 ResultMap 中未明确映射的列。
  • 接着依据 ResultMap 映射规定，将 ResultSet 中的列值与后果对象中的属性值进行映射。
  • 最初返回映射的后果对象，如果没有映射任何属性，则须要依据全局配置决定如何返回这个后果值，这里不同场景和配置，可能返回残缺的后果对象、空后果对象或是 null。

这个能够关注 mybatis 配置中的 returnInstanceForEmptyRow 属性，它默认为 false。

当返回行的所有列都是空时，MyBatis 默认返回 null。当开启这个设置时，MyBatis 会返回一个空实例。

请留神，它也实用于嵌套的后果集（如汇合或关联）。（新增于 3.4.2）

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;
}

| 主动映射

创立完后果对象之后，上面就能够开始映射各个字段了。在简略映射流程中，会先通过 shouldApplyAutomaticMappings() 办法检测是否开启了主动映射。

次要检测以下两个中央：

  • 检测以后应用的 ResultMap 是否配置了 autoMapping 属性，如果是，则间接依据该 autoMapping 属性的值决定是否开启主动映射性能。
  • 检测 mybatis-config.xml 的 <settings> 标签中配置的 autoMappingBehavior 值，决定是否开启主动映射性能。NONE 示意敞开主动映射；PARTIAL 只会主动映射没有定义嵌套后果映射的字段；FULL 会主动映射任何简单的后果集（无论是否嵌套）。

| 失常映射

实现主动映射之后，MyBatis 会执行 applyPropertyMappings() 办法解决 ResultMap 中明确要映射的列。

| 存储对象

通过上述 5 个步骤，咱们曾经实现简略映射的解决，失去了一个残缺的后果对象。

接下来，咱们就要通过 storeObject() 办法把这个后果对象保留到适合的地位。

private void storeObject(...) throws SQLException {if (parentMapping != null) {
        // 嵌套查问或嵌套映射的场景，此时须要将后果对象保留到外层对象对应的属性中
        linkToParents(rs, parentMapping, rowValue);
    } else {// 一般映射 (没有嵌套映射) 或是嵌套映射中的外层映射的场景，此时须要将后果对象保留到 ResultHandler 中
        callResultHandler(resultHandler, resultContext, rowValue);
    }
}

这里解决的简略映射，如果是一个嵌套映射中的子映射，那么咱们就须要将后果对象保留到外层对象的属性中。

如果是一个一般映射或是外层映射的后果对象，那么咱们就须要将后果对象保留到 ResultHandler 中。

回归最后的问题：查问后果为空时的返回值

| 返回后果为单行数据

能够从 ResultSetHandler 的 handleResultSets 办法开始剖析。

multipleResults 用于记录每个 ResultSet 映射进去的 Java 对象，留神这里是每个 ResultSet，也就说能够有多个后果集。

咱们能够看到 DefaultSqlSession#selectOne() 办法，咱们先说论断：因为只有一个 ResultSet 后果集，那么返回值为 null。

步骤如下：

handleResultSet() 办法的 handleRowValuesForSimpleResultMap 会判断 ResultSet.next，此时为 false，间接跳过（遗记了的，返回去看简略映射章节）

    // 检测是否还有须要映射的数据
    while (shouldProcessMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next())

而后 multipleResults.add(defaultResultHandler.getResultList()); 中取得的 list 就是默认创立的空集合。

public class DefaultResultHandler implements ResultHandler<Object> {

  // 默认是空集合
  private final List<Object> list;

  public DefaultResultHandler() {list = new ArrayList<>();
  }

  @SuppressWarnings("unchecked")
  public DefaultResultHandler(ObjectFactory objectFactory) {list = objectFactory.create(List.class);
  }

  @Override
  public void handleResult(ResultContext<? extends Object> context) {list.add(context.getResultObject());
  }

  public List<Object> getResultList() {return list;}

}

接下来 selectOne 拿到的就是空 list，此时 list.size() == 1 和 list.size() > 1 均为 false，所以它的返回值为 NULL。

public <T> T selectOne(String statement, Object parameter) {
    // Popular vote was to return null on 0 results and throw exception on too many.
    List<T> list = this.selectList(statement, parameter);
    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;}
  }

| 返回后果为多行数据

那么咱们看到 DefaultSqlSession#selectList() 办法，先说论断：返回值为空集合而不是 NULL。

后面都同理，感兴趣的能够本人顺着 executor.query 一路往下看，会发现最初就是调用的 resultSetHandler.handleResultSets() 办法。

只不过 selectList 是间接把 executor.query 从 defaultResultHandler.getResultList() 返回的空集合没有做解决，间接返回。

public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {MappedStatement ms = configuration.getMappedStatement(statement);
        return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {throw ExceptionFactory.wrapException("Error querying database.  Cause:" + e, e);
    } finally {ErrorContext.instance().reset();}
}

论断

看到这，咱们在反过来看下面截图里的答案，什么返回值是 Java 汇合会先初始化？？而且如果是 Map 作为返回值的话，那间接是返回的 NULL 好吧，几乎是错的离谱！

如果返回值是 Java 汇合类型，如 List、Map，会先初始化（new 一个汇合对象），再把后果增加进去；如果返回值是一般对象，查问不到时，返回值是 null。

其实不论你是查单行记录还是多行记录，对于 Mybatis 来说都会放到 DefaultResultHandler 中去，而 DefaultResultHandler 又是用 List 存储后果。

所以不论是汇合类型还是一般对象，Mybatis 都会先初始化一个 List 存储后果，而后返回值为一般对象且查为空的时候，selectOne 会判断而后间接返回 NULL 值。

而返回值为汇合对象且查为空时，selectList 会把这个存储后果的 List 对象间接返回，此时这个 List 就是个空集合。

起源：https://c1n.cn/6l7NH

正文完
mybatis
发表至： mybatis
2022-07-05
 0
关于mybatis:三XML配置文件笔记
关于mybatis:Mybatis中的一级缓存二级缓存
关于mybatis:Mybatis配置解析
关于mybatis:Mybatis-select记录封装

站内搜索

-「」