MyBatis 源码解析

本文主要是介绍MyBatis 源码解析，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

本文源码解析针对的是 MyBatis 3.4.4

MyBatis 执行流程

第一阶段

MyBatis 在这个阶段获得 Mapper 的动态代理对象，具体逻辑如下图所示：

其中，Configuration 类和 MapperRegistry 都是在创建 SqlSession 对象时对相关的 MyBatis 配置文件和 Mapper XML 映射文件进行加载的，因此不需要做过多的深入

生成动态代理对象的主要逻辑在 MapperProxyFactory 类中，通过传入的接口的类型来生成对应的代理对象，主要的源代码如下：

// 使用 JDK 动态代理的方式生成对应的代理对象
protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] {mapperInterface}, mapperProxy);
}

public T newInstance(SqlSession sqlSession) {

    /**
    * 创建MapperProxy对象，每次调用都会创建新的MapperProxy对象，MapperProxy implements InvocationHandler
    *
    * MapperProxy 是真正执行 SQL 语句的地方
    */
    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
}

第二阶段

该阶段的主要任务是生成对应的 Mapper 接口方法对象

通过第一阶段得到的 Mapper 对象，当使用 Mapper 接口的相关方法时，由于 MyBatis 使用的是 JDK 的动态代理，因此对于 Mapper 接口的任何方法的调用都会调用到代理对象的 invoke() 方法，在 MyaBatis 当前的上下文环境中，该 inboke() 方法的具体逻辑如下图所示：

具体的源代码如下所示：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
        /*
        	如果当前执行的方法对象对应的方法是 Object 的方法，如 hash()、toString()、equals() 等，那么直接执行 Object 的方法
        */
        if (Object.class.equals(method.getDeclaringClass())) {
            return method.invoke(this, args);
        }

        /*
        	由于较高版本的 JDK 允许接口定义 default 方法，因此遇到这类方法时优先执行这类方法
        */
        else if (isDefaultMethod(method)) {
            return invokeDefaultMethod(proxy, method, args);
        }
    } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
    }

    /*
    	如果不是 Object 的方法或者接口的 default 方法，那么就需要加载对应的具体方法了
    */
    final MapperMethod mapperMethod = cachedMapperMethod(method);

    /*
    	获得对应的 MapperMethod 对象后，需要执行 MapperMethod 的 execute() 方法，这个方法是实际 SQL 的执行点
    */
    return mapperMethod.execute(sqlSession, args);
}

具体来讲， MapperMethod 是真正处理逻辑的地方。获取 MapperMethod的过程如下：首先从对应的缓存中查找是否存在对应的 MapperMethod 方法，如果存在则直接村缓存中获取到这个 MaperMethod 对象，否则的话就需要生成一个新的 MapperMethod 对象，同时将这个新的 MapperMethod 对象放入缓存中。具体的流程如下图所示：

其中，关键的部分是实例化 MapperMethod 对象，因为具体的逻辑都是在实例化 MapperMethod 对象时指定了的。

对应的源代码如下：

private MapperMethod cachedMapperMethod(Method method) {
    /**
    * 在缓存中查找MapperMethod，若没有，则创建MapperMethod对象，并添加到methodCache集合中缓存
    */
    MapperMethod mapperMethod = methodCache.get(method);
    // 构建mapperMethod对象，并维护到缓存methodCache中
    if (mapperMethod == null) {
        mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
        methodCache.put(method, mapperMethod); // 这里的 methodCache 使用 ConcurrentHashMap 作为缓存的集合
    }
    return mapperMethod;
}

现在关键的部分就是 MapperMethod 的实例化过程了。实例化 MapperMethod 主要的工作就是实例化 SqlCommand 对象和 MethodSignature 对象。

对应的源代码如下所示：

public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
    this.command = new SqlCommand(config, mapperInterface, method); // 实例化 SqlCommane 对象
    this.method = new MethodSignature(config, mapperInterface, method); // 实例化 MethodSignature 对象
}

`SqlCommand` 的实例化

