Mybatis源码(八)：查询执行流程

　　在Mybatis源码(七)：SQL执行流程中已提到，根据不同的sqlCommandType执行不同类型的SQL，下面来看看调用Mapper接口的查询，Mybatis中做了哪些处理。

UserMapper mapper = sqlSession.getMapper(UserMapper.class);
// 查询流程
User user02 = mapper.selectUserById("101");

　　查询流程最终会执行到DefaultSqlSession的selectList()方法，DefaultSqlSession#selectList() 核心伪代码

1 public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
2     // 根据statement id找到对应的MappedStatement
3     MappedStatement ms = configuration.getMappedStatement(statement);
4     // 如果 cacheEnabled = true（默认），Executor会被 CachingExecutor装饰
5     return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
6 }

1、获取MappedStatement对象

　　根据statementid(sql标识id)从全局配置对象configuration中拿到MappedStatement，MappedStatement对象中有Mapper.xml中标签的所有属性，如id、statementType、sqlSource、useCache、入参、出参等等。

2、SQL查询执行流程

　　Executor是在创建sqlSession对象时创建的，在创建BaseExecutor/ReuseExecutor/BatchExecutor之后，根据缓存配置判断是否对Executor进行对象装饰。

1 // 默认启用缓存
2 protected boolean cacheEnabled = true;
3 
4 if (cacheEnabled) {
5   executor = new CachingExecutor(executor);
6 }

　　若显示的在settings中配置cacheEnabled=false，会直接调用BaseExecutor的query方法。若未配置或者显示的在settings中配置cacheEnabled=true，会优先执行CachingExecutor中的逻辑，之后再调用BaseExecutor中的逻辑。

　　CachingExecutor#query() 核心代码：

1 public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
2   // 创建BoundSql对象，包含目标执行sql、参数信息
3   BoundSql boundSql = ms.getBoundSql(parameterObject);
4   // 创建CacheKey对象，用来命中缓存
5   CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
6   // 查询
7   return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
8 }

1、创建BoundSql对象

　　StaticSqlSource#getBoundSql() 核心代码

public BoundSql getBoundSql(Object parameterObject) {
 return new BoundSql(configuration, sql, parameterMappings, parameterObject);
}

　　BoundSql对象中包含全局配置对象、xml中的sql，xml中sql的占位符#{}，sql参数。

2、创建CacheKey对象

　　若全局配置中开启了缓存，会根据CacheKey来判断要执行的SQL是否已经被缓存，怎样判断相同的SQL呢？下面来看CaacheKey对象

　　创建缓存key，BaseExecutor#createCacheKey() 核心方法：

 1 public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
 2   // 检测当前executor是否已经关闭
 3   if (closed) {
 4     throw new ExecutorException("Executor was closed.");
 5   }
 6   // 创建CacheKey对象
 7   CacheKey cacheKey = new CacheKey();
 8   // 查询的目标执行方法全路径限定名，并添加到cacheKey对象中
 9   cacheKey.update(ms.getId());
10   // 分页起始位置，并添加到cacheKey对象中
11   cacheKey.update(rowBounds.getOffset());
12   // 每页记录数，并添加到cacheKey对象中
13   cacheKey.update(rowBounds.getLimit());
14   // 目标执行sql添加到cacheKey对象中
15   cacheKey.update(boundSql.getSql());
16   List<ParameterMapping> parameterMappings = boundSql.getParameterMappings(); // sql中的变量参数映射
17   TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry(); // 获取类型处理注册器
18   // mimic DefaultParameterHandler logic
19   // 获取用户传入的实参，并添加到CacheKey对象中
20   for (ParameterMapping parameterMapping : parameterMappings) {
21     if (parameterMapping.getMode() != ParameterMode.OUT) {
22       Object value;
23       String propertyName = parameterMapping.getProperty(); // 获取xml文件中SQL中的变量#{?}
24       if (boundSql.hasAdditionalParameter(propertyName)) {
25         value = boundSql.getAdditionalParameter(propertyName);
26       } else if (parameterObject == null) {
27         value = null;
28       } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) { // 用户传入实参是否有类型处理器
29         value = parameterObject;
30       } else {
31         MetaObject metaObject = configuration.newMetaObject(parameterObject);
32         value = metaObject.getValue(propertyName);
33       }
34       // 将实参添加到CacheKey对象中
35       cacheKey.update(value);
36     }
37   }
38   // 如果environment的id不为空，则将其添加到CacheKey中
39   if (configuration.getEnvironment() != null) {
40     // issue #176
41     cacheKey.update(configuration.getEnvironment().getId());
42   }
43   return cacheKey;
44 }

