Mybatis源码分析之Select返回数据分析

Posted 2022-08-22 叶长风

Mybatis源码分析之Select返回数据分析

在之前的一篇文章中分析了@Select注解的使用方法,在查询方法中我们知可以返回Map类型，也可以返回指针，或者是list集合，或是单条记录，今天就对这几种返回做一个源码分析。

Select查询

---

在这里就不需要再写一个demo演示了，用法无非这么多，直接看查询的源码吧。

首先在看对应select的查询源码时先看下MyBatis是怎么定义method的返回类型的，这里在将method包装成MappedMethod时可以得到对应返回类型。

//返回的MapperProxy代理对象中包装method
final MapperMethod mapperMethod = cachedMapperMethod(method);

private MapperMethod cachedMapperMethod(Method method) 
    MapperMethod mapperMethod = methodCache.get(method);
    if (mapperMethod == null) 
      mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
      methodCache.put(method, mapperMethod);
    
    return mapperMethod;
  

  public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) 
    this.command = new SqlCommand(config, mapperInterface, method);
    this.method = new MethodSignature(config, mapperInterface, method);
  

public MethodSignature(Configuration configuration, Class<?> mapperInterface, Method method) 
      Type resolvedReturnType = TypeParameterResolver.resolveReturnType(method, mapperInterface);
      if (resolvedReturnType instanceof Class<?>) 
        this.returnType = (Class<?>) resolvedReturnType;
       else if (resolvedReturnType instanceof ParameterizedType) 
        this.returnType = (Class<?>) ((ParameterizedType) resolvedReturnType).getRawType();
       else 
        this.returnType = method.getReturnType();
      
      this.returnsVoid = void.class.equals(this.returnType);
      this.returnsMany = configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray();
      this.returnsCursor = Cursor.class.equals(this.returnType);
      this.mapKey = getMapKey(method);
      this.returnsMap = this.mapKey != null;
      this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
      this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);
      this.paramNameResolver = new ParamNameResolver(configuration, method);
    

可以看到，在MethodSignature方法中对各种返回值类型进行了判断，因此有了下面的SELECT方法个对返回类型的判断从而使用不同SELECT逻辑。

case SELECT:
        if (method.returnsVoid() && method.hasResultHandler()) 
          executeWithResultHandler(sqlSession, args);
          result = null;
         else if (method.returnsMany()) 
          result = executeForMany(sqlSession, args);
         else if (method.returnsMap()) 
          result = executeForMap(sqlSession, args);
         else if (method.returnsCursor()) 
          result = executeForCursor(sqlSession, args);
         else 
          Object param = method.convertArgsToSqlCommandParam(args);
          result = sqlSession.selectOne(command.getName(), param);
        

就是以上五种情况，第一种返回void，这种还是比较少见的，不做分析。

第二种条件，如果是返回多条数据的，就是返回一个List列表，根据之前的源码分析，executeForMany和selectOne最终调用方法应该是一致的，应该从前文中分析得知selectOne最终还是调用selectList方法，只是对返回结果进行了判断，size大于1时抛出错误。

先转到executeForMany方法，如下：

private <E> Object executeForMany(SqlSession sqlSession, Object[] args) 
    List<E> result;
    Object param = method.convertArgsToSqlCommandParam(args);
    if (method.hasRowBounds()) 
      RowBounds rowBounds = method.extractRowBounds(args);
      result = sqlSession.<E>selectList(command.getName(), param, rowBounds);
     else 
      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;
  

和预想的差不多，调用selectList得到返回结果，但是在返回时对具体返回类型进行了判断，针对返回类型是数组还是集合对查询结果做了不同的包装。对convertToArray和方法convertToDeclaredCollection没必要再去看实现，无非就是List集合转Array或者直接返回之类的。