SqlCommand 对象只存储两个属性字段：一个是 MapperStatement 的唯一标识 name；另一个是这个 MapperMethod 执行的 Sql 语句的类型 type（"SELECT"、“UPDATE”、“INSERT” 等）

具体源代码如下所示：

// SqlCommand 是 MapperMethod 的一个静态类
public static class SqlCommand {
    /** MappedStatement的唯一标识 */
    private final String name;

    /** sql的命令类型 UNKNOWN, INSERT, UPDATE, DELETE, SELECT, FLUSH; */
    private final SqlCommandType type;
    
    // 省略构造函数和其他的源代码
}

对于 SqlCommand 的实例化，具体的初始化流程如下所示：

SqlCommand 初始化的主要部分在于如何通过传入的方法和接口类来加载对应的 MapperStatement 对象，具体的源代码如下所示：

private MappedStatement resolveMappedStatement(Class<?> mapperInterface, String methodName,
                                               Class<?> declaringClass, Configuration configuration) {
    String statementId = mapperInterface.getName() + "." + methodName;
    // 在 Configuration 对象中查找是否存在该方法。注意，这里的方法名是 "类的全限定名.方法名"
    if (configuration.hasStatement(statementId)) {
        // 如果能够查找到，那么返回这个 MapperStatement 对象
        return configuration.getMappedStatement(statementId);
    } else if (mapperInterface.equals(declaringClass)) { // 传入的接口类和声明的类一样，那么就没有必要再去向父接口再去查找了
        return null;
    }
    
    // 这个方法在当前接口无法找到，那么将会递归处理父接口，以此来查找对应的方法
    for (Class<?> superInterface : mapperInterface.getInterfaces()) {
        if (declaringClass.isAssignableFrom(superInterface)) {
            MappedStatement ms = resolveMappedStatement(superInterface, methodName,
                                                        declaringClass, configuration);
            if (ms != null) {
                return ms;
            }
        }
    }
    return null;
}

`MethodSignature` 实例化

MethodSignature 主要的任务是维护方法签名，如方法的返回值类型、入参名称等。

MethodSignature 的属性字段如下所示：

private final boolean returnsMany;                  // 判断返回类型是集合或者数组吗
private final boolean returnsMap;                   // 判断返回类型是Map类型吗
private final boolean returnsVoid;                  // 判断返回类型是集void吗
private final boolean returnsCursor;                // 判断返回类型是Cursor类型吗
private final Class<?> returnType;                  // 方法返回类型
private final String mapKey;                        // 获得@MapKey注解里面的value值
private final Integer resultHandlerIndex;           // 入参为ResultHandler类型的下标号
private final Integer rowBoundsIndex;               // 入参为RowBounds类型的下标号
private final ParamNameResolver paramNameResolver;  // 入参名称解析器

MethodSignature 实例化的主要任务就是解析传入的方法对象，初始化这些属性字段。

对应的源代码如下所示：

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

    /** 判断returnType是否为集合或者数组 */
    this.returnsMany = (configuration.getObjectFactory().isCollection(this.returnType) || this.returnType.isArray());
    
    this.returnsCursor = Cursor.class.equals(this.returnType);

    /** 判断returnType是否为 Map 类型 */
    this.mapKey = getMapKey(method);
    this.returnsMap = (this.mapKey != null);

    /** 获得方法 method 中，入参为 RowBounds 类型的下标号 */
    this.rowBoundsIndex = getUniqueParamIndex(method, RowBounds.class);
    
    /** 获得方法method中，入参为ResultHandler类型的下标号 */
    this.resultHandlerIndex = getUniqueParamIndex(method, ResultHandler.class);

    /** 生成paramNameResolver实例对象, 构造方法中已经对参数序号和参数名称进行了映射 */
    this.paramNameResolver = new ParamNameResolver(configuration, method);
}

值得注意的是对于参数的解析，具体的源代码如下所示：

