mybatis源码解析之调用流程（执行sql）

缺乏、安全感 2022-09-02 03:56 279阅读 0赞

> 原创不易，转载请注明出处

### 文章目录 ###

*   *   *  前言
         *  1. 承接上文
         *  2.创建statementHandler
         *   *  2.1.创建ParameterHandler
             *  2.2.创建ResultSetHandler
         *  3.创建statement，设置参数
         *   *  3.1.获取连接
             *  3.2 创建Statement
             *  3.3.设置参数
         *  4.执行sql，处理结果集
         *   *  4.1 执行update、insert、delete语句，并处理结果
             *  4.2 执行select语句，处理结果集
         *  总结

--------------------

### 前言 ###

前面几篇文章我们介绍了调用流程中的缓存，包括一级缓存《[mybatis源码解析之调用流程（一级缓存）][mybatis]》，二级缓存《[mybatis源码解析之调用流程（二级缓存）][mybatis 1]》（一级缓存其实不用太多关注，用到的可能性很小），接下来我们就要看下它是怎样获取连接，创建statement，设置参数，执行sql，处理结果集这些东东了。

### 1. 承接上文 ###

我们先回顾下，在向二级缓存查找的时候，如果缓存中没有，就会去数据库中查询。

SimpleExecutor（BaseExecutor）\#query

// 先去cache中查询，如果存在的话，就处理处理返回了
    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);
    }

可以看到缓存中没有的话，就会调用queryFromDatabase去数据库中查询。

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 { 
          // 进行查询
          list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
        } finally { 
          //移除那个占位符
          localCache.removeObject(key);
        }
        // 放入缓存中
        localCache.putObject(key, list);
        // callable
        if (ms.getStatementType() == StatementType.CALLABLE) { 
          localOutputParameterCache.putObject(key, parameter);
        }
        return list;
      }

这里是调用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
          StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
          // 创建statement / 设置参数
          stmt = prepareStatement(handler, ms.getStatementLog());
          // 进行查询
          return handler.query(stmt, resultHandler);
        } finally { 
          // 关闭statement
          closeStatement(stmt);
        }
      }

这里是分为3步：

1.  创建statementHandler
2.  创建statement，并且设置参数
3.  执行sql，处理结果集  
    接下来我们分别看看。

### 2.创建statementHandler ###

StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);

我们直接进入这行代码看看

// 创建StatementHandler
      public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) { 
        StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
        // 拦截器进行来装饰
        statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
        return statementHandler;
      }

首先创建RoutingStatementHandler对象，然后使用插件进行装饰，进行包装。  
先看下RoutingStatementHandler构造方法。

public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) { 
        // 判断statement类型
        switch (ms.getStatementType()) { 
          // 普通的那个statement
          case STATEMENT:
            delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
            break;
         // prepared 的statement
          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());
        }
      }

其实就是根据statement的类型来创建对应的statementHandler类，我们常用的一般是PreparedStatement，也就是PREPARED类型，创建的就是PreparedStatementHandler 。  
这里RoutingStatementHandler的调用最终都会交给delegate 对象来执行，也就是说RoutingStatementHandler 就是做一个转发的作用，正好符合它的名字。  
这里创建的最终是PreparedStatementHandler，外层包着RoutingStatementHandler ，如果有插件的话，外层还包着插件，调用关系如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70]  
接着来看下PreparedStatementHandler 构造方法，

public PreparedStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) { 
        super(executor, mappedStatement, parameter, rowBounds, resultHandler, boundSql);
      }

调用了父类的构造，父类是BaseStatementHandler

protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) { 
        this.configuration = mappedStatement.getConfiguration();
        this.executor = executor;
        this.mappedStatement = mappedStatement;
        this.rowBounds = rowBounds;
        this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
        this.objectFactory = configuration.getObjectFactory();
        if (boundSql == null) {  // issue #435, get the key before calculating the statement
          generateKeys(parameterObject);
          boundSql = mappedStatement.getBoundSql(parameterObject);
        }
        this.boundSql = boundSql;
        // 创建 parameterHandler
        this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
        // 创建 resultHandler
        this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
      }

这里最重要的是使用configuration创建了2个handler，一个是ParameterHandler ，一个是ResultSetHandler ，从名字上也能看出来，ParameterHandler 是处理参数的，ResultSetHandler 是处理返回结果集的。

#### 2.1.创建ParameterHandler ####

public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) \{

//根据lang 也就是数据库类型获取对应的参数处理器 ，这里是DefaultParameterHandler
        ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
        // 拦截器进行装饰
        parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
        return parameterHandler;
      }

首先这里使用对应的驱动（这里一般是XMLLanguageDriver），创建ParameterHandler，然后有插件的话会对ParameterHandler 进行包装拦截。  
创建的ParameterHandler 的实现类是DefaultParameterHandler ，我搜了一下，全局就这一个实现类。  
DefaultParameterHandler 的实现类就没啥好看的了，就是一堆赋值。

#### 2.2.创建ResultSetHandler ####

