Mybatis-StatementHandler解析（三）

StatementHandler

StatementHandler接口的实现大致有四个，其中三个实现类都是和JDBC中的Statement响对应的：

SimpleStatementHandler，这个很简单了，就是对应我们JDBC中常用的Statement接口，用于简单SQL的处理；

PreparedStatementHandler，这个对应JDBC中的PreparedStatement，预编译SQL的接口；

CallableStatementHandler，这个对应JDBC中CallableStatement，用于执行存储过程相关的接口；

RoutingStatementHandler，这个接口是以上三个接口的路由，没有实际操作，只是负责上面三个StatementHandler的创建及调用。

实现

接下来，我们来看下对应的源码实现，我们还是拿查询方法query来学习。

首先，我们从DefaultSqlSession中调用Executor的query方法：

@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      // 注意下这里的方法
      MappedStatement ms = configuration.getMappedStatement(statement);
      // 调用Executor的query方法
      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();
    }
}

然后，我们进入BaseExecutor的query方法：

@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameter);
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

这里涉及到了一个BoundSql 对象。BoundSql对象是用于存储sql语句及对应的参数相关的对象。
然后我们接着看下一步：

@Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ...
    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--;
    }
    ...
}

这里涉及到了对缓存的处理，等到学习Mybatis缓存的时候再一并解释，然后接着看queryFromDatabase方法，这里面调用了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();
      // 这里，从Configuration中获取StatementHandler
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      stmt = prepareStatement(handler, ms.getStatementLog());
      return handler.<E>query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
}

从这里我们可以终于看到了StatementHandler的来源了，来自于Configuration对象的方法newStatementHandler，我们查看下该方法：

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    // RoutingStatementHandler对象出来了
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    return statementHandler;
}

这里，我们终于看到了是如何获取StatementHandler的了，通过RoutingStatementHandler的构造方法来进行获取，我们再来看下RoutingStatementHandler的构造方法：

public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    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());
    }
}

到了这一步就很明显了，根据statementType的类型来判断是哪一种StatementHandler的实现，并且RoutingStatementHandler维护了一个delegate对象，通过delegate对象来实现对实际Handler对象的调用。这里涉及到了一个对象MappedStatement。

MappedStatement

而所谓的MappedStatement对象就是对mapper.xml中的某个方法select|update|delete|insert的封装，如对于下面的getAll方法，就对应一个MappedStatement：

<select id="getAll" resultType="Student2">
        SELECT * FROM Student
    </select>

MappedStatement对象的默认的statementType是PREPARED，所以默认情况下我们所生成的StatementHandler就是PreparedStatementHandler对象。那为什么默认是PREPARED呢，当然，我们也可以从代码中找到原因。
还记得我们最开始的DefaultSqlSession中的selectList方法中的：

MappedStatement ms = configuration.getMappedStatement(statement);

这里，我们获取到了MappedStatement，我们来简单看下获取的过程：

public MappedStatement getMappedStatement(String id) {
    return this.getMappedStatement(id, true);
}

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

这里，方法进入了buildAllStatements方法，我们看到buildAllStatements方法的如下代码：

incompleteStatements.iterator().next().parseStatementNode();

同样，我们进入parseStatementNode方法，然后进入：

builderAssistant.addMappedStatement

然后进入：

MappedStatement.Builder statementBuilder = new MappedStatement.Builder......

最终，兜兜转转进入MappedStatement的内部类Builder的构造方法：

mappedStatement.statementType = StatementType.PREPARED;

最终，我们看到Builder构造方法中设置了默认的statementType类型是PREPARED。当然，如果我们不想使用PREPARED，也可以自己配置，当然配置的方式就是在mapper.xml中对应的某个方法上添加对应属性即可：

<select id="getAll" resultType="Student2" statementType="CALLABLE">
    SELECT * FROM Student
</select>

大致了解了MappedStatement，我们接着上面的SimpleExecutor中的doQuery方法来学习。

获取到StatementHandler之后，首先进入prepareStatement方法，该方法就是为了获取Statement对象，并设置Statement对象中的参数：

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    Connection connection = getConnection(statementLog);
    stmt = handler.prepare(connection, transaction.getTimeout());
    handler.parameterize(stmt);
    return stmt;
}

我们来看下StatementHandler的prepare和parameterize方法，prepare方法负责生成Statement实例对象，而parameterize方法用于处理Statement实例多对应的参数。
我们大致看下prepare方法，首先进入BaseStatementHandler，查看prepare方法：

public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
    ErrorContext.instance().sql(boundSql.getSql());
    Statement statement = null;
    try {
      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，我们可以看下它在PreparedStatementHandler的实现：

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

这里就不多说了，就是通过Connection的方法来获取Statement实例对象而已。
而对于parameterize而言，设置参数也很简单的：

public void parameterize(Statement statement) throws SQLException {
    parameterHandler.setParameters((PreparedStatement) statement);
}

当然，感兴趣的童鞋也可以去看下ParameterHandler的实现DefaultParameterHandler中的实现：setParameters方法。

然后，我们接着doQuery方法来看，SimpleExector的doQuery方法会调用StatementHandler的query方法，然后我们来看下PreparedStatementHandler的query实现：

@Override
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    return resultSetHandler.<E> handleResultSets(ps);
}

这里又涉及到了另一个对象：ResultSetHandler。这个对象就比较简单了，就是将Statement实例执行之后返回的ResultSet结果集转换成我们需要的List结果集。而这里的PreparedStatement接口的实现则对应于JDBC中PreparedStatement类，这样，最终的调用就到了JDBC这边。

Mybatis-StatementHandler解析（三）

猜你喜欢