// 解析方法入参，维护到names中。
public ParamNameResolver(Configuration config, Method method) {
    final Class<?>[] paramTypes = method.getParameterTypes();
    
    /*
    	由于一个方法参数可以被多个注解修饰，因此需要使用一个二维数组来存储这些注解信息
    	这个二维数组是从做向右开始遍历的，第一维表示参数顺序，第二维表示修饰的注解
    */
    final Annotation[][] paramAnnotations = method.getParameterAnnotations();
    
    // 这个 Map 维护的是参数位置索引和参数名称之间的映射关系。通过这个 Map，在之后的实际传入参数处理中将会十分方便
    final SortedMap<Integer, String> map = new TreeMap<>();
    
    int paramCount = paramAnnotations.length;
    
    // 处理被 @Param 注解修饰的参数
    for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
        // 判断是否是特殊的参数——即：RowBounds.class或ResultHandler.class
        if (isSpecialParameter(paramTypes[paramIndex])) {
            continue;
        }
        String name = null;
        
        // 通过 @Param 得到对应的 SQL 参数的名称
        for (Annotation annotation : paramAnnotations[paramIndex]) {
            if (annotation instanceof Param) {
                hasParamAnnotation = true;
                name = ((Param) annotation).value();
                break;
            }
        }
        // 对于没有使用 @Param 注解修饰的参数，将会通过实际 SQL 中使用的参数进行关联
        if (name == null) {
            /** @Param was not specified；useActualParamName默认值为true*/
            if (config.isUseActualParamName()) {
                /** use the parameter index as the name ("arg0", "arg1", ...) */
                name = getActualParamName(method, paramIndex);
            }
            if (name == null) {
                /** use the parameter index as the name ("0", "1", ...) */
                name = String.valueOf(map.size());
            }
        }
        map.put(paramIndex, name);
    }
    // 这个映射关系应当是不能被修改的
    names = Collections.unmodifiableSortedMap(map);
}

第三阶段

这个阶段的主要任务是通过第二阶段生成的 SqlCommand 对象，选择合适的执行 SQL 的方法。

具体流程如下所示：

以执行 SELECT 类型的 SQL 语句为例，假设查询返回的是单个的对象（其它的类似），首先会将方法中传入的查询参数与 SQL 中的参数进行转换，这个过程是在 ParamNameResolver 的 getNamedParams(Object[] args) 方法中完成额。具体的源代码如下所示：

// 将传入的参数与 SQL 中需要的参数对应起来
public Object getNamedParams(Object[] args) {
    // eg1: names={0:"id"} paramCount=1
    final int paramCount = names.size();
    if (args == null || paramCount == 0) {
        return null;
    }

    /** 
    	如果不包含@Param注解并且只有一个入参，那么这个参数就是唯一确定的
    */
    else if (!hasParamAnnotation && paramCount == 1) {
        return args[names.firstKey()]; // 0 -> "arg0"
    } else {
        final Map<String, Object> param = new ParamMap<>();
        int i = 0;
        // 遍历在创建 MethodSignature 过程中解析参数时得到的 Map，设置每个参数对应的实际参数
        for (Map.Entry<Integer, String> entry : names.entrySet()) {
            // 将 SQL 中的处理参数与传入的参数进行绑定
            param.put(entry.getValue(), args[entry.getKey()]);

            /**
            * add generic param names (param1, param2, ...)
            */
            final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);

            /**
            * ensure not to overwrite parameter named with @Param
            */
            if (!names.containsValue(genericParamName)) {
                param.put(genericParamName, args[entry.getKey()]);
            }
            i++;
        }
        
        return param;
    }
}

由于具体的 SQL 语句在打开 SqlSession 时就已经加载了，因此执行 SQL 的时候只需要从配置中拿到这个对应的 SQL，再通过解析的参数进行查询即可。

第四阶段

这个阶段的主要任务是处理真正查询之前的缓存。

实例化 `BoundSql` 对象

BoundSql 对象的主要任务是用于建立 SQL 和对应的参数，一个 BoundSql 对象的实例化流程如下：

实例化的 BoundSql ——> StaticSqlSource ——> RawSqlSource ——> MapperStatement ——> CachingExecutor

主要需要关注的地方是 MapperStatement 中对于 BoundSql实例对象的处理：

