MyBatis源码解析（五）：执行Mapper，获取初始结果集

悠悠 2022-04-23 15:18 267阅读 0赞

前言：[MyBatis源码解析（四）：初始化Mapper][MyBatis_Mapper]中，通过 MapperProxyFactory 已经成功获取到执行 Mapper 的代理对象，这一篇将使用该代理对象执行 Statement，获取到SQL执行的初始结果。另外，本篇步涉及ORM映射

一，执行流程

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE5NzYzODg_size_16_color_FFFFFF_t_70][]

二，执行步骤

1，初始化 Mapper 代理对象回顾

\* MapperProxyFactory：通过java动态动态获取代理对象

// Mapper.Statement执行缓存
    private final Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();
    
    protected T newInstance(MapperProxy<T> mapperProxy) {
        // 通过JDK动态代理方式, 生成Mapper的代理对象,
        return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
      }
    
      public T newInstance(SqlSession sqlSession) {
        // 初始化MapperProxy, 该类为InvocationHandler实现类, 动态代理最终执行该类的Invoke方法
        // mapperInterface 在初始化传递过程中已经初始化为当前Mapper类型
        final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
        return newInstance(mapperProxy);
      }

2，通过 Mapper 代理对象触发 Statement 执行

\* Statement 触发语句

UserVO userVO = mapper.selectUserById(1);

\* MapperProxy ：Statement 最终执行语句，因为通过动态代理触发，此时会执行 InvocationHandler 的 invoke()方法

// MapperProxyFactory实例化时候, 指定InvocationHandler为MapperProxy
      // 则通过Mapper代理对象进行Statement执行时, 执行该invoke()方法
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
          // 如果方法是Object类方法, 直接执行
          // 例如equals, hashCode等方法
          if (Object.class.equals(method.getDeclaringClass())) {
            return method.invoke(this, args);
          } else if (isDefaultMethod(method)) {
            return invokeDefaultMethod(proxy, method, args);
          }
        } catch (Throwable t) {
          throw ExceptionUtil.unwrapThrowable(t);
        }
        // 有效Statement, 根据method生成mapperMethod进行执行
        final MapperMethod mapperMethod = cachedMapperMethod(method);
        return mapperMethod.execute(sqlSession, args);
      }

3，根据 Method 生成有效的 MapperMethod，并区分执行类型

\* MapperProxy：根据有效 Statement 的 Method 对象，生成 MapperMethod 对象

private MapperMethod cachedMapperMethod(Method method) {
        // 从Statement缓存容器中获取当前Statement, 拿到直接返回
        MapperMethod mapperMethod = methodCache.get(method);
        if (mapperMethod == null) {
          // 从缓存集合中未获取到Statment, 初始化当前Statement为MapperMethod
          // 并添加初始化后的MapperMethod到缓存集合
          // mapperInterface, sqlSession, methodCache在构造Mapper代理对象时已经通过MapperProxy初始化传递
          // MapperMethod初始化会从Configuration配置中初始化SqlCommand, MethodSignature信息
          // 表示当前Statment的SQL类型和状态等信息
          mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration());
          // 添加当前Mapper.Statement到缓存中
          methodCache.put(method, mapperMethod);
        }
        return mapperMethod;
      }

\* MapperMethod：构造器中，会生成 SqlCommand 和 MethodSignature 两个对象，表示SQL和Statement基本信息

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

\* MapperMethod：execute()，区分执行类型，并调用 SqlSession 进行具体操作

public Object execute(SqlSession sqlSession, Object[] args) {
        Object result;
        switch (command.getType()) {
          // 标识新增
          case INSERT: {
          Object param = method.convertArgsToSqlCommandParam(args);
            result = rowCountResult(sqlSession.insert(command.getName(), param));
            break;
          }
          // 标识修改
          case UPDATE: {
            Object param = method.convertArgsToSqlCommandParam(args);
            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);
              // 调用SqlSession单条数据查询执行方法
              // SqlSession在初始化SqlSession分析中已经指明, 此处应为DefaultSqlSession
              // 单数据查询, 且查询结果为 VO
              result = sqlSession.selectOne(command.getName(), param);
            }
            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，调用 SqlSession 操作方法，进行数据操作

\* DefaultSqlSession：因为执行 Statement 为单条数据查询，调用 selectOne() 方法

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.<T>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;
        }
      }

