欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识！
您现在的位置是： 首页

Mybatis源码分析（6）—— 从JDBC看Mybatis的设计

程序员文章站 2022-06-16 08:09:54
...

Java数据库连接，（Java Database Connectivity，简称JDBC）是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。

六步流程:

  • 加载驱动（5.x驱动包不需要这步了）
  • 建立连接
  • 创建Statement
  • 执行SQL语句
  • 获取结果集
  • 关闭资源

这里只取后面几步分析下，基本上都是从Executor开始。DefaultSqlSession被每个Mapper持有，将各种基于SQL的操作转移到调用Executor的query和update方法。

Executor的类图如下：

Mybatis源码分析（6）—— 从JDBC看Mybatis的设计

以ReuseExecutor的doQuery方法为例：

public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Configuration configuration = ms.getConfiguration();
    StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, rowBounds, resultHandler, boundSql);
    Statement stmt = prepareStatement(handler, ms.getStatementLog());
    return handler.<E>query(stmt, resultHandler);
}

建立连接

上面ReuseExecutor的doQuery方法调用其prepareStatement方法：

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    BoundSql boundSql = handler.getBoundSql();
    String sql = boundSql.getSql();
    if (hasStatementFor(sql)) {
      stmt = getStatement(sql);
    } else {
      Connection connection = getConnection(statementLog);
      stmt = handler.prepare(connection);
      putStatement(sql, stmt);
    }
    handler.parameterize(stmt);
    return stmt;
}

然后调用getConnection方法获取连接：

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

这个连接是从Transaction对象中获取的。

当我们和Spring一起使用时，当然由Spring统一管理，回顾DefaultSqlSessionFactory类中的openSessionFromDataSource方法，这个连接就是找Spring要的（DataSourceUtils#getConnection），要过来放到了SpringManagedTransaction中。

创建Statement

  • Statement createStatement()

创建Statement 对象，Statement接口提供基本执行SQL语句的能力。

  • PreparedStatement prepareStatement(String sql)

创建PreparedStatement对象，PreparedStatement接口继承了Statement接口，提供SQL语句接受输入参数的能力。

  • CallableStatement prepareCall(String sql)

创建CallableStatement对象，CallableStatement接口继承了PreparedStatement接口，提供执行存储过程的能力。

针对这三种情况，Mybatis提供了三个StatementHandler实现：
Mybatis源码分析（6）—— 从JDBC看Mybatis的设计

并创建了一个RoutingStatementHandler作为路由（代理类），根据MappedStatement中的statementType来确定创建哪个作为实际的StatementHandler实现。对外提供一致接口，实际调用交给委托类。

还是接着看上面的prepareStatement方法，它获取连接后就接着调用StatementHandler的prepare方法：

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    BoundSql boundSql = handler.getBoundSql();
    String sql = boundSql.getSql();
    if (hasStatementFor(sql)) {
      stmt = getStatement(sql);
    } else {
      Connection connection = getConnection(statementLog);
      stmt = handler.prepare(connection);
      putStatement(sql, stmt);
    }
    handler.parameterize(stmt);
    return stmt;
}

这个来自BaseStatementHandler的prepare方法又是调用子类的instantiateStatement方法来实例化Statement:

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的prepareStatement方法，回到了我们传统的操作。

执行SQL语句

在Executor的实现类中，doUpdate和doQuery方法都会调用下面两个方法：

handler.update(stmt);

handler.query(stmt, resultHandler);

SimpleStatementHandler的query方法：

public <E> List<E> query(Statement statement, ResultHandler resultHandler)
      throws SQLException {
    String sql = boundSql.getSql();
    statement.execute(sql);
    return resultSetHandler.<E>handleResultSets(statement);
}

PreparedStatementHandler的query方法：

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

CallableStatementHandler的query方法：

public <E> List<E> query(Statement statement, ResultHandler resultHandler)
      throws SQLException {
    CallableStatement cs = (CallableStatement) statement;
    cs.execute();
    List<E> resultList = resultSetHandler.<E>handleResultSets(cs);
    resultSetHandler.handleOutputParameters(cs);
    return resultList;
}

这里都是直接调的Statement或PreparedStatement的execute方法。

返回结果集

上面的三种StatementHandler，最终都会处理结果集，CallableStatementHandler有点特殊，其它两种都是调用ResultSetHandler的handleResultSets方法来处理结果集。ResultSetHandler在基类BaseStatementHandler的构造函数中通过configuration对象来创建：

this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);

具体的实现有两种，FastResultSetHandler和NestedResultSetHandler，且NestedResultSetHandler继承了FastResultSetHandler，重写了handleRowValues方法。

在FastResultSetHandler的handleResultSets方法中：