// BoundSql 是为了将 Mapper XML 中的参数进行转化，即原来为参数的地方要转换为 '?' 以及其对应位置的对应参数映射信息等
public BoundSql getBoundSql(Object parameterObject) {
    // 这里的 BoundSql 对象来自 RawSqlSource
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);

    // 获得相关的参数信息
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();

    // 如果参数信息为空，那么将会重新实例化一个 BoundSql 对象
    if (parameterMappings == null || parameterMappings.isEmpty()) {
        boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
    }

    /**
    * 处理结果映射，对应 Mapper XML 映射文件的 resultMap 属性
    */
    for (ParameterMapping pm : boundSql.getParameterMappings()) {
        String rmId = pm.getResultMapId();
        // eg1: rmId = null
        if (rmId != null) {
            ResultMap rm = configuration.getResultMap(rmId);
            if (rm != null) {
                hasNestedResultMaps |= rm.hasNestedResultMaps();
            }
        }
    }

    return boundSql;
}

缓存的处理

在 CachingExecutor 的 query(MappedStatement ms, Object parameterObject, RowBounds rowBounds,ResultHandler resultHandler) 方法中，在获取了 BoundSql 对象之后，将会创建缓存 key，作为本次查询结果的 key。这里创建缓存 key 的任务是有 BaseExecutor 的 createCacheKey 方法来完成的。

对于二级缓存的处理

由于二级缓存实在 Mapper XML 映射文件中开启的，因此它只能针对特定的 Mapper。

在执行查询时，首先会检测是否存在二级缓存，如果存在，那么就需要进一步地检测这个二级缓存是否是有效的；如果这个二级缓存是有效的，那么将会从二级缓存中进行读取数据，如果读取不到那么将会直接进行数据库的查询；如果这个二级缓存不是有效的，那么将会首先清除二级缓存，再从数据库中读取，再添加到二级缓存中。

对应的源代码如下所示：

Cache cache = ms.getCache();
// 如果开启了二级缓存，即在 Mapper XML 映射文件中添加了 <cache />，那么将能够检测到二级缓存的存在
if (cache != null) {
    /**
    * 如果flushCacheRequired=true并且缓存中有数据，则先清空缓存
    *
    * <select id="save" parameterType="XXXXXEO" statementType="CALLABLE" flushCache="true" useCache="false">
    *     ……
    * </select>
    * */
    flushCacheIfRequired(ms);

    if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, parameterObject, boundSql);
        @SuppressWarnings("unchecked")
        List<E> list = (List<E>) tcm.getObject(cache, key);
        if (list == null) {
            // 二级缓存中不存在对应数据，需要进行数据库的查询
            list = delegate.<E>query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
            // 以cacheKey为主键，将结果维护到缓存中
            tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
    }
}

对于一级缓存的处理

一级缓存的处理将在 BaseExecutor 中进行处理，具体的源代码如下所示：

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

    /** 如果配置了flushCacheRequired=true并且queryStack=0（没有正在执行的查询操作），则会执行清空缓存操作*/
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
        clearLocalCache();
    }

    List<E> list;
    try {
        /** 记录正在执行查询操作的任务数*/
        queryStack++;

        /** localCache维护一级缓存，试图从一级缓存中获取结果数据，如果有数据，则返回结果；如果没有数据，再执行queryFromDatabase */
        list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
        // eg1: list = 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();

        // eg1: configuration.getLocalCacheScope()=SESSION
        /** 如果设置了<setting name="localCacheScope" value="STATEMENT"/>，则会每次执行完清空缓存。即：使得一级缓存失效 */
        if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
            // issue #482
            clearLocalCache();
        }
    }
    return list;
}

第五阶段

这个阶段的任务是预执行 SQL，然后设置相关的参数，执行相关的 SQL 语句

SQL 的预处理

调用链为 SimpleExecutor ——> PreparedStatementHandler ——> BaseStatementHandler ——> PreparedStatementHandler

对应的源代码如下所示：

