【MyBatis框架】MyBatis底层原理----一次查询的工作流程

朴灿烈づ我的快乐病毒、 2022-02-02 16:59 298阅读 0赞

最近看了一些Mybatis的底层原理，特此记录总结。  
原文链接：[https://blog.csdn.net/luanlouis/article/details/40422941][https_blog.csdn.net_luanlouis_article_details_40422941]

## MyBatis中相关的类及其职责 ##

<table> 
 <thead> 
  <tr> 
   <th>类名</th> 
   <th>职责</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>SqlSession</td> 
   <td>作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必要数据库增删改查功能</td> 
  </tr> 
  <tr> 
   <td>Executor</td> 
   <td>MyBatis执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓存的 维护</td> 
  </tr> 
  <tr> 
   <td>StatementHandler</td> 
   <td>封装了JDBC Statement操作，负责对JDBC statement 的操作，如设置参数、将Statement结果集转换成List集合</td> 
  </tr> 
  <tr> 
   <td>ParameterHandler</td> 
   <td>负责对用户传递的参数转换成JDBC Statement 所需要的参数</td> 
  </tr> 
  <tr> 
   <td>ResultSetHandler</td> 
   <td>负责将JDBC返回的ResultSet结果集对象转换成List类型的集合</td> 
  </tr> 
  <tr> 
   <td>TypeHandler</td> 
   <td>负责java数据类型和jdbc数据类型之间的映射和转换</td> 
  </tr> 
  <tr> 
   <td>MappedStatement</td> 
   <td>MappedStatement维护了一条&lt;select</td> 
  </tr> 
  <tr> 
   <td>SqlSource</td> 
   <td>负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回</td> 
  </tr> 
  <tr> 
   <td>BoundSql</td> 
   <td>表示动态生成的SQL语句以及相应的参数信息</td> 
  </tr> 
  <tr> 
   <td>Configuration</td> 
   <td>MyBatis所有的配置信息都维持在Configuration对象之中</td> 
  </tr> 
 </tbody> 
</table>

## Mybatis的层次结构 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzk4NjYx_size_16_color_FFFFFF_t_70]  
如果上图看得还是不太清楚的话，我们来详细讲讲SqlSession的工作流程

## SqlSession的工作流程 ##

**1、开启一个数据库访问会话–创建SqlSession对象**

SqlSession sqlSession = SqlSessionFactory.open();

Mybatis封装了对数据库的访问，即封装了JDBC的连接过程，把对数据库的会话和事务控制放到了SqlSession对象中。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzk4NjYx_size_16_color_FFFFFF_t_70 1]  
**2、为SqlSession的selectList方法传递StatementId（即配置在Mapper中Select标签的Id）和参数，并返回结果**

List<Student> result = sqlSession.selectList("com.mybatis.dao.EmployeesMapper.selectById",params);

SelectList方法会根据传入的statementId去Configuration对象中查找相对应的MappedStatement，然后将查询任务委派给Mybatis的执行器,源码如下所示：

public <E> List<E> selectList(String statement, Object parameter) { 
        return this.selectList(statement, parameter, RowBounds.DEFAULT);
      }
     
      public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { 
        try { 
          //1.根据Statement Id，在mybatis 配置对象Configuration中查找和配置文件相对应的MappedStatement 
          MappedStatement ms = configuration.getMappedStatement(statement);
          //2. 将查询任务委托给MyBatis 的执行器 Executor
          List<E> result = executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
          return result;
        } catch (Exception e) { 
          throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
        } finally { 
          ErrorContext.instance().reset();
        }
      }

Mybatis在初始化时，会将配置信息全部加载到内存中，并且通过org.apache.ibatis.session.Configuration实例来维护，使用者可以使用sqlSession.getConfiguration()方法来获取。MyBatis的配置文件中配置信息的组织格式和内存中对象的组织格式几乎完全对应的。  
而Mapper中的一个一个的Sql语句模块，如下：

<select id="selectAll" resultType="com.pojo.student">
        select * from student
    </select>

这种sql语句片段会在Mybatis初始化时被加载成一个MappedStatement对象，然后以键值对的形式存入Configuration对象中去，其中key为namespace+id，value为mappedStatement对象。

由以上分析我们可以看出，**SqlSession的职能是根据statementId从Configuration中获取相对应的MappedStatement对象，然后将MappedStatement对象，参数等信息传给Mybatis的Executor执行器，委派Executor去执行查询。**