　　Mybatis中，拥有相同的方法、翻页偏移、SQL、参数值、数据源环境会被认为是同一个SQL查询。

 1   // 创建CacheKey对象
 2   CacheKey cacheKey = new CacheKey();
 3   // 查询的目标执行方法全路径限定名，并添加到cacheKey对象中
 4   cacheKey.update(ms.getId());
 5   // 分页起始位置，并添加到cacheKey对象中
 6   cacheKey.update(rowBounds.getOffset());
 7   // 每页记录数，并添加到cacheKey对象中
 8   cacheKey.update(rowBounds.getLimit());
 9   // 目标执行sql添加到cacheKey对象中
10   cacheKey.update(boundSql.getSql());
11   // 将实参添加到CacheKey对象中
12   cacheKey.update(value);
13   // environment环境信息
14   cacheKey.update(configuration.getEnvironment().getId());

　　CacheKey#update() 核心代码：

 1 private static final int DEFAULT_MULTIPLYER = 37;
 2 private static final int DEFAULT_HASHCODE = 17;
 3 
 4 // 用于判重
 5 private int hashcode;
 6 private long checksum;
 7 private int count;
 8 // 存储sql信息，用于生成hashcode
 9 private List<Object> updateList;
10 
11 // 构造函数
12 public CacheKey() {
13   this.hashcode = DEFAULT_HASHCODE;
14   this.multiplier = DEFAULT_MULTIPLYER;
15   this.count = 0;
16   this.updateList = new ArrayList<>();
17 }
18 
19 // CacheKey设置进updateList属性中
20 public void update(Object object) {
21   int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object);
22 
23   count++;
24   checksum += baseHashCode;
25   baseHashCode *= count;
26 
27   // 每添加一个object，都重新生成hashCode
28   // 生成hashCode用于快速判重，判断是否为同一个CacheKey，重写了Object的equals方法
29   hashcode = multiplier * hashcode + baseHashCode;
30 
31   // 将值设置进updateList中
32   updateList.add(object);
33 }

　　hashCode()是Object中的一个本地方法，通过随机数算法生成，返回自己生成的hashCode。

　　在生成CacheKey的时候（update方法），每添加一个参数就会重新生成CacheKey的hashCode，hashcode是用乘法哈希生成的（基数baseHashCode=17，乘法因子multiplier=37）。

　　CacheKey对hashCode()方法进行了重写，若哈希值（乘法哈希）、校验值（加法哈希）、要素个数任何一个不相等，都不是同一个查询，最后循环比较要素，防止哈希碰撞。

 1 // 重写equals方法
 2 public boolean equals(Object object) {
 3   if (this == object) {
 4     return true;
 5   }
 6   if (!(object instanceof CacheKey)) {
 7     return false;
 8   }
 9 
10   final CacheKey cacheKey = (CacheKey) object;
11 
12   if (hashcode != cacheKey.hashcode) {
13     return false;
14   }
15   if (checksum != cacheKey.checksum) {
16     return false;
17   }
18   if (count != cacheKey.count) {
19     return false;
20   }
21 
22   for (int i = 0; i < updateList.size(); i++) {
23     Object thisObject = updateList.get(i);
24     Object thatObject = cacheKey.updateList.get(i);
25     if (!ArrayUtil.equals(thisObject, thatObject)) {
26       return false;
27     }
28   }
29   return true;
30 }

CacheKey详情如下：

3、执行查询SQL

　　CacheKey生成之后，执行SQL查询，CachingExecutor#query() 核心代码：

 1 public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
 2     throws SQLException {
 3   // 获取查询语句所在命名空间对应的二级缓存
 4   Cache cache = ms.getCache();
 5   // 是否开启了二级缓存
 6   if (cache != null) {
 7     // 根据select节点的配置，决定是否需要清空二级缓存
 8     flushCacheIfRequired(ms);
 9     // 检测SQL节点的useCache配置以及是否使用了resultHandler配置
10     if (ms.isUseCache() && resultHandler == null) {
11       // 二级缓存不能保存输出类型的参数，如果查询操作调用了包含输出参数的存储过程，则报错
12       ensureNoOutParams(ms, boundSql);
13       @SuppressWarnings("unchecked")
14       // 查询二级缓存
15       List<E> list = (List<E>) tcm.getObject(cache, key);
16       if (list == null) {
17         // 二级缓存没有相应的结果对，调用封装的Executor对象的query方法
18         list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
19         // 将查询结果保存到TransactionalCache.entriesToAddOnCommit集合中
20         tcm.putObject(cache, key, list); // issue #578 and #116
21       }
22       return list;
23     }
24   }
25   // 没有启动二级缓存，直接调用底层Executor执行数据库查询操作
26   return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
27 }

