乐趣区

关于java:阅读-MyBatis-源码SQL-执行过程

上一篇文章介绍了 JDBC 实现 SQL 查问的原理,本文通过一个简略的 MyBatis 查问示例,探索 MyBatis 执行 SQL 查问的代码流程。

本文基于 MyBatis 3.5.7。

1. 应用示例

工程构造:

简略查问例子:

private static SqlSessionFactory sqlSessionFactory;

@BeforeClass
public static void init() {
    try {Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
    } catch (IOException e) {e.printStackTrace();
    }
}

@Test
public void selectAll() {try (SqlSession sqlSession = sqlSessionFactory.openSession()) {List<Student> students = sqlSession.selectList("selectAll");
        for (int i = 0; i < students.size(); i++) {System.out.println(students.get(i));
        }
    } catch (Exception e) {e.printStackTrace();
    }
}

2. 源码剖析

2.1 解析配置文件

2.1.1 解析 mybatis-config.xml

MyBatis XML 配置文件例子如下,更多阐明见官网文档 -XML 配置

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!-- MyBatis XML 配置阐明 https://mybatis.org/mybatis-3/zh/configuration.html -->

    <!-- 引入其余配置文件 -->
    <properties resource="jdbc.properties"/>

    <settings>
        <!-- 设置一级缓存的范畴 -->
        <setting name="localCacheScope" value="SESSION"/>
        <!-- 开启缓存 -->
        <setting name="cacheEnabled" value="true"/>
        <!-- 开启驼峰式命名,数据库的列名可能映射到去除下划线驼峰命名后的字段名 -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!-- 指定 MyBatis 所用日志的具体实现,未指定时将主动查找 -->
        <setting name="logImpl" value="LOG4J"/>
    </settings>

    <!-- 类型别名可为 Java 类型设置一个缩写名字。它仅用于 XML 配置,意在升高冗余的全限定类名书写 -->
    <typeAliases>
        <!-- 指定一个包名,MyBatis 会在包名上面搜寻须要的 Java Bean。在没有注解的状况下,会应用 Bean 的首字母小写的非限定类名来作为它的别名 -->
        <package name="com.sumkor.entity"/>
    </typeAliases>

    <plugins>
        <plugin interceptor="com.sumkor.plugin.StatementInterceptor"/>
        <plugin interceptor="com.sumkor.plugin.PageInterceptor"/>
    </plugins>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC">
                <property name=""value=""/>
            </transactionManager>
            <!-- POOLED 这种数据源的实现利用“池”的概念将 JDBC 连贯对象组织起来,防止了创立新的连贯实例时所必须的初始化和认证工夫。-->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <!-- 应用 package 标签,须要把 xml 映射文件和 Mapper 接口文件放在同一个目录,而且必须同名 -->
        <package name="com.sumkor.mapper"/>
        <!-- <mapper resource="com/sumkor/mapper/StudentMapper.xml"/> -->
    </mappers>
</configuration>

通过 SqlSessionFactoryBuilder 来解析 mybatis-config.xml 文件:

Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);

这里会把 mybatis-config.xml 配置文件解析成 org.apache.ibatis.session.Configuration 对象,这是一个重要的配置类。