@Override
protected Statement instantiateStatement(Connection connection) throws SQLException {
    // 这里的 SQL 是经过参数映射转换的，即有参数的地方已经转换为了 '?'
    String sql = boundSql.getSql();

    if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {
        String[] keyColumnNames = mappedStatement.getKeyColumns();
        if (keyColumnNames == null) {
            return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
        } else {
            return connection.prepareStatement(sql, keyColumnNames);
        }
    } else if (mappedStatement.getResultSetType() != null) {
        return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(),
                                           ResultSet.CONCUR_READ_ONLY);
    } else {
        // 预执行 SQL 语句
        return connection.prepareStatement(sql);
    }
}

除了预处理 SQL 之外，在这个过程中还会设置 SQL 语句的最大执行时间和要获取的数据行的个数等信息（分页的操作就在这里处理）

对预处理的 SQL 设置对应的参数

通过对 SQL 的预处理，下一步就是设置对应的参数，设置了参数之后的 SQL 就可以直接被执行

具体设置参数的源代码如下所示：

// 设置参数的工作是由 DefaultParameterHandler 类进行处理的
public void setParameters(PreparedStatement ps) {
    ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
    
    // 之前在实例化 BoundSql 的过程中已经设置了相关的参数映射关系
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings != null) {
        // 遍历这个参数映射集合，将对应的参数放到正确的位置上
        for (int i = 0; i < parameterMappings.size(); i++) {
            ParameterMapping parameterMapping = parameterMappings.get(i);
            // eg1: parameterMapping.getMode() = IN
            if (parameterMapping.getMode() != ParameterMode.OUT) {
                // 从传入的参数中获取值
                Object value;
                String propertyName = parameterMapping.getProperty();
                if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
                    value = boundSql.getAdditionalParameter(propertyName);
                } else if (parameterObject == null) {
                    value = null;
                } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
                    // 对于一般的基本数据类型的装箱类，都有对应的 typeHandler
                    value = parameterObject;
                } else {
                    // 传入的是一个实体对象，那么需要通过反射的方式从这个对象中获取对应的属性值
                    MetaObject metaObject = configuration.newMetaObject(parameterObject);
                    value = metaObject.getValue(propertyName);
                }
                // 从参数对象中获取值的过程结束。。。。。。
                
                // 将数据库表中列的类型与对象属性字段的类型对应起来
                TypeHandler typeHandler = parameterMapping.getTypeHandler();
                JdbcType jdbcType = parameterMapping.getJdbcType();
                if (value == null && jdbcType == null) {
                    jdbcType = configuration.getJdbcTypeForNull();
                }
                // 对应阶段结束
                
                // 针对预处理语句和得到的参数值，设置对应的 SQL 语句的实际参数
                typeHandler.setParameter(ps, i + 1, value, jdbcType);
            }
        }
    }
}

执行 SQL

通过上面的步骤，现在已经得到了一个可以执行的 SQL，这一步的主要任务是执行这个 SQL，同时将得到的结果进行包装

对应的源代码如下：

// 这里的任务是通过 PreparedStatementHandler 对象来完成的
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    // 调用 JDBC 的 PreparedStatement 去执行 SQL
    PreparedStatement ps = (PreparedStatement) statement;

    // 执行这个 SQL
    ps.execute();

    /** 将结果集进行封装 */
    return resultSetHandler.handleResultSets(ps);
}

在执行完 SQL 之后，将会删除旧的缓存，将这次从数据库中查找得到的数据保存到缓存（一级缓存）中

第六阶段

以查询数据为例，会调用 DefaultResultSetHandler 对象的 handleResultSets 方法来进行结果集的处理。

调用 getFirstResultSet 方法，获取执行之后的结果集，并且封装到 ResultSetWrapper 对象中，对应的源代码如下所示：

private ResultSetWrapper getFirstResultSet(Statement stmt) throws SQLException {
    /** 通过JDBC获得结果集ResultSet */
    ResultSet rs = stmt.getResultSet();
    while (rs == null) {
        if (stmt.getMoreResults()) {
            rs = stmt.getResultSet();
        } else {
            /**
            * getUpdateCount()==-1,既不是结果集,又不是更新计数了.说明没的返回了。
            * 如果getUpdateCount()>=0,则说明当前指针是更新计数(0的时候有可能是DDL指令)。
            * 无论是返回结果集或是更新计数,那么则可能还继续有其它返回。
            * 只有在当前指指针getResultSet()==null && getUpdateCount()==-1才说明没有再多的返回。
            */
            if (stmt.getUpdateCount() == -1) {
                // no more results. Must be no resultset
                break;
            }
        }
    }
    
    /** 将结果集ResultSet封装到ResultSetWrapper实例中 */
    return rs != null ? new ResultSetWrapper(rs, configuration) : null;
}