## Executor的工作流程 ##

SqlSession对象会把相应的配置信息传递给Executor执行器，由执行器来执行查询并返回结果。下面我们边看源码边分析：

> **1、SqlSession对象将MappedStatement对象和参数信息传递给Executor执行器的query方法去执行，它会根据传递过来的参数完成解析动态sql语句，并且生成一个BoundSql对象，供给StatementHandler使用。**  
> **2、然后Executor会生成一个缓存用的key，调用重载的query方法。**

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException { 
    	  
    	// 1.根据具体传入的参数，动态地生成需要执行的SQL语句，用BoundSql对象表示 
        BoundSql boundSql = ms.getBoundSql(parameter);
        // 2.为当前的查询创建一个缓存Key
        CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
        return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
     }

> **3、query方法会去根据缓存key查看缓存中有没有本次查询的结果，如果有，返回;如果没有，将MappedStatement，参数，resultHandler，key，boundsql等信息传递给queryFormDatabase方法。**

@SuppressWarnings("unchecked")
      public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { 
        ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
        if (closed) throw new ExecutorException("Executor was closed.");
        if (queryStack == 0 && ms.isFlushCacheRequired()) { 
          clearLocalCache();
        }
        List<E> list;
        try { 
          queryStack++;
          list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
          if (list != null) { 
            handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
          } else { 
        	// 3.缓存中没有值，直接从数据库中读取数据 
            list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
          }
        } finally { 
          queryStack--;
        }
        if (queryStack == 0) { 
          for (DeferredLoad deferredLoad : deferredLoads) { 
            deferredLoad.load();
          }
          deferredLoads.clear(); // issue #601
          if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) { 
            clearLocalCache(); // issue #482
          }
        }
        return list;
      }

> **4、queryFormDatabase方法会将参数传递给doQuery方法执行查询，并将执行结果放入缓存之中。**

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 { 
        	
          //4. 执行查询，返回List 结果，然后将查询的结果放入缓存之中
          list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
        } finally { 
          localCache.removeObject(key);
        }
        localCache.putObject(key, list);
        if (ms.getStatementType() == StatementType.CALLABLE) { 
          localOutputParameterCache.putObject(key, parameter);
        }
        return list;
      }

> **5、doQuery方法根据参数创建出StatementHandler对象来执行查询，并且创建java.lang.Statement对象，传递给StatementHandler对象使用，然后调用StatementHandler对象的query方法得到查询结果返回。**

/** * *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();
          //5. 根据既有的参数，创建StatementHandler对象来执行查询操作
          StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
          //6. 创建java.Sql.Statement对象，传递给StatementHandler对象
          stmt = prepareStatement(handler, ms.getStatementLog());
          //7. 调用StatementHandler.query()方法，返回List结果集
          return handler.<E>query(stmt, resultHandler);
        } finally { 
          closeStatement(stmt);
        }
      }

至此，Executor的工作流程执行完毕。  
总的来说，**Executor的作用**有以下几点：

1.  根据传递的参数，解析出动态sql语句，并生成一个BoundSql对象，供StatementHandler使用
2.  为查询建立缓存，提高查询效率
3.  创建JDBC的Statement连接对象，传递给StatementHandler，完成查询并返回结果

## StatementHandler的作用及工作流程 ##

由上面我们知道，Executor最终会创建出StatementHandler对象来进行JDBC操作。  
Executor工作流程的第⑤步中，doQuery方法会调用preparedStatement来创建一个java.lang.Statement对象，那么这个方法是如何执行的呢？来看下源码：

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException { 
        Statement stmt;
        Connection connection = getConnection(statementLog);
        stmt = handler.prepare(connection);
        //对创建的Statement对象设置参数，即设置SQL 语句中 ? 设置为指定的参数
        handler.parameterize(stmt);
        return stmt;
      }

以上我们可以总结StatementHandler对象主要完成两个工作：

1.  通过parameterize方法对Statement对象进行设值。
2.  通过query方法完成执行statement，并且将statement执行返回的resultset封装为List返回。

**StatementHandler 的parameterize(statement) 方法的实现：**

/** * StatementHandler 类的parameterize(statement) 方法实现 */
    public void parameterize(Statement statement) throws SQLException { 
    	//使用ParameterHandler对象来完成对Statement的设值 
        parameterHandler.setParameters((PreparedStatement) statement);
      }
    
      /** * *ParameterHandler类的setParameters(PreparedStatement ps) 实现 * 对某一个Statement进行设置参数 */
      public void setParameters(PreparedStatement ps) throws SQLException { 
        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);
              }
              
              // 每一个Mapping都有一个TypeHandler，根据TypeHandler来对preparedStatement进行设置参数
              TypeHandler typeHandler = parameterMapping.getTypeHandler();
              JdbcType jdbcType = parameterMapping.getJdbcType();
              if (value == null && jdbcType == null) jdbcType = configuration.getJdbcTypeForNull();
              // 设置参数
              typeHandler.setParameter(ps, i + 1, value, jdbcType);
            }
          }
        }
      }