org.apache.ibatis.session.SqlSessionFactoryBuilder#build
org.apache.ibatis.builder.xml.XMLConfigBuilder#parse

  public Configuration parse() {if (parsed) {throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

解析 mybatis-config.xml 中的每一个节点。

org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration

  private void parseConfiguration(XNode root) {
    try {
      // issue #117 read properties first
      propertiesElement(root.evalNode("properties"));
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(settings);
      loadCustomLogImpl(settings);
      typeAliasesElement(root.evalNode("typeAliases"));
      pluginElement(root.evalNode("plugins")); // 解析插件配置
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      settingsElement(settings);
      // read it after objectFactory and objectWrapperFactory issue #631
      environmentsElement(root.evalNode("environments")); // 解析环境配置:数据源、事务管理
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      typeHandlerElement(root.evalNode("typeHandlers"));
      mapperElement(root.evalNode("mappers")); // 解析映射文件
    } catch (Exception e) {throw new BuilderException("Error parsing SQL Mapper Configuration. Cause:" + e, e);
    }
  }

解析失去 Configuration 对象之后,能够用它来结构 SqlSessionFactory 对象。

org.apache.ibatis.session.SqlSessionFactoryBuilder#build(org.apache.ibatis.session.Configuration)

  public SqlSessionFactory build(Configuration config) {return new DefaultSqlSessionFactory(config);
  }

2.1.2 解析 SQL 映射文件

SQL 映射文件 com\sumkor\mapper\StudentMapper.xml 示例如下,更多阐明见官网文档 -XML 映射

<mapper namespace="com.sumkor.mapper.StudentMapper">
    <!-- 要留神 MyBatis 不会通过检测数据库元信息来决定应用哪种类型,所以必须在参数和后果映射中指明字段的 jdbcType 类型,以使其可能绑定到正确的类型处理器上。这是因为 MyBatis 直到语句被执行时才分明数据类型 -->
    <resultMap id="BaseResultMap" type="com.sumkor.entity.Student">
        <id column="id" jdbcType="INTEGER" property="id"/>
        <result column="name" jdbcType="VARCHAR" property="name"/>
        <result column="phone" jdbcType="VARCHAR" property="phone"/>
        <result column="email" jdbcType="VARCHAR" property="email"/>
        <result column="sex" jdbcType="TINYINT" property="sex"/>
        <result column="locked" jdbcType="TINYINT" property="locked"/>
        <result column="gmt_created" jdbcType="TIMESTAMP" property="gmtCreated"/>
        <result column="gmt_modified" jdbcType="TIMESTAMP" property="gmtModified"/>
        <!-- 反对的 jdbcType 见 org.apache.ibatis.type.JdbcType 或者 https://mybatis.org/mybatis-3/zh/sqlmap-xml.html -->
    </resultMap>

    <sql id="base_column_list">
        id, name, phone, email, sex, locked, gmt_created, gmt_modified
    </sql>

    <select id="selectAll" resultMap="BaseResultMap">
        select
        <include refid="base_column_list"/>
        from student
    </select>
</mapper>    

在解析 mybatis-config.xml 文件的时候,解析 mappers 标签,找到对应的 SQL 映射文件。

org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration
org.apache.ibatis.builder.xml.XMLConfigBuilder#mapperElement
org.apache.ibatis.session.Configuration#addMappers
org.apache.ibatis.binding.MapperRegistry#addMapper
org.apache.ibatis.builder.annotation.MapperAnnotationBuilder#parse
org.apache.ibatis.builder.xml.XMLMapperBuilder#parse
org.apache.ibatis.builder.xml.XMLMapperBuilder#configurationElement

  private void configurationElement(XNode context) {
    try {String namespace = context.getStringAttribute("namespace");
      if (namespace == null || namespace.isEmpty()) {throw new BuilderException("Mapper's namespace cannot be empty");
      }
      builderAssistant.setCurrentNamespace(namespace);
      cacheRefElement(context.evalNode("cache-ref"));
      cacheElement(context.evalNode("cache"));
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));
      resultMapElements(context.evalNodes("/mapper/resultMap"));
      sqlElement(context.evalNodes("/mapper/sql"));
      buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {throw new BuilderException("Error parsing Mapper XML. The XML location is'" + resource + "'. Cause:" + e, e);
    }
  }

SQL 映射文件中一个 <select|update|delete|insert> 节点,会被解析为 MappedStatement 对象。

org.apache.ibatis.mapping.MappedStatement

// 该对象示意 Mapper.xml 中的一条 SQL 信息,相干标签见 org\apache\ibatis\builder\xml\mybatis-3-mapper.dtd
public final class MappedStatement {     

  private String resource;
  private Configuration configuration;
  private String id;
  private Integer fetchSize;             // 这是一个给驱动的倡议值,尝试让驱动程序每次批量返回的后果行数等于这个设置值。默认值为未设置(unset)(依赖驱动)。private Integer timeout;               // 驱动程序期待数据库返回申请后果的秒数,超时将会抛出异样
  private StatementType statementType;   // 参数可选值为 STATEMENT、PREPARED 或 CALLABLE,这会让 MyBatis 别离应用 Statement、PreparedStatement 或 CallableStatement 与数据库交互,默认值为 PREPARED
  private ResultSetType resultSetType;   // 参数可选值为 FORWARD_ONLY、SCROLL_SENSITIVE 或 SCROLL_INSENSITIVE,用于设置从后果集读取数据时,读指针是否高低挪动。例如,只须要程序读取,可设置为 FORWARD_ONLY,便于开释已读内容所占的内存
  private SqlSource sqlSource;           // sql 语句
  private Cache cache;                   // 二级缓存,若无配置则为空
  private ParameterMap parameterMap;
  private List<ResultMap> resultMaps;
  private boolean flushCacheRequired;    // 对应 xml 中的 flushCache 属性。将其设置为 true 后,只有语句被调用,都会导致本地缓存和二级缓存被清空,默认值:false。private boolean useCache;              // 对应 xml 中的 useCache 属性。将其设置为 true 后,将会导致本条语句的后果被二级缓存缓存起来,默认值:对 select 元素为 true。private boolean resultOrdered;         // 这个设置仅针对嵌套后果 select 语句。默认值:false。private SqlCommandType sqlCommandType; // sql 语句的类型,如 select、update、delete、insert
  private KeyGenerator keyGenerator;
  private String[] keyProperties;
  private String[] keyColumns;
  private boolean hasNestedResultMaps;
  private String databaseId;
  private Log statementLog;
  private LanguageDriver lang;
  private String[] resultSets;

生成 MappedStatement 对象之后,会将其注册到 Configuration 对象之中:

org.apache.ibatis.builder.MapperBuilderAssistant#addMappedStatement
org.apache.ibatis.session.Configuration#addMappedStatement

  protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection")
      .conflictMessageProducer((savedValue, targetValue) ->
          ". please check" + savedValue.getResource() + "and" + targetValue.getResource());

  public void addMappedStatement(MappedStatement ms) {mappedStatements.put(ms.getId(), ms);
  }

Configuration 对象中的 mappedStatements 属性是一个 StrictMap 类型,是 MyBatis 的一个外部类。
能够看到,这里以 MappedStatement#id 进行注册,会同时注册一个短名称(eg:selectAll)和长名称(eg:com.sumkor.mapper.StudentMapper.selectAll)。

org.apache.ibatis.session.Configuration.StrictMap#put

    @Override
    @SuppressWarnings("unchecked")
    public V put(String key, V value) {if (containsKey(key)) {
        throw new IllegalArgumentException(name + "already contains value for" + key
            + (conflictMessageProducer == null ? "" : conflictMessageProducer.apply(super.get(key), value)));
      }
      if (key.contains(".")) {final String shortKey = getShortName(key);
        if (super.get(shortKey) == null) {super.put(shortKey, value); // 以短名称进行注册
        } else {super.put(shortKey, (V) new Ambiguity(shortKey)); // 短名称注册呈现抵触
        }
      }
      return super.put(key, value); // 以全名称注册
    }

2.2 开启会话

SqlSession sqlSession = sqlSessionFactory.openSession()

对于 SqlSession 的官网阐明:

SqlSession 提供了在数据库执行 SQL 命令所需的所有办法。能够通过 SqlSession 实例来间接执行已映射的 SQL 语句。
每个线程都应该有它本人的 SqlSession 实例。SqlSession 的实例不是线程平安的,因而是不能被共享的,所以它的最佳的作用域是申请或办法作用域。
在 Web 利用中,每次收到 HTTP 申请,就能够关上一个 SqlSession,返回一个响应后,就敞开它。

构建 SqlSession 实例,代码如下。默认 autoCommit 为 false。
留神,每一个 SqlSession 会话都有单独的 Executor 和 Transaction 实例。

org.apache.ibatis.session.defaults.DefaultSqlSessionFactory#openSession
org.apache.ibatis.session.defaults.DefaultSqlSessionFactory#openSessionFromDataSource

  private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {final Environment environment = configuration.getEnvironment();
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      // 通过事务工厂,实例化 Transaction 事务对象
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit); 
      // 实例化 Executor 执行器对象,通过它来执行 SQL,反对插件扩大
      final Executor executor = configuration.newExecutor(tx, execType); 
      // 构建 SqlSession 
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause:" + e, e);
    } finally {ErrorContext.instance().reset();}
  }

