八、SqlSession 执行 Mapper 过程详解

水深无声 2023-01-21 05:25 280阅读 0赞

*  源码地址：https://github.com/RononoaZoro/mybatis-book/tree/master 的 mybatis-book ( mybatis-chapter06 )
 *  文章内容出自《Mybatis 3 源码深度解析》第六章
 *  自己实现代码地址：https://github.com/RononoaZoro/mybatis-book/tree/master 的 archer-mybatis

package com.blog4java.mybatis.example;
    
    import com.alibaba.fastjson.JSON;
    import com.blog4java.common.DbUtils;
    import com.blog4java.mybatis.example.entity.UserEntity;
    import com.blog4java.mybatis.example.mapper.UserMapper;
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.apache.ibatis.session.SqlSessionManager;
    import org.junit.Before;
    import org.junit.Test;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.Reader;
    import java.util.List;
    
    public class MybatisExample {
        
    
        @Before
        public void initData() {
        
            DbUtils.initData();
        }
    
        @Test
        public  void testMybatis () throws IOException {
        
            // 获取配置文件输入流
            InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
            // 通过SqlSessionFactoryBuilder的build()方法创建SqlSessionFactory实例
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            // 调用openSession()方法创建SqlSession实例
            SqlSession sqlSession = sqlSessionFactory.openSession();
            // 获取UserMapper代理对象
            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
            // 执行Mapper方法，获取执行结果
            List<UserEntity> userList = userMapper.listAllUser();
             /*
            // 兼容Ibatis，通过Mapper Id执行SQL操作
            List<UserEntity> userList = sqlSession.selectList(
                    "com.blog4java.mybatis.com.blog4java.mybatis.example.mapper.UserMapper.listAllUser");
            */
            System.out.println(JSON.toJSONString(userList));
        }
    }

## 1、核心配置类 Configuration 初始化 ##

*  参考 [Mybatis 核心对象之 Configuration 对象初始化详解][Mybatis _ Configuration]

## 2、创建 SqlSession 对象 ##

*  参考 [SqlSession 的创建过程以及 Executor 执行 SQL 过程详解][SqlSession _ Executor _ SQL]

## 3、获取 UserMapper 的动态代理对象 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyODY2NDk3_size_16_color_FFFFFF_t_70]

// 获取UserMapper代理对象
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

**SqlSession.java** 部分代码

public class SqlSession {
        
          /**
       * Retrieves a mapper.
       * @param <T> the mapper type
       * @param type Mapper interface class
       * @return a mapper bound to this SqlSession
       */
      <T> T getMapper(Class<T> type);
    }

**DefaultSqlSession.java** 部分代码

/**
     *
     * The default implementation for {@link SqlSession}.
     * Note that this class is not Thread-Safe.
     *
     * @author Clinton Begin
     */
    public class DefaultSqlSession implements SqlSession {
        
    
      private final Configuration configuration;
      private final Executor executor;
    
      private final boolean autoCommit;
      private boolean dirty;
      private List<Cursor<?>> cursorList;
    
      public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
        
        this.configuration = configuration;
        this.executor = executor;
        this.dirty = false;
        this.autoCommit = autoCommit;
      }
    
      public DefaultSqlSession(Configuration configuration, Executor executor) {
        
        this(configuration, executor, false);
      }  
        
        
      @Override
      public <T> T getMapper(Class<T> type) {
        
        return configuration.<T>getMapper(type, this);
      }
    }

**Configuration.java** 部分代码

public class Configuration {
          
        protected final MapperRegistry mapperRegistry = new MapperRegistry(this);
        
          public void addMappers(String packageName, Class<?> superType) {
        
            mapperRegistry.addMappers(packageName, superType);
          }
    
          public void addMappers(String packageName) {
        
            mapperRegistry.addMappers(packageName);
          }
    
          public <T> void addMapper(Class<T> type) {
        
            mapperRegistry.addMapper(type);
          }
        
          public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
        
            return mapperRegistry.getMapper(type, sqlSession);
          }
    }

**MapperRegistry.java** 部分代码

*  Configuration 初始化会填充 MapperRegistry 对象

public class MapperRegistry {
        
      // Configuration对象引用
      private final Configuration config;
      // 用于注册Mapper接口Class对象，和MapperProxyFactory对象对应关系
      private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<Class<?>, MapperProxyFactory<?>>();
    
      public MapperRegistry(Configuration config) {
        
        this.config = config;
      }
      // 根据Mapper接口Class对象获取Mapper动态代理对象
      @SuppressWarnings("unchecked")
      public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
        