　　优先判断缓存开关是否打开，若缓存开关打开，根据CacheKey判断是否命中二级缓存，未命中二级缓存，调用CachingExecutor持有的Executor对象的query方法。

　　调用CachingExecutor父类BaseExecutor的query()方法，BaseExecutor#query() 核心伪代码

 1 public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
 2   ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
 3   // 检测当前Executor是否已经关闭
 4   if (closed) {
 5     throw new ExecutorException("Executor was closed.");
 6   }
 7    // 非嵌套查询，并且select节点配置的flushCache属性为true时，才会清空一级缓存
 8   if (queryStack == 0 && ms.isFlushCacheRequired()) {
 9     clearLocalCache();
10   }
11   List<E> list;
12   try {
13     // 增加查询层数
14     queryStack++;
15     // 查询一级缓存
16     list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
17     // 针对存储过程调用的处理，在一级缓存命中时，获取缓存中保存的输出类型参数，并设置到用户传入的实参对象中
18     if (list != null) {
19       handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
20     // 调用doQuery方法完成数据库查询，并得到映射后的结果对象
21     } else {
22       list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
23     }
24   } finally {
25     // 当前查询完成，查询层数减少
26     queryStack--;
27   }
28   // ..
29   return list;
30 }

　　根据CacheKey判断是否命中一级缓存，若命中一级缓存则从缓存中获取；若未命中一级缓存，执行queryFromDatabase()方法查询数据库。

　　BaseExecutor#queryFromDatabase() 核心方法:

 1 private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
 2   List<E> list;
 3   // 在一级缓存中添加占位符
 4   localCache.putObject(key, EXECUTION_PLACEHOLDER);
 5   try {
 6     // 完成数据库查询操作，并返回结果对象，默认Simple
 7     list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
 8   } finally {
 9     // 删除缓存占位符
10     localCache.removeObject(key);
11   }
12   // 将真正的结果对象添加到一级缓存中
13   localCache.putObject(key, list);
14   // 存储过程的调用处理
15   if (ms.getStatementType() == StatementType.CALLABLE) {
16     // 缓存输出类型的参数
17     localOutputParameterCache.putObject(key, parameter);
18   }
19   return list;
20 }

SimpleExecutor#doQuery() 核心代码

 1 public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
 2   Statement stmt = null;
 3   try {
 4     // 获取全局配置对象configuration
 5     Configuration configuration = ms.getConfiguration();
 6     // 创建StatementHandler对象，实际返回的是RoutingStatementHandler对象
 7     StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
 8     // 完成SQL中变量值的替换，获取完整的sql查询语句
 9     stmt = prepareStatement(handler, ms.getStatementLog());
10     return handler.query(stmt, resultHandler);
11   } finally {
12     closeStatement(stmt);
13   }
14 }

3.1、StatementHandler
　　configuration.newStatementHandler()创建一个RoutingStatementHandler对象，并向StatementHandler中植入插件。

1 //创建语句处理器
2 public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
3   //创建路由选择语句处理器，根据statementType创建不同类型的StatementHandler
4   StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
5   //  植入插件
6   statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
7   return statementHandler;
8 }

　　RoutingStatementHandler构造函数详情如下：

 1 // 封装的真正的StatementHandler对象
 2 private final StatementHandler delegate;
 3 
 4 public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
 5   // 根据MappedStatement的配置，生成一个对应的StatementHandler对象，并设置到delegate字段中
 6   switch (ms.getStatementType()) {  
 7     case STATEMENT:
 8       delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
 9       break;
10     case PREPARED:
11       delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
12       break;
13     case CALLABLE:
14       delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
15       break;
16     default:
17       throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
18   }
19 }

　　根据同的MappedStatement中的statementType属性，判断要创建何种类型的StatementHandler，默认为PREPARED。statementType设值的位置，详见Mybatis 源码(四)：Mapper的解析工作。
　　StatementType详情如下：