默认应用 SimpleExecutor 作为执行器,作为 MyBatis 的调度核心。

org.apache.ibatis.session.Configuration#newExecutor

  public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    // 该类型的执行器会批量执行所有更新语句,如果 SELECT 在多个更新两头执行,将在必要时将多条更新语句分隔开来,以不便了解。if (ExecutorType.BATCH == executorType) {executor = new BatchExecutor(this, transaction);
    } 
    // 该类型的执行器会复用预处理语句。else if (ExecutorType.REUSE == executorType) {executor = new ReuseExecutor(this, transaction);
    } 
    // 该类型的执行器没有特地的行为。它为每个语句的执行创立一个新的预处理语句。else {executor = new SimpleExecutor(this, transaction);
    }
    if (cacheEnabled) {executor = new CachingExecutor(executor);
    }
    // 应用插件来包装 executor
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

2.3 执行 SQL

List<Student> students = sqlSession.selectList("selectAll");
  • 全限定名(比方“com.sumkor.mapper.StudentMapper.selectAll)将被间接用于查找及应用。
  • 短名称(比方“selectAll”)如果全局惟一也能够作为一个独自的援用。如果不惟一,有两个或两个以上的雷同名称(比方“com.foo.selectAll”和“com.bar.selectAll”),那么应用时就会产生“短名称不惟一”的谬误,这种状况下就必须应用全限定名。