        final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
        if (mapperProxyFactory == null) {
        
          throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
        }
        try {
        
          return mapperProxyFactory.newInstance(sqlSession);
        } catch (Exception e) {
        
          throw new BindingException("Error getting mapper instance. Cause: " + e, e);
        }
      }
    
      // 根据Mapper接口Class对象，创建MapperProxyFactory对象，并注册到knownMappers属性中
      public <T> void addMapper(Class<T> type) {
        
        if (type.isInterface()) {
        
          if (hasMapper(type)) {
        
            throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
          }
          boolean loadCompleted = false;
          try {
        
            knownMappers.put(type, new MapperProxyFactory<T>(type));
            // It's important that the type is added before the parser is run
            // otherwise the binding may automatically be attempted by the
            // mapper parser. If the type is already known, it won't try.
            MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
            parser.parse();
            loadCompleted = true;
          } finally {
        
            if (!loadCompleted) {
        
              knownMappers.remove(type);
            }
          }
        }
      }
    }

**MapperProxyFactory.java** 部分代码

*  默认使用 jdk 的 Proxy 生成 Mapper 的代理类
 *  > Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class\[\] \{ mapperInterface \}, mapperProxy)

public class MapperProxyFactory<T> {
        
    
      private final Class<T> mapperInterface;
      private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();
    
      public MapperProxyFactory(Class<T> mapperInterface) {
        
        this.mapperInterface = mapperInterface;
      }
    
      public Class<T> getMapperInterface() {
        
        return mapperInterface;
      }
    
      public Map<Method, MapperMethod> getMethodCache() {
        
        return methodCache;
      }
    
      @SuppressWarnings("unchecked")
      protected T newInstance(MapperProxy<T> mapperProxy) {
        
        return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] {
         mapperInterface }, mapperProxy);
      }
    
      public T newInstance(SqlSession sqlSession) {
        
        final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
        return newInstance(mapperProxy);
      }
    
    }

## 4、执行 Mapper 的增删查改方法 ##

// 执行Mapper方法，获取执行结果
    List<UserEntity> userList = userMapper.listAllUser();

### 4.1、执行代理类的 invoke 方法 ###

public class MapperProxy<T> implements InvocationHandler, Serializable {
        
    
      private static final long serialVersionUID = -6424540398559729838L;
      private final SqlSession sqlSession;
      private final Class<T> mapperInterface;
      private final Map<Method, MapperMethod> methodCache;
    
      public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
        
        this.sqlSession = sqlSession;
        this.mapperInterface = mapperInterface;
        this.methodCache = methodCache;
      }
    
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        try {
        
          // 从Object类继承的方法不做处理
          if (Object.class.equals(method.getDeclaringClass())) {
        
            return method.invoke(this, args);
          // jdk8 接口默认方法
          } else if (isDefaultMethod(method)) {
        
            return invokeDefaultMethod(proxy, method, args);
          }
        } catch (Throwable t) {
        
          throw ExceptionUtil.unwrapThrowable(t);
        }
        // 对Mapper接口中定义的方法进行封装，生成MapperMethod对象
        final MapperMethod mapperMethod = cachedMapperMethod(method);
        return mapperMethod.execute(sqlSession, args);
      }
    
      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;
      }
    }

**MapperMethod.java** 部分代码

public class MapperMethod {
        
    
        private final SqlCommand command;
        private final MethodSignature method;
    
        public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
        
            this.command = new SqlCommand(config, mapperInterface, method);
            this.method = new MethodSignature(config, mapperInterface, method);
        }
    
        public Object execute(SqlSession sqlSession, Object[] args) {
        
            Object result;
            // 其中command为MapperMethod构造是创建的SqlCommand对象
            // 获取SQL语句类型
            switch (command.getType()) {
        
                case INSERT: {
        
                    // 获取参数信息
                    Object param = method.convertArgsToSqlCommandParam(args);
                    // 调用SqlSession的insert（）方法，然后调用rowCountResult（）方法统计行数
                    result = rowCountResult(sqlSession.insert(command.getName(), param));
                    break;
                }
                case UPDATE: {
        
                    Object param = method.convertArgsToSqlCommandParam(args);
                    // 调用SqlSession对象的update（）方法
                    result = rowCountResult(sqlSession.update(command.getName(), param));
                    break;
                }
                case DELETE: {
        
                    Object param = method.convertArgsToSqlCommandParam(args);
                    result = rowCountResult(sqlSession.delete(command.getName(), param));
                    break;
                }
                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);
                        if (method.returnsOptional() &&
                                (result == null || !method.getReturnType().equals(result.getClass()))) {
        
                            result = OptionalUtil.ofNullable(result);
                        }
                    }
                    break;
                case FLUSH:
                    result = sqlSession.flushStatements();
                    break;
                default:
                    throw new BindingException("Unknown execution method for: " + command.getName());
            }
            if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
        
                throw new BindingException("Mapper method '" + command.getName()
                        + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
            }
            return result;
        }
    }