1 public enum StatementType {
2   // STATEMENT 对应 SimpleStatementHandler
3   // PREPARED 对应 PreparedStatementHandler
4   // CALLABLE 对应 CallableStatementHandler
5   STATEMENT, PREPARED, CALLABLE
6 }

　　在创建PreparedStatementHandler对象时，调用父类BaseStatementHandler的构造方法，初始化了参数处理器parameterHandler，返回结果处理器resultSetHandler。

 1 // 将结果集映射成结果对象
 2 protected final ResultSetHandler resultSetHandler;
 3 // 参数处理器，SQL语句占位符设置为实参
 4 protected final ParameterHandler parameterHandler;
 5 
 6 protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
 7   this.configuration = mappedStatement.getConfiguration();
 8   this.executor = executor;
 9   this.mappedStatement = mappedStatement;
10   this.rowBounds = rowBounds;
11 
12   this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
13   this.objectFactory = configuration.getObjectFactory();
14 
15   if (boundSql == null) { // issue #435, get the key before calculating the statement
16     generateKeys(parameterObject);
17     boundSql = mappedStatement.getBoundSql(parameterObject);
18   }
19 
20   this.boundSql = boundSql;
21   
22   // 创建parameterHandler并完成赋值
23   this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
24   // 创建resultSetHandler并完成赋值
25   this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
26 }

　　参数处理器parameterHandler，主要为SQL语句绑定实参，用传入的实参替换SQL语句中的占位符?

　　返回值处理器resultSetHandler，主要将结果集映射为结果对象。

1、参数处理器

　　Mybatis中参数处理器默认为DefaultParameterHandler，在创建参数处理器后，可植入插件做拦截处理。
　　configuration#newParameterHandler() 核心代码

1 // 创建参数处理器
2 public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
3   // 创建ParameterHandler
4   ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
5   // 设置插件
6   parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
7   return parameterHandler;
8 }

　　DefaultParameterHandler详情如下：

2、返回值处理器

　　Mybatis中结果集处理器默认为DefaultResultSetHandler，在设置结果集处理器时，可植入插件做拦截处理。

1 // 创建结果集处理器
2 public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
3     ResultHandler resultHandler, BoundSql boundSql) {
4   //创建DefaultResultSetHandler
5   ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
6   resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
7   return resultSetHandler;
8 }

　　DefaultResultSetHandler详情如下：

3.2、Statement -> SQL语句处理

　　SQL语句处理，主要完成三件事：获取数据库连接、创建数据库执行对象Statement、使用Statement对象替换SQL中的占位符？。

　　SimpleExecutor#prepareStatement() 核心代码：

 1 private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
 2   Statement stmt;
 3   // 获取JBDC连接
 4   Connection connection = getConnection(statementLog);
 5   // 创建Statement对象
 6   stmt = handler.prepare(connection, transaction.getTimeout());
 7   // 处理SQL中的占位符1
 8   handler.parameterize(stmt);
 9   return stmt;
10 }

1、获取数据库连接

　　BaseExecutor#getConnection() 核心代码：

 1 // Transaction对象，实现事务的提交、回滚和关闭操作
 2 protected Transaction transaction;
 3 
 4 protected Connection getConnection(Log statementLog) throws SQLException {
 5   Connection connection = transaction.getConnection();
 6   if (statementLog.isDebugEnabled()) {
 7     // 若需要打印日志，返回一个ConnectionLogger(代理模式, AOP思想)
 8     return ConnectionLogger.newInstance(connection, statementLog, queryStack);
 9   } else {
10     // 不需要打印日志，直接返回连接
11     return connection;
12   }
13 }

　　在全局配置中事务管理器设置的为JDBC。

<transactionManager type="JDBC"/>

　　在类型初始化configuration时，别名注册器中对JDBC别名映射的对象为JdbcTransactionFactory，通过事务工厂创建事务对象JdbcTransaction。

typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);

　　从事务中获取连接，JdbcTransaction#openConnection() 核心代码：

1 protected void openConnection() throws SQLException {
2   connection = dataSource.getConnection();
3   if (level != null) {
4     connection.setTransactionIsolation(level.getLevel());
5   }
6   setDesiredAutoCommit(autoCommit);
7 }

　　从数据源中获取连接，并设置连接的自动提交标识，默认为false; 若指定了事务隔离级别，则设置连接的隔离级别。

2、创建Statement对象