接下来看看ResultSetHandler 是怎么创建的。

public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
          ResultHandler resultHandler, BoundSql boundSql) { 
        // 创建默认的resultSetHandler
        ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
        // 拦截器进行装饰
        resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
        return resultSetHandler;
      }

这里直接创建DefaultResultSetHandler ，然后使用插件进行包装拦截。DefaultResultSetHandler 构造也没啥好看的，也是一堆赋值。

### 3.创建statement，设置参数 ###

创建完了statementHandler，接下来我们就要看看它是怎样获取连接，创建statement，设置参数的了。

stmt = prepareStatement(handler, ms.getStatementLog());

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException { 
        Statement stmt;
        // 获取数据库连接
        Connection connection = getConnection(statementLog);
        // 创建statement
        stmt = handler.prepare(connection, transaction.getTimeout());
        // 设置参数
        handler.parameterize(stmt);
        return stmt;
      }

可以看到，首先是获取连接 ，接着创建Statement ，最后设置往Statement 设置参数。

#### 3.1.获取连接 ####

先来看看getConnection 是怎样获取连接的。

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

其实就是从事务里面获取的。

#### 3.2 创建Statement ####

接着看看 stmt = handler.prepare(connection, transaction.getTimeout()); 是怎样创建Statement的。  
调用PreparedStatementHandler的父类BaseStatementHandler 的prepare 方法

@Override
      public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException { 
        ErrorContext.instance().sql(boundSql.getSql());
        Statement statement = null;
        try { 
          // 创建statement
          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);
        }
      }

可以看到，调用的instantiateStatement 方法创建的statement ，这个instantiateStatement 方法是个抽象方法，需要子类来实现。  
这里直接看PreparedStatementHandler实现的instantiateStatement 方法就好啦。

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() == ResultSetType.DEFAULT) { 
          return connection.prepareStatement(sql);
        } else { 
          return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
        }
      }

就是使用连接prepareStatement创建出来的PreparedStatement。只不过useGeneratedKeys 这个参数设置true的话，就会在创建prepareStatement 的时候指定要返回来的数据库字段（也就是我们指定的keyProperty 或者是keyColumn 对应的数据库字段）

#### 3.3.设置参数 ####

最后就是调用`handler.parameterize(stmt);` 设置参数了。

> 这个设置参数从何说起？  
> 我们创建PreparedStatement 的时候传入的sql里面有一堆？问号占位符，在执行sql之前需要将占位符对应的参数值设置到statement中。  
> 比如说，我们要根据id查询用户信息，sql可能会这么写 select id,username,password from user where id=？ ，然后往statement 设置参数id 是1

我们看下statementHandler 的parameterize方法。

@Override
      public void parameterize(Statement statement) throws SQLException { 
        // 找到parameterHandler 设置参数
        parameterHandler.setParameters((PreparedStatement) statement);
      }

可以看到，直接找的parameterHandler 来设置参数的。

public void setParameters(PreparedStatement ps) { 
        ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
        if (parameterMappings != null) { 
          for (int i = 0; i < parameterMappings.size(); i++) { 
            ParameterMapping parameterMapping = parameterMappings.get(i);
            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())) { 
                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();
              }
              try { 
                // 使用typeHandler进行设置
                typeHandler.setParameter(ps, i + 1, value, jdbcType);
              } catch (TypeException | SQLException e) { 
                throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
              }
            }
          }
        }
      }

其实就是遍历ParameterMapping ，然后根据参数类型 获取对应的类型处理器，然后使用类型处理来进行参数的设置。

// 使用typeHandler进行设置
      typeHandler.setParameter(ps, i + 1, value, jdbcType);

可以看到将ps 也就是prepareStatement 传入类型处理器里面，里面其实就是调用prepareStatement 的api进行参数设置。  
我们这里看下Integer类型处理器是怎样设置参数的。

public void setNonNullParameter(PreparedStatement ps, int i, Integer parameter, JdbcType jdbcType)
          throws SQLException { 
        ps.setInt(i, parameter);
      }

就是调用prepareStatement 的api设置的。

### 4.执行sql，处理结果集 ###

创建好了statement，设置好了参数，接下来就是执行sql，处理结果集了。

handler.query(stmt, resultHandler)

调用的statementHandler 的query进行查询，这里是查询语句，如果是update，insert，delete语句的话就是走的handler的update 方法，我们先看下update的吧

#### 4.1 执行update、insert、delete语句，并处理结果 ####

public int update(Statement statement) throws SQLException { 
        PreparedStatement ps = (PreparedStatement) statement;
        ps.execute();//执行
        int rows = ps.getUpdateCount();//获取执行结果（影响行数）
        // 获取请求参数
        Object parameterObject = boundSql.getParameterObject();
        // 处理KeyGenerator
        KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
        keyGenerator.processAfter(executor, mappedStatement, ps, parameterObject);
        return rows;
      }