\* 在 selectOne() 中，调用 selectList() 方法，实现接口复用

public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
        try {
          // 从Configuration对象中根据Statment名称获取有效的MappedStatement
          MappedStatement ms = configuration.getMappedStatement(statement);
          // 调用Executor执行查询
          // Executor初始化阶段已经被包装 CachingExecutor(SimleExecutor)
          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();
        }
      }

\* 从 Configuration 中获取有效的 Statement

public MappedStatement getMappedStatement(String id, boolean validateIncompleteStatements) {
        if (validateIncompleteStatements) {
          buildAllStatements();
        }
        return mappedStatements.get(id);
      }

5，调用执行器 Executor 执行查询语句

\* CachingExecutor：执行第一层 query() 方法

public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
        // 获取Statment执行的BoundSql, 包含Sql, 参数, 返回结果等信息
        BoundSql boundSql = ms.getBoundSql(parameterObject);
        // 创建数据缓存
        CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
        // 继续进行数据查询
        return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
      }

\* CachingExecutor：执行第二层 query() 方法

public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
          throws SQLException {
        // 先从缓存中获取一次数据, 缓存中存在数据, 直接返回缓存中的数据
        Cache cache = ms.getCache();
        if (cache != null) {
          flushCacheIfRequired(ms);
          if (ms.isUseCache() && resultHandler == null) {
            ensureNoOutParams(ms, 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);
              tcm.putObject(cache, key, list); // issue #578 and #116
            }
            return list;
          }
        }
        // 缓存中没有数据, 装饰者模式, 经过BaseExecutor转发到SimpleExecutor继续进行数据查询
        return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
      }

\* BaseExecutor：装饰者模式，转发到 BaseExecutor 继续执行 query() 方法

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 {
            // 缓存数据为空, 从数据库查询
            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;
      }

\* BaseExecutor：缓存未加载到，从数据库中获取有效数据

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        List<E> list;
        // 添加特殊表示, 标识当前Statemnt存在语句正在执行
        localCache.putObject(key, EXECUTION_PLACEHOLDER);
        try {
          // doQuery方法由子类实现, 当前子类SimpleExecutor
          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;
      }

6，SimpleExecutor 执行 doQuery() 方法解析

\* SimpleExecutor：doQuery()方法

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, 生成已经被Plugin代理的执行器
          StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
          // 获取数据库连接, 并注册相关事务
          // 此处使用JDBC连接连接, 会调用JDBCConnection进行数据库连接处理
          stmt = prepareStatement(handler, ms.getStatementLog());
          // 数据执行
          return handler.<E>query(stmt, resultHandler);
        } finally {
          closeStatement(stmt);
        }
      }

7，初始化 StatementHandler 处理器

\* 第一：初始化外层 RoutingStatementHandler 处理器

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
        // 首先初始化StatementHandler为RoutingStatementHandler
        StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
        // 循环插件生成StatementHandler的代理对象, 此处代理为循环代理
        statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
        return statementHandler;
      }

\* 第二：RoutingStatementHandler 内部，根据 MappedStatement.statementType 属性，初始化具体处理器；到这一步后，确保所有的 StatementHandler 能够持有数据查询和组装过程中的所有引用

public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    
        // 根据getStatementType()进行内部初始化, 此次初始化为PreparedStatementHandler
        switch (ms.getStatementType()) {
          case STATEMENT:
            delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
            break;
          case PREPARED:
            delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
            break;
          case CALLABLE:
            delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
            break;
          default:
            throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
        }
    
      }

\* 第三：循环插件生成代理对象，在方法最终执行前，先触发拦截器！该方法之前有过解析，参考[MyBatis源码解析（三）：初始化SqlSession][MyBatis_SqlSession]第三步

// 循环插件生成StatementHandler的代理对象, 此处代理为循环代理
        statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);

8，初始化数据库连接和 PreparedStatement 预编译平台