　　BaseStatementHandler#prepare() 核心伪代码

 1 public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
 2   ErrorContext.instance().sql(boundSql.getSql());
 3   Statement statement = null;
 4   // 实例化Statement
 5   statement = instantiateStatement(connection);
 6   // 设置超时
 7   setStatementTimeout(statement, transactionTimeout);
 8   // 设置读取条数
 9   setFetchSize(statement);
10   return statement;
11 }

1、实例化Statement对象

　　实例化Statement对象，PreparedStatementHandler#instantiateStatement() 核心代码

 1 protected Statement instantiateStatement(Connection connection) throws SQLException {
 2   // 获取待执行的SQL语句
 3   String sql = boundSql.getSql();
 4   // 根据keyGenerator字段的值，创建PreparedStatement对象
 5   if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {
 6     String[] keyColumnNames = mappedStatement.getKeyColumns();
 7     if (keyColumnNames == null) {
 8       // 返回数据库生成的主键
 9       return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
10     } else {
11       // 在insert语句执行完成之后，会将keyColumnNames指定的列返回
12       return connection.prepareStatement(sql, keyColumnNames);
13     }
14   } else if (mappedStatement.getResultSetType() == ResultSetType.DEFAULT) {
15     // 创建普通的PreparedStatement对象
16     return connection.prepareStatement(sql);
17   } else {
18     // 设置结果集是否可以滚动以及其游标是否可以上下移动，设置结果集是否可更新
19     return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
20   }
21 }

　　在解析Mapper配置，MapperBuilderAssistant#addMappedStatement()中创建MappedStatement的内部类Builder时，会将MappedStatement中resultSetType属性设置为ResultSetType.DEFAULT。

　　根据及resultSetType类型，通过数据库连接创建PreparedStatement对象。

2、PreparedStatement属性填充

　　设置PreparedStatement的超时时间及匹配数据条数。

3、SQL语句占位符处理

　　DefaultParameterHandler#setParameters() 核心伪代码：

 1 // 用户传入的实参对象
 2 private final Object parameterObject;
 3 
 4 public void setParameters(PreparedStatement ps) {
 5   ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
 6   // 取出sql中的参数映射列表
 7   List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
 8   // 检测parameterMappings集合是否为空
 9   if (parameterMappings != null) {
10     for (int i = 0; i < parameterMappings.size(); i++) {
11       ParameterMapping parameterMapping = parameterMappings.get(i);
12       // 过滤掉存储过程中的输出参数
13       if (parameterMapping.getMode() != ParameterMode.OUT) {
14         // 记录绑定的实参
15         Object value;
16         // 获取参数名称
17         String propertyName = parameterMapping.getProperty();
18         // ...
19         if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
20           // 实参可以直接通过TypeHandler转换成JdbcType
21           value = parameterObject;
22         }
23         // ...
24         // 获取parameterMapping中设置的TypeHandler对象
25         TypeHandler typeHandler = parameterMapping.getTypeHandler();
26         JdbcType jdbcType = parameterMapping.getJdbcType();
27         if (value == null && jdbcType == null) {
28           //不同类型的set方法不同，所以委派给子类的setParameter方法
29           jdbcType = configuration.getJdbcTypeForNull();
30         }
31         // 调用PreparedStatement.set*方法为SQL语句绑定相应的实参
32         typeHandler.setParameter(ps, i + 1, value, jdbcType);        
33       }
34     }
35   }
36 }

　　获取sql中的参数映射表，包含了参数值Mapper.xml中映射SQL中的参数名称#{id},及参数类型。

　　遍历参数映射表，类型处理器注册器中是否有处理器可以处理用户传入的实参类型，TypeHandlerRegistry#hasTypeHandler() 核心代码：

1 // 判断类型处理注册器中的类型处理器是否可以处理javaType、jdbcType
2 public boolean hasTypeHandler(Class<?> javaType, JdbcType jdbcType) {
3   return javaType != null && getTypeHandler((Type) javaType, jdbcType) != null;
4 }

　　TypeHandlerRegistry#getTypeHandler() 核心代码：

 1 private <T> TypeHandler<T> getTypeHandler(Type type, JdbcType jdbcType) {
 2   // 查找或初始化Java类型对应的TypeHandler集合
 3   Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = getJdbcHandlerMap(type);
 4   TypeHandler<?> handler = null;
 5   if (jdbcHandlerMap != null) {
 6     // 根据JdbcType类型查找TypeHandler对象
 7     handler = jdbcHandlerMap.get(jdbcType);
 8     if (handler == null) {
 9       handler = jdbcHandlerMap.get(null);
10     }
11     if (handler == null) {
12       // 如果jdbcHandlerMap只注册了一个TypeHandler,则使用此TypeHandler对象
13       handler = pickSoleHandler(jdbcHandlerMap);
14     }
15   }
16   // type drives generics here
17   return (TypeHandler<T>) handler;
18 }