从 MappeedStatement 对象中获取 ResultMap 列表（还记得 Mapper XML 中配置的 resultMap 吗？）

遍历 ResultMap 集合，针对每个 ResultMap 对象进行相应的处理，对应的源代码如下所示：

final List<Object> multipleResults = new ArrayList<>(); // 存储 ResultMap
int resultSetCount = 0;
// 从 MappedStatement 对象中获取对应的 ResultMap 列表
List<ResultMap> resultMaps = mappedStatement.getResultMaps();
int resultMapCount = resultMaps.size();
while (rsw != null && resultMapCount > resultSetCount) {
    // 遍历每个 ResultMap 对象
    ResultMap resultMap = resultMaps.get(resultSetCount);

    /** 处理结果集, 存储在 multipleResults 中 */
    handleResultSet(rsw, resultMap, multipleResults, null);
    
    // 通过游标的方式获取下一条数据
    rsw = getNextResultSet(stmt);

    cleanUpAfterHandlingResultSet();
    resultSetCount++;
}

第三步的主要任务是处理结果集，对应的源代码如下所示：

// 此方法位于 DefaultResultSetHandler 对象中
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) {
                /** 初始化ResultHandler实例，用于解析查询结果并存储于该实例对象中 */
                DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
                /** 解析行数据 */
                handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
                multipleResults.add(defaultResultHandler.getResultList());
            } else {
                handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
            }
        }
    } finally {
        /** 关闭ResultSet */
        closeResultSet(rsw.getResultSet());
    }
}

最终都会调用 DefaultResultSetHandler 的 handleRowValues 方法，对指定的行数据进行处理

这一步的任务主要是针对不同的返回结果进行一个选择，针对不同的返回结果进行处理

public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler,
                            RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
    /** 是否是聚合Nested类型的结果集 */
    if (resultMap.hasNestedResultMaps()) {
        ensureNoRowBounds();
        checkResultHandler();
        // 针对 NestedResultMap 的结果进行处理
        handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    } else {
        // 针对 SimpleResultMap进行处理
        handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    }
}

这里以简单查询为例，因此最终会执行 handleRowValuesForSimpleResultMap方法

这一步的主要任务是处理行数据，对应的源代码如下所示

private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap,
                                               ResultHandler<?> resultHandler, RowBounds rowBounds,
                                               ResultMapping parentMapping) throws SQLException {
    DefaultResultContext<Object> resultContext = new DefaultResultContext<>();

    /**
    	将指针移动到rowBounds.getOffset()指定的行号，即：略过（skip）offset之前的行 
    */
    skipRows(rsw.getResultSet(), rowBounds);

    while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
        /** 
        	解析结果集中的鉴别器<discriminate/>，即鉴别器
        	这个一般来讲不会遇到，因此一般为 null
        */
        ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);

        /** 
        	将数据库操作结果保存到POJO并返回，这里是真正处理数据的地方
        */
        Object rowValue = getRowValue(rsw, discriminatedResultMap);

        /**
        	存储POJO对象到DefaultResultHandler中 
        */
        storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
    }
}

getRowValue，对应的源代码如下：