public List<Object> handleResultSets(Statement stmt) throws SQLException {
    final List<Object> multipleResults = new ArrayList<Object>();
    final List<ResultMap> resultMaps = mappedStatement.getResultMaps();
    int resultMapCount = resultMaps.size();
    int resultSetCount = 0;
    ResultSet rs = stmt.getResultSet();

    while (rs == null) {
      // move forward to get the first resultset in case the driver
      // doesn't return the resultset as the first result (HSQLDB 2.1)
      if (stmt.getMoreResults()) {
        rs = stmt.getResultSet();
      } else {
        if (stmt.getUpdateCount() == -1) {
          // no more results.  Must be no resultset
          break;
        }
      }
    }
    // 验证是否定义了resultType或者resultMap
    validateResultMapsCount(rs, resultMapCount);
    while (rs != null && resultMapCount > resultSetCount) {
      final ResultMap resultMap = resultMaps.get(resultSetCount);
      ResultColumnCache resultColumnCache = new ResultColumnCache(rs.getMetaData(), configuration);
      handleResultSet(rs, resultMap, multipleResults, resultColumnCache);
      rs = getNextResultSet(stmt);
      cleanUpAfterHandlingResultSet();
      resultSetCount++;
    }
    return collapseSingleResultList(multipleResults);
}

处理结果行：

protected void handleRowValues(ResultSet rs, ResultMap resultMap, ResultHandler resultHandler, RowBounds rowBounds, ResultColumnCache resultColumnCache) throws SQLException {
    final DefaultResultContext resultContext = new DefaultResultContext();
    skipRows(rs, rowBounds);
    while (shouldProcessMoreRows(rs, resultContext, rowBounds)) {
      final ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rs, resultMap, null);
      Object rowValue = getRowValue(rs, discriminatedResultMap, null, resultColumnCache);
      callResultHandler(resultHandler, resultContext, rowValue);
    }
}

skipRows就是跳过行，基于查询结果的分页使用，其中会直接调用ResultSet的absolute方法：

rs.absolute(rowBounds.getOffset());

而shouldProcessMoreRows方法就是判断是否应该获取更多的行：

protected boolean shouldProcessMoreRows(ResultSet rs, ResultContext context, RowBounds rowBounds) throws SQLException {
    return !context.isStopped() && rs.next() && context.getResultCount() < rowBounds.getLimit();
}

也对应了分页的limit字段，这种分页可以说是伪分页，查出来再分页。所以我们一般使用插件的形式来实现分页，基于sql的动态替换。

具体针对行的处理在getRowValue方法中：

protected Object getRowValue(ResultSet rs, ResultMap resultMap, CacheKey rowKey, ResultColumnCache resultColumnCache) throws SQLException {
    final ResultLoaderMap lazyLoader = instantiateResultLoaderMap();
    Object resultObject = createResultObject(rs, resultMap, lazyLoader, null, resultColumnCache);
    if (resultObject != null && !typeHandlerRegistry.hasTypeHandler(resultMap.getType())) {
      final MetaObject metaObject = configuration.newMetaObject(resultObject);
      boolean foundValues = resultMap.getConstructorResultMappings().size() > 0;
      if (shouldApplyAutomaticMappings(resultMap, !AutoMappingBehavior.NONE.equals(configuration.getAutoMappingBehavior()))) {
        final List<String> unmappedColumnNames = resultColumnCache.getUnmappedColumnNames(resultMap, null);
        foundValues = applyAutomaticMappings(rs, unmappedColumnNames, metaObject, null, resultColumnCache) || foundValues;
      }
      final List<String> mappedColumnNames = resultColumnCache.getMappedColumnNames(resultMap, null);
      foundValues = applyPropertyMappings(rs, resultMap, mappedColumnNames, metaObject, lazyLoader, null) || foundValues;
      foundValues = (lazyLoader != null && lazyLoader.size() > 0) || foundValues;
      resultObject = foundValues ? resultObject : null;
      return resultObject;
    }
    return resultObject;
}

根据ResultMap提供的相关参数（返回的类型等），构造一个空的对象，然后根据属性名到ResultSet中获取结果，再通过MetaObject给set进对象里。

具体的取值是通过TypeHandler:

final Object value = typeHandler.getResult(rs, columnName);

每种类型的都对应一个TypeHandler的实现，以Integer类型的为例（IntegerTypeHandler）：

@Override
public Integer getNullableResult(ResultSet rs, String columnName)
  throws SQLException {
    return rs.getInt(columnName);
}

框架就是这样，底层就是最基本的原理和最简单的接口，而这些接口通常就是所谓的标准。它所做的事就是解放我们的双手，把能省的都给省了，让我们专注于业务代码的编写。

但我们也应该知其所以然。一是出于好奇心，这是程序员的本能；二是为了学习其优秀的思想和设计理念，以后可以为我所用，这可称之为野心吧。

相关标签： JDBC Mybatis ResultSet

上一篇： 基于cdh5.7.5集群的solr(4.10.3-cdh5.7.5)+hbase(1.2.0-cdh5.7.5)构建二级索引方案

下一篇： 开关电源EMI设计(原理讲解及实战分析)

推荐阅读