　　根据用户传入参数的Class、JdbcType获取缓存中的TypeHandler。Mybatis中所有的类型处理器都在TypeHandlerRegistry的TYPE_HANDLER_MAP属性中。

　　TypeHandlerRegistry#getJdbcHandlerMap 核心伪代码：

 1 // 记录了Java类型向指定JdbcType转换时，需要使用TypeHandler对象
 2 private final Map<Type, Map<JdbcType, TypeHandler<?>>> TYPE_HANDLER_MAP = new ConcurrentHashMap<>();
 3 // 空TypeHandler集合
 4 private static final Map<JdbcType, TypeHandler<?>> NULL_TYPE_HANDLER_MAP = Collections.emptyMap();
 5 
 6 private Map<JdbcType, TypeHandler<?>> getJdbcHandlerMap(Type type) {
 7   // 查找指定Java类型对应TypeHandler集合
 8   Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(type);
 9   // 检测是否为空集合标识
10   if (NULL_TYPE_HANDLER_MAP.equals(jdbcHandlerMap)) {
11     return null;
12   }
13   // ...
14   TYPE_HANDLER_MAP.put(type, jdbcHandlerMap == null ? NULL_TYPE_HANDLER_MAP : jdbcHandlerMap);
15   return jdbcHandlerMap;
16 }

　　getJdbcHandlerMap()方法，根据传入实参Class，从TypeHandlerRegistry中TYPE_HANDLER_MAP属性中获取对应的类型处理器，若未匹配到，并且TYPE_HANDLER_MAP为空集合，返回null；若根据Class类型未匹配到TYPE_HANDLER_MAP中的类型处理器，将Class类型对应的类型处理器设置为空集合，返回获取到的类型处理器集合，最后再根据jdbcType的类型锁定目标参数类型处理器。

　　在TypeHandlerRegistry的构造函数中，完成了常用Class类型处理器的注册。

　　类型处理器集合示例如下：

　最后调用类型处理器基类BaseTypeHandler中的setParameter，BaseTypeHandler#setParameter() 核心伪代码：

 1 public void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {
 2   if (parameter == null) {
 3     if (jdbcType == null) {
 4       throw new TypeException("JDBC requires that the JdbcType must be specified for all nullable parameters.");
 5     }
 6     ps.setNull(i, jdbcType.TYPE_CODE);
 7   } else {
 8     setNonNullParameter(ps, i, parameter, jdbcType);
 9   }
10 }

　　当用户传入实参不为空时，调用子类的类型处理器setNonNullParameter方法，不同的类型处理器会设置不同的参数类型。如String类型处理器，StringTypeHandler#setNonNullParameter() 核心代码：

1 public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType)
2     throws SQLException {
3   ps.setString(i, parameter);
4 }

　　获取到的Statement对象详情如下，已生成可执行的SQL语句。

3.3、执行SQL查询

　　获取到PreparedStatement对象，执行SQL，处理结果集，PreparedStatementHandler#query() 核心代码：

1 public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
2   PreparedStatement ps = (PreparedStatement) statement;
3   //  JDBC的执行SQL查询
4   ps.execute();
5   // 处理结果集
6   return resultSetHandler.handleResultSets(ps);
7 }

　　DefaultResultSetHandler#handleResultSets() 核心代码：

 1 public List<Object> handleResultSets(Statement stmt) throws SQLException {
 2   ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
 3 
 4   // 该集合用于保存映射结果得到的结果对象
 5   final List<Object> multipleResults = new ArrayList<>();
 6 
 7   int resultSetCount = 0;
 8   // 创建ResultSetWrapper对象，封装resultSet
 9   ResultSetWrapper rsw = getFirstResultSet(stmt);
10 
11   // 获取MappedStatement.resultMaps集合
12   List<ResultMap> resultMaps = mappedStatement.getResultMaps();
13   int resultMapCount = resultMaps.size();
14 
15   // 遍历resultMaps集合
16   while (rsw != null && resultMapCount > resultSetCount) {
17     // 获取该结果集对应的ResultMap对象
18     ResultMap resultMap = resultMaps.get(resultSetCount);
19     // 根据ResultMap中定义的映射规则对ResultSet进行映射，并将映射的结果对象添加到multipleResult集合中保存
20     handleResultSet(rsw, resultMap, multipleResults, null);
21     // 获取下一个结果集
22     rsw = getNextResultSet(stmt);
23     // 清空nestedResultObjects集合
24     cleanUpAfterHandlingResultSet();
25     // 递增resultSetCount
26     resultSetCount++;
27   }
28   // ...
29 
30   return collapseSingleResultList(multipleResults);
31 }