### 4.2、执行 SQL ###

**MapperMethod.java** 部分代码

public class MapperMethod {
        
         private Object rowCountResult(int rowCount) {
        
            final Object result;
            if (method.returnsVoid()) {
        
                result = null;
            } else if (Integer.class.equals(method.getReturnType()) || Integer.TYPE.equals(method.getReturnType())) {
        
                result = rowCount;
            } else if (Long.class.equals(method.getReturnType()) || Long.TYPE.equals(method.getReturnType())) {
        
                result = (long) rowCount;
            } else if (Boolean.class.equals(method.getReturnType()) || Boolean.TYPE.equals(method.getReturnType())) {
        
                result = rowCount > 0;
            } else {
        
                throw new BindingException("Mapper method '" + command.getName() + "' has an unsupported return type: " + method.getReturnType());
            }
            return result;
        }
    
        private void executeWithResultHandler(SqlSession sqlSession, Object[] args) {
        
            MappedStatement ms = sqlSession.getConfiguration().getMappedStatement(command.getName());
            if (!StatementType.CALLABLE.equals(ms.getStatementType())
                    && void.class.equals(ms.getResultMaps().get(0).getType())) {
        
                throw new BindingException("method " + command.getName()
                        + " needs either a @ResultMap annotation, a @ResultType annotation,"
                        + " or a resultType attribute in XML so a ResultHandler can be used as a parameter.");
            }
            Object param = method.convertArgsToSqlCommandParam(args);
            if (method.hasRowBounds()) {
        
                RowBounds rowBounds = method.extractRowBounds(args);
                sqlSession.select(command.getName(), param, rowBounds, method.extractResultHandler(args));
            } else {
        
                sqlSession.select(command.getName(), param, method.extractResultHandler(args));
            }
        }
    
        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;
        }
    }

**SqlSession.java** 部分代码

/**
       * Retrieve a single row mapped from the statement key and parameter
       * using a {@code ResultHandler}.
       * @param statement Unique identifier matching the statement to use.
       * @param parameter A parameter object to pass to the statement.
       * @param handler ResultHandler that will handle each retrieved row
       */
      void select(String statement, Object parameter, ResultHandler handler);

**DefaultSqlSession.java** 部分代码

@Override
      public void select(String statement, Object parameter, ResultHandler handler) {
        
        select(statement, parameter, RowBounds.DEFAULT, handler);
      }
    
      @Override
      public void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
        
        try {
        
          MappedStatement ms = configuration.getMappedStatement(statement);
          executor.query(ms, wrapCollection(parameter), rowBounds, handler);
        } catch (Exception e) {
        
          throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
        } finally {
        
          ErrorContext.instance().reset();
        }
      }

**Executor.java** 部分代码

public interface Executor {
        
      ResultHandler NO_RESULT_HANDLER = null;  
      <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;
    }

**BaseExecutor.java**

public abstract class BaseExecutor implements Executor {
        
    
      private static final Log log = LogFactory.getLog(BaseExecutor.class);
    
      protected Transaction transaction;
      protected Executor wrapper;
    
      protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;
      // Mybatis一级缓存对象
      protected PerpetualCache localCache;
      // 存储过程输出参数缓存
      protected PerpetualCache localOutputParameterCache;
      protected Configuration configuration;
    
      protected int queryStack;
      private boolean closed;
    
      protected BaseExecutor(Configuration configuration, Transaction transaction) {
        
        this.transaction = transaction;
        this.deferredLoads = new ConcurrentLinkedQueue<DeferredLoad>();
        this.localCache = new PerpetualCache("LocalCache");
        this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");
        this.closed = false;
        this.configuration = configuration;
        this.wrapper = this;
      }  
      @Override
      public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
        