这里通过字符串 selectAll 从 Configuration 对象之中,查找到对应的 MappedStatement 对象。

org.apache.ibatis.session.defaults.DefaultSqlSession#selectList

  private <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
    try {MappedStatement ms = configuration.getMappedStatement(statement); // 依据 SQL id 从配置类中获取 SQL 解析后的对象
      return executor.query(ms, wrapCollection(parameter), rowBounds, handler); // 执行 SQL
    } catch (Exception e) {throw ExceptionFactory.wrapException("Error querying database.  Cause:" + e, e);
    } finally {ErrorContext.instance().reset();}
  }

2.3.1 Executor#query

查询数据库之前,会先查问 MyBatis 缓存。这里只关注数据库查问的局部:

org.apache.ibatis.executor.CachingExecutor#query
org.apache.ibatis.executor.BaseExecutor#query
org.apache.ibatis.executor.BaseExecutor#queryFromDatabase
org.apache.ibatis.executor.SimpleExecutor#doQuery

  @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 handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql); // 创立 StatementHandler,反对插件扩大
      stmt = prepareStatement(handler, ms.getStatementLog()); // 获取数据库连贯对象 Connection,以结构 Statement 对象
      return handler.query(stmt, resultHandler);
    } finally {closeStatement(stmt);
    }
  }

Executor 对象的次要性能是创立并应用 StatementHandler 拜访数据库,并将查问后果存入缓存中(如果配置了缓存的话)。

2.3.2 Executor#prepareStatement

Executor 在创立失去 StatementHandler 对象之后,利用 StatementHandler#prepare 来构建 Statement 对象。

org.apache.ibatis.executor.SimpleExecutor#prepareStatement

  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    Connection connection = getConnection(statementLog); // 获取数据库连贯对象
    stmt = handler.prepare(connection, transaction.getTimeout()); // 应用 Connection 对象结构 Statement 对象
    handler.parameterize(stmt); // 其中会应用 ParameterHandler 设置参数,反对插件扩大
    return stmt;
  }

org.apache.ibatis.executor.statement.BaseStatementHandler#prepare
org.apache.ibatis.executor.statement.BaseStatementHandler#instantiateStatement
org.apache.ibatis.executor.statement.PreparedStatementHandler#instantiateStatement

  protected Statement instantiateStatement(Connection connection) throws SQLException {
    // ...
    String sql = boundSql.getSql();
    return connection.prepareStatement(sql);
  }

到了 JDBC 层面,通过 Connection 来创立 Statement 对象,最初取得 ClientPreparedStatement 实例。