1、创建ResultSetWrapper对象封装ResultSet

　　ResultSetWrapper持有ResultSet，类型处理器注册器，包含表字段、表字段类型及表字段对应的Java类型，ResultSetWrapper详情如下：

2、获取MappedStatement.resultMaps集合

　　MappedStatement.resultMaps是在解析Mapper.xml的select|insert|update|delete标签，创建MappedStatement.Builder对象时，完成的初始化操作。

　　初始化resultMaps的链路：XMLMapperBuilder#configurationElement() -> XMLMapperBuilder#buildStatementFromContext() -> XMLStatementBuilder#parseStatementNode() -> MapperBuilderAssistant#addMappedStatement()

　　resultMaps持有结果映射的类型type，statementId -> 目标执行方法全限定名，resultMaps示例详情：

3、结果集映射成结果对象集合

　　遍历resultMaps集合，逐个处理resultMap，DefaultResultSetHandler#handleResultSet() 核心伪代码：

 1 private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
 2   try {
 3       // ...
 4       // 用户未指定处理映射结果对象的ResultHandler对象，则使用DefaultResultHandler作为默认的ResultHandler对象
 5       if (resultHandler == null) {
 6         // 默认的结果处理器
 7         DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
 8         // 对ResultSet进行映射，并将映射得到的结果对象添加到DefaultResultHandler对象中暂存
 9         handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
10         // 将DefaultResultHandler中保存的结果对象添加到multipleResults集合中
11         multipleResults.add(defaultResultHandler.getResultList());
12         
13       // 使用用户指定的ResultHandler对象处理结果对象
14       } else {
15         handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
16       }
17     }
18   } finally {
19     // 调用ResultSet.close方法关闭结果集
20     closeResultSet(rsw.getResultSet());
21   }
22 }

　　ResultSet结果集的处理，可以自定义resultHandler结果集处理器；若未指定resultHandler，使用默认的结果集处理器DefaultResultHandler。默认结果集处理器DefaultResultHandler通过ObjectFactory对象实例化List属性，DefaultResultHandler详情：

　　对结果集进行映射，会将映射的对象设置在defaultResultHandler对象的List属性中。

handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);

1、创建结果映射对象并完成对象属性填充，将填充完成的对象存储在DefaultResultSetHandler的List属性中

　　最终会执行到 DefaultResultSetHandler的handleRowValuesForSimpleResultMap()方法

 1 private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
 2     throws SQLException {
 3   // 默认上下文对象
 4   DefaultResultContext<Object> resultContext = new DefaultResultContext<>();
 5   ResultSet resultSet = rsw.getResultSet();
 6   // 根据RowBounds中的offset定位到指定的记录
 7   skipRows(resultSet, rowBounds);
 8   // 检测已经处理的行数是否已经达到上限（RowBounds,limit）以及ResultSet中是否还有可处理的记录
 9   while (shouldProcessMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next()) {
10     // 根据该行记录以及ResultMap.discriminator，决定映射使用的ResultMap
11     ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(resultSet, resultMap, null);
12     // 根据最终确定的ResultMap对ResultSet中的该行记录进行映射，得到映射后的结果对象
13     Object rowValue = getRowValue(rsw, discriminatedResultMap, null);
14     // 将映射创建的结果对象添加到ResultHandler.resultList中保存
15     storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);
16   }
17 }