现在看第二种返回类型，返回类型为Map的，先做个猜测吧，有可能也是调用的selectList方法，然后将返回值放在map中，转到executeForMap方法看看具体吧。

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);
      result = sqlSession.<K, V>selectMap(command.getName(), param, method.getMapKey(), rowBounds);
     else 
      result = sqlSession.<K, V>selectMap(command.getName(), param, method.getMapKey());
    
    return result;
  

session调用的是selectMap方法，和预想中还是有一些不同的，有些意思，继续转到selectMap方法中。

@Override
  public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) 
    final List<? extends V> list = selectList(statement, parameter, rowBounds);
    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();
  

底层还是调用的selectList方法，倒也是没怎么出乎意料之外，基本上其他查询方法都能用selectList包装出来，在查询出结果后，再对结果进行包装，最后返回map，不过这里最开始还是有一个疑惑，就是这里查询出来的list是单条记录的kv的集合还是多条数据库中查询出来的记录，后来我做了个测试，在mapper中加一个返回map的方法，然后再用session调用一下，具体演示源码就不展示了，然后发现如果直接定义返回类型是Map集合的时候仍然调用的是SELECT中的最后一种情况，就是返回单条记录，然后我又把上面的查询map的条件再看了一遍，在MethodSignature方法中，判断当前方法的返回值是否是map类型，还增加了如下判断：

this.mapKey = getMapKey(method);
this.returnsMap = this.mapKey != null;

private String getMapKey(Method method) 
      String mapKey = null;
      if (Map.class.isAssignableFrom(method.getReturnType())) 
        final MapKey mapKeyAnnotation = method.getAnnotation(MapKey.class);
        if (mapKeyAnnotation != null) 
          mapKey = mapKeyAnnotation.value();
        
      
      return mapKey;
    
  

这里加了一个对方法上是否加了MapKey注解的方法判断，如果有MapKey则认为当前值返回Map类型，如果不是则按返回多条或者单条来处理，这里倒是挺有意思，以后找个时间把返回Map和加上MapKey的效果一起写一篇文章出来。

对返回Map类型分析就到此为止了，我们继续看返回类型为指针的。

else if (method.returnsCursor()) 
          result = executeForCursor(sqlSession, args);

要说返回类型为指针，最早见到使用指针移到返回一条条记录的，还是在C语言里面看到过一回，然后后来写python的时候，使用pymysql的时候，其他不多说，转到executeForCursor方法。

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);
      result = sqlSession.<T>selectCursor(command.getName(), param, rowBounds);
     else 
      result = sqlSession.<T>selectCursor(command.getName(), param);
    
    return result;
  

底层调用的仍然是sqlSession中的selectCursor方法，继续追溯。

@Override
  public <T> Cursor<T> selectCursor(String statement, Object parameter, RowBounds rowBounds) 
    try 
      MappedStatement ms = configuration.getMappedStatement(statement);
      Cursor<T> cursor = executor.queryCursor(ms, wrapCollection(parameter), rowBounds);
      registerCursor(cursor);
      return cursor;
     catch (Exception e) 
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
     finally 
      ErrorContext.instance().reset();
    
  

@Override
  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());
    return handler.<E>queryCursor(stmt);
  

@Override
  public <E> Cursor<E> queryCursor(Statement statement) throws SQLException 
    String sql = boundSql.getSql();
    statement.execute(sql);
    return resultSetHandler.<E>handleCursorResultSets(statement);
  

这里挺有意思，最终到StatementHandler还是调用了execute方法，然后对当前statement对象做了一层包装，可以继续看看handleCursorResultSets。

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

这个方法做的事情就是继续包装statement对象，获取到statement返回的第一条结果，然后将resultMap、包装对象rsw、rowBounds包装为DefaultCursor对象返回。这里有空以后继续深究一下。

最后一种SELECT其实就没有太多可以分析的，前面文章中几乎都是对selectOne查看的源码。

---

对Select几种查询的分析就到这了，不过对于MapKey和Cursor这几种以后有空可以继续探索一下，还是挺有意思的。