java.sql.Connection#prepareStatement(java.lang.String, int, int)
com.mysql.cj.jdbc.ConnectionImpl#prepareStatement
com.mysql.cj.jdbc.ConnectionImpl#clientPrepareStatement(java.lang.String, int, int, boolean)
com.mysql.cj.jdbc.ClientPreparedStatement#getInstance(com.mysql.cj.jdbc.JdbcConnection, java.lang.String, java.lang.String)

protected static ClientPreparedStatement getInstance(JdbcConnection conn, String sql, String db) throws SQLException {return new ClientPreparedStatement(conn, sql, db);
}

2.3.3 StatementHandler#query

获取失去 Statement 对象之后,利用 StatementHandler#query 办法来执行 SQL 语句。

org.apache.ibatis.executor.SimpleExecutor#doQuery
org.apache.ibatis.executor.statement.RoutingStatementHandler#query
org.apache.ibatis.executor.statement.PreparedStatementHandler#query

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

到了 JDBC 层面,交由 MySQL 驱动中的 PreparedStatement 对象来执行 SQL。

org.apache.ibatis.logging.jdbc.PreparedStatementLogger#invoke
com.mysql.cj.jdbc.ClientPreparedStatement#execute

2.4 后果映射

在 StatementHandler#query 中通过 PreparedStatement 执行完 SQL 之后,向 MySQL 服务器读取响应。

org.apache.ibatis.executor.SimpleExecutor#doQuery
org.apache.ibatis.executor.statement.RoutingStatementHandler#query
org.apache.ibatis.executor.statement.PreparedStatementHandler#query

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

通过 JDBC 从数据库读取到的是二进制数据,封装在 ResultSet 对象中。
须要将 ResultSet 中的数据,转换成配置在 SQL 映射文件的 ResultMap 对象。

本例中 ResultMap 配置如下,更多配置阐明见官网文档 -XML 映射

<mapper namespace="com.sumkor.mapper.StudentMapper">
    <!-- 要留神 MyBatis 不会通过检测数据库元信息来决定应用哪种类型,所以必须在参数和后果映射中指明字段的 jdbcType 类型,以使其可能绑定到正确的类型处理器上。这是因为 MyBatis 直到语句被执行时才分明数据类型 -->
    <resultMap id="BaseResultMap" type="com.sumkor.entity.Student">
        <id column="id" jdbcType="INTEGER" property="id"/>
        <result column="name" jdbcType="VARCHAR" property="name"/>
        <result column="phone" jdbcType="VARCHAR" property="phone"/>
        <result column="email" jdbcType="VARCHAR" property="email"/>
        <result column="sex" jdbcType="TINYINT" property="sex"/>
        <result column="locked" jdbcType="TINYINT" property="locked"/>
        <result column="gmt_created" jdbcType="TIMESTAMP" property="gmtCreated"/>
        <result column="gmt_modified" jdbcType="TIMESTAMP" property="gmtModified"/>
        <!-- 反对的 jdbcType 见 org.apache.ibatis.type.JdbcType 或者 https://mybatis.org/mybatis-3/zh/sqlmap-xml.html -->
    </resultMap>
</mapper>    

代码流程:

  1. 从数据库读取的响应数据 ResultSet 对象。
  2. 获取配置在 SQL 映射文件的 ResultMap 对象,生成对应的 Java 实体对象。
  3. 利用 ResultSet 对象中的数据,对 Java 实体对象的属性进行赋值。

org.apache.ibatis.executor.resultset.DefaultResultSetHandler#handleResultSets

  @Override
  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;
    ResultSetWrapper rsw = getFirstResultSet(stmt); // 从数据库读取的响应数据 ResultSet 对象

    List<ResultMap> resultMaps = mappedStatement.getResultMaps(); // 配置在 SQL 映射文件的 ResultMap 对象
    int resultMapCount = resultMaps.size();
    validateResultMapsCount(rsw, resultMapCount);
    while (rsw != null && resultMapCount > resultSetCount) {ResultMap resultMap = resultMaps.get(resultSetCount);
      handleResultSet(rsw, resultMap, multipleResults, null); // 生成 Java 实体对象并进行属性赋值,存储在 multipleResults
      rsw = getNextResultSet(stmt);
      cleanUpAfterHandlingResultSet();
      resultSetCount++;
    }

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

