三枣

mybatis 源码分析（八）ResultSetHandler 详解

本篇博客就是 myabtis 系列的最后一篇了，还剩 ResultSetHandler 没有分析；作为整个 mybatis 最复杂最繁琐的部分，我不打算按步骤一次详解，因为里面的主要内容就是围绕 resultMap 按层次结构依次解析的，其中运用最多的就是反射，所以我这里将围绕延迟加载重点分析，另外本文使用的测试代码都是源码的测试案例；

一、ResultSetHandler 主体结构

public interface ResultSetHandler {
  // 负责结果集处理，完成映射返回结果对象
   List handleResultSets(Statement stmt) throws SQLException;
  // 负责游标对象处理
   Cursor handleCursorResultSets(Statement stmt) throws SQLException;
  // 负责存储过程的输出参数
  void handleOutputParameters(CallableStatement cs) throws SQLException;
}

以上就是 ResultSetHandler 的接口方法（mybatis 中只提供了唯一的实现类 DefaultResultSetHandler），在本篇博客中将主要以 handleResultSets 结果集处理作为主线分析；

在分析之前首先要清楚 handleResultSets 方法的处理流程就是围绕 resultMap 依次解析的，这里先看一个比较复杂的 resultMap 映射：

当 mybatis 初始化完成后上面的配置都放到 MappedStatement.resultMaps 里面，在解析的时候就是通过 resultMap.id 取到对应的 resultMap 然后逐次解析；

1. 嵌套查询

这里之所以说 ResultSetHandler 是整个 mybatis 里面最复杂的，主要是嵌套查询的解析（association 一对一，collection 一对多），值得注意的是这里的嵌套查询是有两种方式的：

内部嵌套

像这种嵌套查询是直接在同一个 resultMap 依次映射对应结果的，使用的是 SQL 多表连接，例如：

这里还有一种分离的内部嵌套：

这中写法只是将 association、collection 部分分离出来，其实质都是一样的，都是一条多表连接的 SQL；

外部嵌套

还有另外一种是将多表连接的 SQL 拆分，每个属性单独发一条 SQL：

像这样在 association、collection 中使用 select 属性指定外部 SQL，其查询结果也是发两条 SQL，这里之所以没有详细写出每个属性的映射，是因为指定了 type 和 ofType，并开启的自动映射，mybatis 在执行的时候使用反射推断出来的；

这里的两种嵌套查询在初始化的时候就进行了单独的区分：

// org.apache.ibatis.builder.xml.XMLMapperBuilder
String nestedResultMap = context.getStringAttribute("resultMap", processNestedResultMappings(context, Collections.emptyList(), resultType));

// org.apache.ibatis.submitted.nestedresulthandler.Mapper.mapper_resultMap[personResult]_collection[items]
private String processNestedResultMappings(XNode context, List resultMappings, Class enclosingType) throws Exception {
  if ("association".equals(context.getName())
      || "collection".equals(context.getName())
      || "case".equals(context.getName())) {
    if (context.getStringAttribute("select") == null) {
      validateCollection(context, enclosingType);
      ResultMap resultMap = resultMapElement(context, resultMappings, enclosingType);
      return resultMap.getId();
    }
  }
  return null;
}

// org.apache.ibatis.mapping.ResultMap
// resultMap.hasNestedResultMaps = resultMap.hasNestedResultMaps || (resultMapping.getNestedResultMapId() != null && resultMapping.getResultSet() == null);

这里代码代码比较多所以只放了关键代码，其最终结果是内部嵌套由 ResultMap.hasNestedResultMaps 标识；

// org.apache.ibatis.builder.xml.XMLMapperBuilder
private ResultMapping buildResultMappingFromContext(XNode context, Class resultType, List flags) throws Exception {
  ...
  String nestedSelect = context.getStringAttribute("select");
  String nestedResultMap = context.getStringAttribute("resultMap",
      processNestedResultMappings(context, Collections.emptyList(), resultType));
  ...
}

外部查询的最终结果是由 ResultMapping.nestedQueryId 保存的，之所以这里强调这些是因为在 ResultSetHandler 解析的时候是分了内外部嵌套两种大的情况的；

2. 多结果集

此外分析之前首先还要知道 CallableStatement 调用存储过程的时候，会有多结果集的情况，例如：

create procedure sptest.getnamesanditemsbyid(in nameId integer)
modifies sql data
dynamic result sets 2
BEGIN ATOMIC
  declare cur1 cursor for select * from sptest.names where id = nameId;
  declare cur2 cursor for select * from sptest.items where name_id in (select id from sptest.names where id = nameId);
  open cur1;
  open cur2;
END

2. 整体流程

上图就是 ResultSetHandler.handleResultSet 的主要流程，这里只保留了重要的部分：

内外部嵌套查询的分支；
外部嵌套查询与一级缓存；
外部嵌套查询的延迟加载，主要是代理对象、ResultLoader、ResultLoaderMap三个对象；

其余的部分这里就不再详细分析了，一下将主要讲解外部嵌套查询的延迟加载；

二、cglib 和 javassisit 动态代理

在讲解延迟加载之前，需要首先简单了解一下动态代理，因为普通的 JavaBean 对象一般都没有实现接口，所以不能使用 java.lang.reflect.Proxy，在 mybatis 中提供了另外两种动态代理 cglib 和 javassisit；

1. cglib