        // 获取BoundSql对象，BoundSql是对动态SQL解析生成的SQL语句和参数映射信息的封装
        BoundSql boundSql = ms.getBoundSql(parameter);
        // 创建CacheKey，用于缓存Key
        CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
        // 调用重载的query（）方法
        return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
     }
        
      @SuppressWarnings("unchecked")
      @Override
      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.");
        }
        if (queryStack == 0 && ms.isFlushCacheRequired()) {
        
          clearLocalCache();
        }
        List<E> list;
        try {
        
          queryStack++;
          // 从缓存中获取结果
          list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
          if (list != null) {
        
            handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
          } else {
        
            // 缓存中获取不到，则调用queryFromDatabase（）方法从数据库中查询
            list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
          }
        } finally {
        
          queryStack--;
        }
        if (queryStack == 0) {
        
          for (DeferredLoad deferredLoad : deferredLoads) {
        
            deferredLoad.load();
          }
          // issue #601
          deferredLoads.clear();
          if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        
            // issue #482
            clearLocalCache();
          }
        }
        return list;
      }
        
        
          private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        
        List<E> list;
        localCache.putObject(key, EXECUTION_PLACEHOLDER);
        try {
        
          // 调用doQuery（）方法查询
          list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
        } finally {
        
          localCache.removeObject(key);
        }
        // 缓存查询结果
        localCache.putObject(key, list);
        if (ms.getStatementType() == StatementType.CALLABLE) {
        
          localOutputParameterCache.putObject(key, parameter);
        }
        return list;
      }
        
        
          protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
          throws SQLException;
    }

**SimpleExecutor.java**

public class SimpleExecutor extends BaseExecutor {
        
    
      public SimpleExecutor(Configuration configuration, Transaction transaction) {
        
        super(configuration, transaction);
      }  
      @Override
      public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
        
        Statement stmt = null;
        try {
        
          Configuration configuration = ms.getConfiguration();
          // 获取StatementHandler对象
          StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
          // 调用prepareStatement（）方法,创建Statement对象，并进行设置参数等操作
          stmt = prepareStatement(handler, ms.getStatementLog());
          // 调用StatementHandler对象的query（）方法执行查询操作
          return handler.<E>query(stmt, resultHandler);
        } finally {
        
          closeStatement(stmt);
        }
      }
        
        
      private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
        
        Statement stmt;
        // 获取JDBC中的Connection对象
        Connection connection = getConnection(statementLog);
        // 调用StatementHandler的prepare（）方法创建Statement对象
        stmt = handler.prepare(connection, transaction.getTimeout());
        // 调用StatementHandler对象的parameterize（）方法设置参数
        handler.parameterize(stmt);
        return stmt;
      }
    }

**StatementHandler.java** 部分代码

public interface StatementHandler {
        
    <E> List<E> query(Statement statement, ResultHandler resultHandler)
          throws SQLException;
      }

**SimpleStatementHandler.java** 部分代码

public class SimpleStatementHandler extends BaseStatementHandler {
        
    
      public SimpleStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
        
        super(executor, mappedStatement, parameter, rowBounds, resultHandler, boundSql);
      }  
      @Override
      public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
        
        String sql = boundSql.getSql();
        statement.execute(sql);
        return resultSetHandler.<E>handleResultSets(statement);
      }
    }

### 4.3、处理结果并返回对应 Java 实体类 ###

**ResultSetHandler.java** 部分代码

public interface ResultSetHandler {
        
    
      <E> List<E> handleResultSets(Statement stmt) throws SQLException;
    
      <E> Cursor<E> handleCursorResultSets(Statement stmt) throws SQLException;
    
      void handleOutputParameters(CallableStatement cs) throws SQLException;
    
    }

public class DefaultResultSetHandler implements ResultSetHandler {
          
    //
      // 处理结果集
      //
      @Override
      public List<Object> handleResultSets(Statement stmt) throws SQLException {
        
        ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
        final List<Object> multipleResults = new ArrayList<Object>();
        int resultSetCount = 0;
        // 1、获取ResultSet对象，將ResultSet对象包装为ResultSetWrapper
        ResultSetWrapper rsw = getFirstResultSet(stmt);
        // 2、获取ResultMap信息，一般只有一个ResultMap
        List<ResultMap> resultMaps = mappedStatement.getResultMaps();
        int resultMapCount = resultMaps.size();
        // 校验ResultMap,如果该ResultMap名称没有配置，则抛出异常
        validateResultMapsCount(rsw, resultMapCount);
        // 如果指定了多个ResultMap，则对每个ResultMap进行处理
        while (rsw != null && resultMapCount > resultSetCount) {
        
          ResultMap resultMap = resultMaps.get(resultSetCount);
          // 3、调用handleResultSet方法处理结果集
          handleResultSet(rsw, resultMap, multipleResults, null);
          // 获取下一个结果集对象，需要JDBC驱动支持多结果集
          rsw = getNextResultSet(stmt);
          cleanUpAfterHandlingResultSet();
          resultSetCount++;
        }
        // 如果JDBC驱动支持多结果集，可以通过<select>标签resultSets属性指定多个ResultMap
        // 处理<select>标签resultSets属性，该属性一般情况不会指定
        String[] resultSets = mappedStatement.getResultSets();
        if (resultSets != null) {
        
          while (rsw != null && resultSetCount < resultSets.length) {
        
            ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
            if (parentMapping != null) {
        
              String nestedResultMapId = parentMapping.getNestedResultMapId();
              ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
              //调用handleResultSet方法处理结果集
              handleResultSet(rsw, resultMap, null, parentMapping);
            }
            rsw = getNextResultSet(stmt);
            cleanUpAfterHandlingResultSet();
            resultSetCount++;
          }
        }
        // 对multipleResults进行处理，如果只有一个结果集，则返回结果集中的元素，否则返回多个结果集
        return collapseSingleResultList(multipleResults);
      }
        
