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

35次阅读

共计 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

正文完
 0