/**
* 将数据库操作结果保存到 POJO 并返回
*/
private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap) throws SQLException {
    final ResultLoaderMap lazyLoader = new ResultLoaderMap();
    /** 创建空的结果对象 */
    Object rowValue = createResultObject(rsw, resultMap, lazyLoader, null);
    
    /*
    	对这个返回结果执行对应的 typeHandler；如果这个 resultType 不存在 typeHandler，则直接返回原来的对象
    */
    if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
        /** 
        	创建rowValue的metaObject 
        */
        final MetaObject metaObject = configuration.newMetaObject(rowValue);

        boolean foundValues = this.useConstructorMappings;

        /** 是否应用自动映射 */
        if (shouldApplyAutomaticMappings(resultMap, false)) {
            /**
            * 将查询出来的值赋值给metaObject中的POJO对象
            */
            foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, null) || foundValues;
        }

        foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, null) || foundValues;

        foundValues = lazyLoader.size() > 0 || foundValues;
        
        /** 
        	configuration.isReturnInstanceForEmptyRow() 当返回行的所有列都是空时，MyBatis默认返回null。
        	当开启这个设置时，MyBatis会返回一个空实例。
        */
        rowValue = (foundValues || configuration.isReturnInstanceForEmptyRow()) ? rowValue : null;
    }
    return rowValue;
}

其中，最主要的两部分是调用createResultObject方法创建一个结果对象和调用 applyAutomaticMappings 方法将查询到的数据赋值到创建的结果对象中。

createResultObject 的源代码如下：

private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, ResultLoaderMap lazyLoader,
                                  String columnPrefix) throws SQLException {
    this.useConstructorMappings = false; // 重置原来的映射关系
    final List<Class<?>> constructorArgTypes = new ArrayList<>();
    final List<Object> constructorArgs = new ArrayList<>();

    /**
    	创建一个空的resultMap.getType()类型的实例对象 
    */
    Object resultObject = createResultObject(rsw, resultMap, constructorArgTypes, constructorArgs, columnPrefix);

    /** 
    	判断resultMap.getType() 是否存在TypeHandler
    */
    if (resultObject != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
        final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();

        for (ResultMapping propertyMapping : propertyMappings) {
            /** 
            	如果是聚合查询并且配置了懒加载 
            */
            if (propertyMapping.getNestedQueryId() != null && propertyMapping.isLazy()) {
                resultObject = configuration.getProxyFactory()
                    .createProxy(resultObject, lazyLoader, configuration,
                                 objectFactory, constructorArgTypes, constructorArgs);
                break;
            }
        }
    }
    
    this.useConstructorMappings = (resultObject != null && !constructorArgTypes.isEmpty());

    return resultObject;
}

applyAutomaticMappings 的源代码如下所示：

private boolean applyAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject,
                                       String columnPrefix) throws SQLException {
    /** 
    	创建自动映射集合 
    */
    List<UnMappedColumnAutoMapping> autoMapping = createAutomaticMappings(rsw, resultMap, metaObject, columnPrefix);
    boolean foundValues = false;
    
    if (autoMapping.size() > 0) {
        // 遍历这些映射的对象，从对应的列中获取数据
        for (UnMappedColumnAutoMapping mapping : autoMapping) {
            final Object value = mapping.typeHandler.getResult(rsw.getResultSet(), mapping.column);
            if (value != null) {
                foundValues = true;
            }
            
            if (value != null || (configuration.isCallSettersOnNulls() && !mapping.primitive)) {
                // 将查询到的数据放到对应的属性中
                metaObject.setValue(mapping.property, value);
            }
        }
    }
    return foundValues;
}

UnMappedColumnAutoMapping 类定义如下：

private static class UnMappedColumnAutoMapping {
    private final String column;
    private final String property;
    private final TypeHandler<?> typeHandler;
    private final boolean primitive;

    public UnMappedColumnAutoMapping(String column, String property, TypeHandler<?> typeHandler,
                                     boolean primitive) {
        this.column = column;
        this.property = property;
        this.typeHandler = typeHandler;
        this.primitive = primitive;
    }
}

storeObject，主要的任务是将查询到的 POJO 对象存储到 ResultHandler对象中（这里是 DefaultResultHandler）

private void storeObject(ResultHandler<?> resultHandler, DefaultResultContext<Object> resultContext,
                         Object rowValue, ResultMapping parentMapping, ResultSet rs) throws SQLException {
    if (parentMapping != null) {
        linkToParents(rs, parentMapping, rowValue);
    } else {
        /** 将结果存储到DefaultResultHandler中 */
        callResultHandler(resultHandler, resultContext, rowValue);
    }
}

这篇关于MyBatis 源码解析的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程