public class Car {
  String name;
  
  public String getName() { return name; }
  public void setName(String name) { this.name = name; }
}

@Test
public void test() {
  Enhancer enhancer = new Enhancer();
  enhancer.setSuperclass(Car.class);
  enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> {
    System.out.println("代理开始");
    Object object = proxy.invokeSuper(obj, args);
    System.out.println("result: " + object);
    System.out.println("代理结束");
    return object;
  });

  Car car = (Car) enhancer.create();
  car.setName("Test");
  car.getName();
}

打印：

代理开始
result: null
代理结束
代理开始
result: Test
代理结束

2. javassist

public class Car {
  String name;
  
  public String getName() { return name; }
  public void setName(String name) { this.name = name; }
}

@Test
public void test() throws IllegalAccessException, InstantiationException {
  ProxyFactory proxyFactory = new ProxyFactory();
  proxyFactory.setSuperclass(Car.class);
  // 设置拦截目标
  proxyFactory.setFilter(m -> m.getName().startsWith("get") || m.getName().startsWith("set"));
  proxyFactory.setHandler((self, thisMethod, proceed, arg) -> {
    System.out.println("代理开始");
    Object object = proceed.invoke(self, arg);
    System.out.println("result: " + object);
    System.out.println("代理结束");
    return object;
  });

  Class clazz = proxyFactory.createClass();
  Car car = (Car) clazz.newInstance();
  car.setName("Test");
  car.getName();
}

打印：

代理开始
result: null
代理结束
代理开始
result: Test
代理结束

三、延迟加载

通过上面的讲解大家应该清楚只有外部嵌套查询才有延迟加载功能；此外和延迟加载相关的配置：

proxyFactory：（CGLIB | JAVASSIST-默认）指定 mybatis 延迟加载的代理工具；
lazyLoadingEnabled：（true | false-默认）延迟加载的全局开关。可使用 association、collection 的 fetchType （lazy|eager）属性覆盖；
aggressiveLazyLoading：（false| true-默认）当开启时，任何方法的调用都会加载该对象的所有属性。否则每个属性会按需加载；

1. demo

public class User {
  private Integer id;
  private String name;
  private User lazy1;
  private User lazy2;
  private List lazy3;
  ...
 }

@Test
void test() {
  try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
    Mapper mapper = sqlSession.getMapper(Mapper.class);
    User user = mapper.getUser(1);
    System.out.println("----getLazy1: " + user.getLazy1());
    System.out.println("----getLazy2: " + user.getLazy2());
    System.out.println("----getLazy3: " + user.getLazy3());
  }
}

打印：

DEBUG [main] - ==> Preparing: select * from users where id = ?
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - ====> Preparing: select 12 id, 'lazy2' name from (values(0))
DEBUG [main] - ====> Parameters:
DEBUG [main] - <==== Total: 1
DEBUG [main] - <== Total: 1
DEBUG [main] - ==> Preparing: select 11 id, 'lazy1' name from (values(0))
DEBUG [main] - ==> Parameters:
DEBUG [main] - <== Total: 1
----getLazy1: User{id=11, name='lazy1'}
----getLazy2: User{id=12, name='lazy2'}
DEBUG [main] - ==> Preparing: select 13 id, 'lazy3' name from (values(0))
DEBUG [main] - ==> Parameters:
DEBUG [main] - <== Total: 1
----getLazy3: [User{id=13, name='lazy3'}]

从打印的顺序可以看出当 mapper.getUser(1) 的时候，就已经获取了 user 和 lazy2，而 lazy1 和 lazy3 则是在 get 的时候才加载；这里在看一下 aggressiveLazyLoading = true 的效果：

打印：

DEBUG [main] - ==> Preparing: select * from users where id = ?
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - ====> Preparing: select 12 id, 'lazy2' name from (values(0))
DEBUG [main] - ====> Parameters:
DEBUG [main] - <==== Total: 1
DEBUG [main] - ====> Preparing: select 11 id, 'lazy1' name from (values(0))
DEBUG [main] - ====> Parameters:
DEBUG [main] - <==== Total: 1
DEBUG [main] - ====> Preparing: select 13 id, 'lazy3' name from (values(0))
DEBUG [main] - ====> Parameters:
DEBUG [main] - <==== Total: 1
DEBUG [main] - <== Total: 1
----getLazy1: User{id=11, name='lazy1'}
----getLazy2: User{id=12, name='lazy2'}
----getLazy3: [User{id=13, name='lazy3'}]

这里也能看到首先是获取 user 和 lazy2，然后在 user.getLazy1() 的时候同时加载了 lazy1 和 lazy3；

2. 创建代理

在上面已经讲过了，在使用延迟加载的时候：

首先判断是否有延迟加载属性，有就使用代理包装结果集对象；
然后判断一级缓存中时候有对应的外部嵌套，有就取缓存；如果没有就将外部嵌套包装为 ResultLoader 对象；
然后判断外部嵌套是否需要延迟加载，如果是就将 ResultLoader 加入到 ResultLoaderMap 中，如果不需要就直接加载 resultLoader.loadResult();

创建代理：首先获取代理工厂，然后创建代理类；

private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, ResultLoaderMap lazyLoader, String columnPrefix) throws SQLException {
  this.useConstructorMappings = false; // reset previous mapping result
  final List> constructorArgTypes = new ArrayList<>();
  final List