          private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
        
        try {
        
          //  仅当指定了<select>标签resultSets属性，parentMapping值才不为null
          if (parentMapping != null) {
        
            // 调用handleRowValues（）方法处理
            handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
          } else {
        
            if (resultHandler == null) {
        
              // 如果未指定ResultHandler，则创建默认的ResultHandler实现
              DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
              // 调用handleRowValues（）方法处理
              handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
              // 获取处理后的结果
              multipleResults.add(defaultResultHandler.getResultList());
            } else {
        
              handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
            }
          }
        } finally {
        
          closeResultSet(rsw.getResultSet());
        }
      }
        
          public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
        
        // 是否有嵌套ResultMap
        if (resultMap.hasNestedResultMaps()) {
        
          // 嵌套查询校验RowBounds，可以通过设置safeRowBoundsEnabled=false参数绕过校验
          ensureNoRowBounds();
          // 校验ResultHandler，可以设置safeResultHandlerEnabled=false参数绕过校验
          checkResultHandler();
          // 如果有嵌套的ResultMap，调用handleRowValuesForNestedResultMap处理嵌套ResultMap
          handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
        } else {
        
          // 如果无嵌套的ResultMap，调用handleRowValuesForSimpleResultMap处理简单非嵌套ResultMap
          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<Object>();
        skipRows(rsw.getResultSet(), rowBounds);
        // 遍历处理每一行记录
        while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
        
          // 对<discriminator>标签配置的鉴别器进行处理，获取实际映射的ResultMap对象
          ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);
          // 调用getRowValue（）把一行数据转换为Java实体对象
          Object rowValue = getRowValue(rsw, discriminatedResultMap);
          storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
        }
      }
    
      private void storeObject(ResultHandler<?> resultHandler, DefaultResultContext<Object> resultContext, Object rowValue, ResultMapping parentMapping, ResultSet rs) throws SQLException {
        
        if (parentMapping != null) {
        
          linkToParents(rs, parentMapping, rowValue);
        } else {
        
          callResultHandler(resultHandler, resultContext, rowValue);
        }
      }
        
          // 多ResultSet处理
      private void linkToParents(ResultSet rs, ResultMapping parentMapping, Object rowValue) throws SQLException {
        
        CacheKey parentKey = createKeyForMultipleResults(rs, parentMapping, parentMapping.getColumn(), parentMapping.getForeignColumn());
        List<PendingRelation> parents = pendingRelations.get(parentKey);
        if (parents != null) {
        
          for (PendingRelation parent : parents) {
        
            if (parent != null && rowValue != null) {
        
              linkObjects(parent.metaObject, parent.propertyMapping, rowValue);
            }
          }
        }
      }
        
      private void linkObjects(MetaObject metaObject, ResultMapping resultMapping, Object rowValue) {
        
        final Object collectionProperty = instantiateCollectionPropertyIfAppropriate(resultMapping, metaObject);
        if (collectionProperty != null) {
        
          final MetaObject targetMetaObject = configuration.newMetaObject(collectionProperty);
          targetMetaObject.add(rowValue);
        } else {
        
          metaObject.setValue(resultMapping.getProperty(), rowValue);
        }
      }
    }

[Mybatis _ Configuration]: https://blog.csdn.net/lxz352907839/article/details/116740600
[SqlSession _ Executor _ SQL]: https://blog.csdn.net/lxz352907839/article/details/116658179
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyODY2NDk3_size_16_color_FFFFFF_t_70]: /images/20221020/c0306d72ec6d43bd88fab50b6e95c9c2.png