调用statement的execute执行sql，这个动作可以认为去数据库执行sql了，接着就是获取执行语句影响行数。  
最后就是处理KeyGenerator ，我们在执行insert语句的时候一般都喜欢使用`useGeneratedKeys =true ，keyProperty="id"` 这两个属性，代表的含义就是，执行完insert语句将插入的id字段值赋值给参数实体id字段。

#### 4.2 执行select语句，处理结果集 ####

接着看下`handler.query(stmt, resultHandler)` 执行insert语句的了。

public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException { 
        // 执行
        PreparedStatement ps = (PreparedStatement) statement;
        ps.execute();
        // 处理结果集
        return resultSetHandler.handleResultSets(ps);
      }

也是调用PreparedStatement 的execute方法执行sql，然后调用resultSetHandler的handleResultSets 方法处理结果集，最后将结果返回。接下来我们重点看下handleResultSets 是怎样处理结果集的

public List<Object> handleResultSets(Statement stmt) throws SQLException { 
        ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
        final List<Object> multipleResults = new ArrayList<>();
        int resultSetCount = 0;
        // 封装resultSet包装类
        ResultSetWrapper rsw = getFirstResultSet(stmt);
        // resultMap
        List<ResultMap> resultMaps = mappedStatement.getResultMaps();
        int resultMapCount = resultMaps.size();
        validateResultMapsCount(rsw, resultMapCount);
        while (rsw != null && resultMapCount > resultSetCount) { 
          ResultMap resultMap = resultMaps.get(resultSetCount);
          handleResultSet(rsw, resultMap, multipleResults, null);
          rsw = getNextResultSet(stmt);
          cleanUpAfterHandlingResultSet();
          resultSetCount++;
        }
        // resultSet 处理
        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(rsw, resultMap, null, parentMapping);
            }
            rsw = getNextResultSet(stmt);
            cleanUpAfterHandlingResultSet();
            resultSetCount++;
          }
        }
        // 返回处理过的结果集
        return collapseSingleResultList(multipleResults);
      }

首先是创建ResultSetWrapper，这个动作其实是将元数据信息收集起来。

public ResultSetWrapper(ResultSet rs, Configuration configuration) throws SQLException { 
        super();
        this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
        this.resultSet = rs;
        final ResultSetMetaData metaData = rs.getMetaData();
        final int columnCount = metaData.getColumnCount();
        for (int i = 1; i <= columnCount; i++) { 
          columnNames.add(configuration.isUseColumnLabel() ? metaData.getColumnLabel(i) : metaData.getColumnName(i));
          jdbcTypes.add(JdbcType.forCode(metaData.getColumnType(i)));// jdbc类型--》mybatis的JdbcType
          classNames.add(metaData.getColumnClassName(i));
        }
      }

可以看到获取元数据信息（就是你数据库表字段信息）,封装到columnNames ，jdbcTypes，classNames这三个集合中。

接着处理结果集往下说  
使用resultMap来处理，handleResultSet(rsw, resultMap, multipleResults, null);

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) { 
              DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
              handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);//处理结果集
              multipleResults.add(defaultResultHandler.getResultList());
            } else { 
              handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
            }
          }
        } finally { 
          // issue #228 (close resultsets) // 关闭resultSet
          closeResultSet(rsw.getResultSet());
        }
      }

创建DefaultResultHandler 对象，然后使用handleRowValues 处理结果集，最后将结果集放入multipleResults这个集合中。  
重点看下handleRowValues 方法。

public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException { 
        if (resultMap.hasNestedResultMaps()) { ///判断是否有嵌套的那种resultMap
          ensureNoRowBounds();
          checkResultHandler();
          handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
        } else { 
          handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
        }
      }

可以看到这个方法是处理嵌套resultMap的，最后走的是handleRowValuesForSimpleResultMap方法处理的

private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
          throws SQLException { 
        DefaultResultContext<Object> resultContext = new DefaultResultContext<>();
        ResultSet resultSet = rsw.getResultSet();
        skipRows(resultSet, rowBounds);
        while (shouldProcessMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next()) { 
          ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(resultSet, resultMap, null);
          Object rowValue = getRowValue(rsw, discriminatedResultMap, null);//封装结果集
          storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);// 将结果集放到resultHandler里面
        }
      }

从ResultSetWrapper 拿到resultSet，这个resultSet就是jdbc 那个了。  
while循环，如果还有下一个，就调用getRowValue 方法封装一行数据，之后将这行数据添加到resultHandler的集合里面，里面的一些细节信息我们这里就不看了，大体知道怎样处理的就可以了，最后涉及到字段，也是使用类型处理器处理的。

### 总结 ###

我们这篇文章很长，有些细节也不到位，本文主要介绍mybatis执行流程最后一部分，执行sql全流程，从创建statementHandler 到获取连接，创建statement ，设置参数，最后再到执行sql，处理结果集返回。

[mybatis]: https://inetyoung.blog.csdn.net/article/details/119118536
[mybatis 1]: https://inetyoung.blog.csdn.net/article/details/119153473
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70]: /images/20220829/28d780ce9d0a48aea41475ee98cbedc7.png