值得注意的是,并不是所有在 ResultSet 中的二进制数据,都须要转换成 Java 实体对象。

  1. 应用 RowBounds 的状况下,阐明用到了 MyBatis 提供的通用分页性能。只须要取 ResultSet 的 offset 到 limit 范畴的数据进行对象映射。
  2. 应用 Discriminator 的状况下,须要依据鉴别器的条件,进行对象映射。

org.apache.ibatis.executor.resultset.DefaultResultSetHandler#handleResultSet
org.apache.ibatis.executor.resultset.DefaultResultSetHandler#handleRowValues
org.apache.ibatis.executor.resultset.DefaultResultSetHandler#handleRowValuesForSimpleResultMap

  private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
      throws SQLException {DefaultResultContext<Object> resultContext = new DefaultResultContext<>();
    // 在查询数据库时,如果没有 limit 语句,则 ResultSet 中会蕴含所有满足条件的数据
    ResultSet resultSet = rsw.getResultSet(); 
    // 把 offset 之前的数据都 skip 掉
    skipRows(resultSet, rowBounds); 
    // 判断数据是否超过了 limit
    while (shouldProcessMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next()) { 
      // 如果配置了鉴别器 Discriminator,则对查问的后果进行分支解决
      ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(resultSet, resultMap, null); 
      // 将 ResultSet 中的一行数据转换为 ResultMap 的一个对象并赋值
      Object rowValue = getRowValue(rsw, discriminatedResultMap, null); 
      // 将后果存储到 ResultHandler 之中
      storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet); 
    }
  }

对于 ResultMap 中的鉴别器 Discriminator 和多后果集的阐明,见官网文档 -XML 映射

2.4.1 数据对象映射

  1. 依据 ResultMap 获取 Java 实体对象。
  2. 为 Java 实体对象的属性赋值。

org.apache.ibatis.executor.resultset.DefaultResultSetHandler#getRowValue

  private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, String columnPrefix) throws SQLException {final ResultLoaderMap lazyLoader = new ResultLoaderMap();
    Object rowValue = createResultObject(rsw, resultMap, lazyLoader, columnPrefix); // 获取 Java 实体类的实例,属性均为空
    if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {final MetaObject metaObject = configuration.newMetaObject(rowValue); // 反射工具类 MetaObject
      boolean foundValues = this.useConstructorMappings;
      if (shouldApplyAutomaticMappings(resultMap, false)) {foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
      }
      foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues; // 利用 MetaObject 为 Java 实体的属性赋值
      foundValues = lazyLoader.size() > 0 || foundValues;
      rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;}
    return rowValue;
  }

2.4.2 依据 ResultMap 获取 Java 实体对象

org.apache.ibatis.executor.resultset.DefaultResultSetHandler#createResultObject

  private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, List<Class<?>> constructorArgTypes, List<Object> constructorArgs, String columnPrefix)
      throws SQLException {final Class<?> resultType = resultMap.getType(); // Java 实体类型
    final MetaClass metaType = MetaClass.forClass(resultType, reflectorFactory); // 反射工具类 MetaClass
    final List<ResultMapping> constructorMappings = resultMap.getConstructorResultMappings();
    if (hasTypeHandlerForResultObject(rsw, resultType)) {return createPrimitiveResultObject(rsw, resultMap, columnPrefix);
    } else if (!constructorMappings.isEmpty()) {return createParameterizedResultObject(rsw, resultType, constructorMappings, constructorArgTypes, constructorArgs, columnPrefix);
    } else if (resultType.isInterface() || metaType.hasDefaultConstructor()) {return objectFactory.create(resultType); // 创立 Java 实体类的实例
    } else if (shouldApplyAutomaticMappings(resultMap, false)) {return createByConstructorSignature(rsw, resultType, constructorArgTypes, constructorArgs);
    }
    throw new ExecutorException("Do not know how to create an instance of" + resultType);
  }