\* SimpleExecutor：prepareStatement()

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
        Statement stmt;
        // 初始化数据库连接
        Connection connection = getConnection(statementLog);
        // 初始化PreparedStatement预编译平台
        stmt = handler.prepare(connection, transaction.getTimeout());
        // 封装Statement对象到StatementHandler处理器中
        handler.parameterize(stmt);
        return stmt;
      }

\* BaseExecutor：初始化数据库连接

protected Connection getConnection(Log statementLog) throws SQLException {
        Connection connection = transaction.getConnection();
        if (statementLog.isDebugEnabled()) {
          return ConnectionLogger.newInstance(connection, statementLog, queryStack);
        } else {
          return connection;
        }
      }

protected Connection getConnection(Log statementLog) throws SQLException {
        // 通过JdbcTransaction获取连接
        Connection connection = transaction.getConnection();
        if (statementLog.isDebugEnabled()) {
          return ConnectionLogger.newInstance(connection, statementLog, queryStack);
        } else {
          return connection;
        }
      }

protected void openConnection() throws SQLException {
        if (log.isDebugEnabled()) {
          log.debug("Opening JDBC Connection");
        }
        // dataSource已经封装好了数据库连接信息, 获取数据库连接
        connection = dataSource.getConnection();
        if (level != null) {
          connection.setTransactionIsolation(level.getLevel());
        }
        setDesiredAutoCommit(autoCommmit);
      }

\* BaseStatementHandler：初始化 PreparedStatement 预编译平台

public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
        ErrorContext.instance().sql(boundSql.getSql());
        Statement statement = null;
        try {
          // 从子类实现中获取最终的Statement
          // 此时子类实现为PreparedStatement
          statement = instantiateStatement(connection);
          setStatementTimeout(statement, transactionTimeout);
          setFetchSize(statement);
          return statement;
        } catch (SQLException e) {
          closeStatement(statement);
          throw e;
        } catch (Exception e) {
          closeStatement(statement);
          throw new ExecutorException("Error preparing statement.  Cause: " + e, e);
        }
      }

protected Statement instantiateStatement(Connection connection) throws SQLException {
        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 {
          return connection.prepareStatement(sql);
        }
      }

9，StatementHandler 处理器，进行最终结果集获取

\* 此时的 StatementHandler 对象是被拦截器插件代理后的代理对象，会通过动态代理方式进行执行，生成代理方法如下

public static Object wrap(Object target, Interceptor interceptor) {
        Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
        Class<?> type = target.getClass();
        Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
        // 存在有效插件
        if (interfaces.length > 0) {
          // 对target即executor进行代理
          // 外部循环调用, 则此时executor对象可能已经是代理对象
          // 允许对代理对象再次进行代理
          // 最终执行时, 装箱代理, 拆箱调用, 类似装饰者模式一层层进行处理
          return Proxy.newProxyInstance(
              type.getClassLoader(),
              interfaces,
              new Plugin(target, interceptor, signatureMap));
        }
        return target;
      }

\* StatementHandler.query()方法调用，会先执行 Plugin.invoke()方法

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
          Set<Method> methods = signatureMap.get(method.getDeclaringClass());
          if (methods != null && methods.contains(method)) {
            return interceptor.intercept(new Invocation(target, method, args));
          }
          return method.invoke(target, args);
        } catch (Exception e) {
          throw ExceptionUtil.unwrapThrowable(e);
        }
      }

\* 拦截器方法执行完成后，再最终调用 PreparedStatementHandler.query()方法，

public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
        // 转换Statement为JDBC原生的PreparedStatement
        PreparedStatement ps = (PreparedStatement) statement;
        // 通过JDBC底层执行, 并将执行结果封装到PreparedStatement中
        ps.execute();
        // resultSetHandler:结果集处理器, 对查询结果进行ORM映射
        return resultSetHandler.<E> handleResultSets(ps);
      }

10，本篇博文只分析到获取结果集，ORM映射下一篇进行分析

[MyBatis_Mapper]: https://blog.csdn.net/u011976388/article/details/88907538
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE5NzYzODg_size_16_color_FFFFFF_t_70]: /images/20220226/0fe6b2a1d0644c15a78fab157e72d887.png
[MyBatis_SqlSession]: https://blog.csdn.net/u011976388/article/details/88904251