从上述的代码可以看到,StatementHandler 的parameterize(Statement) 方法调用了 ParameterHandler的setParameters(statement) 方法，ParameterHandler的setParameters(Statement)方法负责根据我们输入的参数，对statement对象的 ? 占位符处进行赋值，即使用了typeHandler来完成java对象到jdbc对象的映射

**StatementHandler 的List query(Statement statement, ResultHandler resultHandler)方法的实现：**

/** * PreParedStatement类的query方法实现 */
      public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException { 
    	// 1.调用preparedStatemnt。execute()方法，然后将resultSet交给ResultSetHandler处理 
        PreparedStatement ps = (PreparedStatement) statement;
        ps.execute();
        //2. 使用ResultHandler来处理ResultSet
        return resultSetHandler.<E> handleResultSets(ps);
      }
    
    /** *ResultSetHandler类的handleResultSets()方法实现 * */
    public List<Object> handleResultSets(Statement stmt) throws SQLException { 
        final List<Object> multipleResults = new ArrayList<Object>();
     
        int resultSetCount = 0;
        ResultSetWrapper rsw = getFirstResultSet(stmt);
     
        List<ResultMap> resultMaps = mappedStatement.getResultMaps();
        int resultMapCount = resultMaps.size();
        validateResultMapsCount(rsw, resultMapCount);
        
        while (rsw != null && resultMapCount > resultSetCount) { 
          ResultMap resultMap = resultMaps.get(resultSetCount);
          
          //将resultSet
          handleResultSet(rsw, resultMap, multipleResults, null);
          rsw = getNextResultSet(stmt);
          cleanUpAfterHandlingResultSet();
          resultSetCount++;
        }
     
        String[] resultSets = mappedStatement.getResulSets();
        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);
      }

从上述代码我们可以看出，StatementHandler 的List query(Statement statement, ResultHandler resultHandler)方法的实现，是调用了ResultSetHandler的handleResultSets(Statement) 方法。ResultSetHandler的handleResultSets(Statement) 方法会**将Statement语句执行后生成的resultSet 结果集转换成List 结果集**：

//
      // DefaultResultSetHandler 类的handleResultSets(Statement stmt)实现 
      //HANDLE RESULT SETS
      //
     
      public List<Object> handleResultSets(Statement stmt) throws SQLException { 
        final List<Object> multipleResults = new ArrayList<Object>();
     
        int resultSetCount = 0;
        ResultSetWrapper rsw = getFirstResultSet(stmt);
     
        List<ResultMap> resultMaps = mappedStatement.getResultMaps();
        int resultMapCount = resultMaps.size();
        validateResultMapsCount(rsw, resultMapCount);
        
        while (rsw != null && resultMapCount > resultSetCount) { 
          ResultMap resultMap = resultMaps.get(resultSetCount);
          
          //将resultSet
          handleResultSet(rsw, resultMap, multipleResults, null);
          rsw = getNextResultSet(stmt);
          cleanUpAfterHandlingResultSet();
          resultSetCount++;
        }
     
        String[] resultSets = mappedStatement.getResulSets();
        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);
      }

[https_blog.csdn.net_luanlouis_article_details_40422941]: https://blog.csdn.net/luanlouis/article/details/40422941
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzk4NjYx_size_16_color_FFFFFF_t_70]: /images/20220202/6bc2bd8b2d294778baadc80d29c56d5a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNzk4NjYx_size_16_color_FFFFFF_t_70 1]: /images/20220202/6dd9dc97848d450d9a57791c25aecaab.png