2.4.3 为 Java 实体对象的属性赋值

从 ResultSet 中读取每一个字段的值,再赋值给 Java 实体的属性。

org.apache.ibatis.executor.resultset.DefaultResultSetHandler#applyPropertyMappings

  private boolean applyPropertyMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, ResultLoaderMap lazyLoader, String columnPrefix)
      throws SQLException {final List<String> mappedColumnNames = rsw.getMappedColumnNames(resultMap, columnPrefix);
    boolean foundValues = false;
    final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
    for (ResultMapping propertyMapping : propertyMappings) { // 遍历所有字段
      String column = prependPrefix(propertyMapping.getColumn(), columnPrefix); // 表字段名,例如:gmt_created
      if (propertyMapping.getNestedResultMapId() != null) {
        // the user added a column attribute to a nested result map, ignore it
        column = null;
      }
      if (propertyMapping.isCompositeResult()
          || (column != null && mappedColumnNames.contains(column.toUpperCase(Locale.ENGLISH)))
          || propertyMapping.getResultSet() != null) {Object value = getPropertyMappingValue(rsw.getResultSet(), metaObject, propertyMapping, lazyLoader, columnPrefix); // 获取字段的值
        // issue #541 make property optional
        final String property = propertyMapping.getProperty(); // 实体属性名,例如:gmtCreated
        if (property == null) {continue;} else if (value == DEFERRED) {
          foundValues = true;
          continue;
        }
        if (value != null) {foundValues = true;}
        if (value != null || (configuration.isCallSettersOnNulls() && !metaObject.getSetterType(property).isPrimitive())) {// gcode issue #377, call setter on nulls (value is not 'found')
          metaObject.setValue(property, value); // 为 Java 实体对象的字段赋值
        }
      }
    }
    return foundValues;
  }

至于如何从 ResultSet 中读取一个字段的值,这里是用到了 TypeHandler,做到 java 数据类型和 jdbc 数据类型之间的映射和转换。

org.apache.ibatis.executor.resultset.DefaultResultSetHandler#getPropertyMappingValue

  private Object getPropertyMappingValue(ResultSet rs, MetaObject metaResultObject, ResultMapping propertyMapping, ResultLoaderMap lazyLoader, String columnPrefix)
      throws SQLException {if (propertyMapping.getNestedQueryId() != null) {return getNestedQueryMappingValue(rs, metaResultObject, propertyMapping, lazyLoader, columnPrefix);
    } else if (propertyMapping.getResultSet() != null) {addPendingChildRelation(rs, metaResultObject, propertyMapping);   // TODO is that OK?
      return DEFERRED;
    } else {final TypeHandler<?> typeHandler = propertyMapping.getTypeHandler(); // 获取字段映射所需的 TypeHandler
      final String column = prependPrefix(propertyMapping.getColumn(), columnPrefix); // 获取数据库表的字段名
      return typeHandler.getResult(rs, column); // 进行 java 数据类型和 jdbc 数据类型之间的映射和转换
    }
  }

以 IntegerTypeHandler 为例,从 ResultSet 之中读取字段名 columnName 对应的数据,该字段的数据类型为 int。

org.apache.ibatis.type.IntegerTypeHandler#getNullableResult

  @Override
  public Integer getNullableResult(ResultSet rs, String columnName)
      throws SQLException {int result = rs.getInt(columnName);
    return result == 0 && rs.wasNull() ? null : result;}

3. 总结

MyBatis 执行 SQL 的流程:

  1. 加载配置:将 MyBatis XML 配置文件解析为 Configuration 对象,其中,会将 SQL 映射文件中的 SQL 语句解析为 MappedStatement 对象,存储在 Configuration 对象中。
  2. SQL 解析:通过 SQLSession 接管到申请时,依据传入的 SQL id 找到对应的 MappedStatement 对象。
  3. SQL 执行:由 Executor 进行调度,向缓存或数据库发动查问,失去查问后果。
  4. 后果映射:依照映射的配置对查问后果进行转换,能够转换成 HashMap、JavaBean 或者根本数据类型,并将最终后果返回。

作者:Sumkor
链接:https://segmentfault.com/a/11…

退出移动版