　　将结果集映射成结果对象 DefaultResultSetHandler#getRowValue() 核心代码：

 1 private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, String columnPrefix) throws SQLException {
 2   // 实例化ResultLoaderMap(延迟加载器)
 3   final ResultLoaderMap lazyLoader = new ResultLoaderMap();
 4   // 创建该行记录映射之后得到的结果对象，该结果对象的类型由ResultMap节点的type属性指定
 5   Object rowValue = createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
 6   if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
 7     // 创建上述结果对象相应的MetaObject对象
 8     final MetaObject metaObject = configuration.newMetaObject(rowValue);
 9     // 成功映射任意属性，则foundValues为true,否则foundValues为false
10     boolean foundValues = this.useConstructorMappings;
11     // 检测是否需要进行自动映射
12     if (shouldApplyAutomaticMappings(resultMap, false)) {
13       // 自动映射ResultMap中未明确指定的列
14       foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
15     }
16     // 映射ResultMap中明确指定需要映射的列
17     foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
18     foundValues = lazyLoader.size() > 0 || foundValues;
19     // 如果没有成功映射任何属性，则根据mybatis-config.xml中的returnInstanceForEmptyRow配置决定返回空的结果对象还是返回null
20     rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
21   }
22   return rowValue;
23 }

1、实例化空的映射结果对象

　　createResultObject() 根据resultMap中的type实例化对象，rowValue详情如下

2、映射结果属性填充

　　DefaultResultSetHandler#applyAutomaticMappings() 核心代码

 1 // 自动映射
 2 private boolean applyAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, String columnPrefix) throws SQLException {
 3   // 获取ResultSet中存在，但ResultMap中没有明确映射的列所对应的UnMappedColumnAutoMapping集合，如果ResultMap中设置的resultType为HashMap的话，则全部的列都会在这里获取到
 4   List<UnMappedColumnAutoMapping> autoMapping = createAutomaticMappings(rsw, resultMap, metaObject, columnPrefix);
 5   boolean foundValues = false;
 6   if (!autoMapping.isEmpty()) {
 7     // 遍历autoMapping集合
 8     for (UnMappedColumnAutoMapping mapping : autoMapping) {
 9       // 使用TypeHandler获取自动映射的列值
10       final Object value = mapping.typeHandler.getResult(rsw.getResultSet(), mapping.column);
11       if (value != null) {
12         foundValues = true;
13       }
14       if (value != null || (configuration.isCallSettersOnNulls() && !mapping.primitive)) {
15         // 将自动映射的属性值设置到结果对象中
16         metaObject.setValue(mapping.property, value);
17       }
18     }
19   }
20   return foundValues;
21 }

　　获取autoMapping，即获取数据字段与Java实体对象的映射关系及类型处理器，autoMapping详情如下：

　　遍历autoMapping集合，通过类型处理器获取自动映射的列值，根据映射结果对象的元数据对象metaObject，完成对象属性的设置，本质上是通过反射完成赋值操作的。

3、映射结果对象信息存储

　　映射结果对象信息最后会添加进DefaultResultHandler的List属性中进行存储，遍历下一个ResultSet结果集继续上述流程处理。

　　DefaultResultSetHandler#storeObject() 核心伪代码

1 private void storeObject(ResultHandler<?> resultHandler, DefaultResultContext<Object> resultContext, Object rowValue, ResultMapping parentMapping, ResultSet rs) throws SQLException {
2     // 普通映射，将结果对象保存到ResultHandler中
3     callResultHandler(resultHandler, resultContext, rowValue);
4 }

　　DefaultResultSetHandler#callResultHandler() 核心伪代码：

1 private void callResultHandler(ResultHandler<?> resultHandler, DefaultResultContext<Object> resultContext, Object rowValue) {
2   //将结果对象保存到 DefaultResultContext.resultObject字段中
3   resultContext.nextResultObject(rowValue);
4   // 将结果对象添加到ResultHandler.resultList中保存
5   ((ResultHandler<Object>) resultHandler).handleResult(resultContext);
6 }

　　DefaultResultHandler#handleResult() 核心代码：

public void handleResult(ResultContext<? extends Object> context) {
  list.add(context.getResultObject());
}

2、将暂存在DefaultResultSetHandler#List中映射结果对象集合赋值给multipleResults集合

3、关闭ResultSet

3.4、返回映射对象结果集合

3.5、关闭Statement

　　至此，完成了SQL查询的分析。

posted @ 2023-03-21 17:42 无虑的小猪阅读(232) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Mybatis源码(七)：SQL执行流程

· Mybtais源码(九)：增删改执行流程

· MyBatis 架构与原理深入解析，面试随便问！

· 面试官：你能简单聊聊MyBatis执行流程

· 详细讲解 mybatis 的执行流程

阅读排行：
· 分享4款.NET开源、免费、实用的商城系统
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
· 上周热点回顾（2.24-3.2）

公告

昵称：无虑的小猪
园龄： 5年9个月
粉丝： 18
关注： 1

+加关注

2025年3月

日

一

二

三

四

五

六

无虑的小猪