深入浅出MyBatis：MyBatis解析和运行原理

快来打我* 2022-02-19 14:40 278阅读 0赞

# Mybatis工作原理 #

![70][]

# 工作原理解析 #

**mybatis应用程序通过SqlSessionFactoryBuilder从mybatis-config.xml配置文件（也可以用Java文件配置的方式，需要添加@Configuration）中构建出SqlSessionFactory（SqlSessionFactory是线程安全的）；**

**然后，SqlSessionFactory的实例直接开启一个SqlSession，再通过SqlSession实例获得Mapper对象并运行Mapper映射的SQL语句，完成对数据库的CRUD和事务提交，之后关闭SqlSession。**

说明：SqlSession是单线程对象，因为它是非线程安全的，是持久化操作的独享对象，类似jdbc中的Connection，底层就封装了jdbc连接。

**详细流程如下：**  
1、加载mybatis全局配置文件（数据源、mapper映射文件等），解析配置文件，MyBatis基于XML配置文件生成Configuration，和一个个MappedStatement（包括了参数映射配置、动态SQL语句、结果映射配置），其对应着<select | update | delete | insert>标签项。  
2、SqlSessionFactoryBuilder通过Configuration对象生成SqlSessionFactory，用来开启SqlSession。  
3、SqlSession对象完成和数据库的交互：  
a、用户程序调用mybatis接口层api（即Mapper接口中的方法）  
b、SqlSession通过调用api的Statement ID找到对应的MappedStatement对象  
c、通过Executor（负责动态SQL的生成和查询缓存的维护）将MappedStatement对象进行解析，sql参数转化、动态sql拼接，生成jdbc Statement对象  
d、JDBC执行sql。  
e、借助MappedStatement中的结果映射关系，将返回结果转化成HashMap、JavaBean等存储结构并返回。  
**mybatis层次图：**

![70 1][]

本篇会介绍MyBatis解析和运行原理，下一篇介绍插件及应用，目的是更好地编写插件，通过本篇的介绍，你会了解到：

*  构建SqlSessionFactory过程
 *  映射器的动态代理
 *  SqlSession的4大对象
 *  sql执行的过程

SqlSessionFactory和SqlSession是MyBatis的核心组件，在文章 [JDBC和MyBatis介绍][JDBC_MyBatis] 中有详细说明。

构建SqlSessionFactory过程

构建主要分为2步：

*  通过XMLConfigBuilder解析配置的XML文件，读出配置参数，包括基础配置XML文件和映射器XML文件；
 *  使用Configuration对象创建SqlSessionFactory，SqlSessionFactory是一个接口，提供了一个默认的实现类DefaultSqlSessionFactory。

说白了，就是将我们的所有配置解析为Configuration对象，在整个生命周期内，可以通过该对象获取需要的配置。

由于插件需要频繁访问映射器的内部组成，会重点这部分，了解这块配置抽象出来的对象：

MappedStatement

它保存映射器的一个节点（select|insert|delete|update），包括配置的SQL，SQL的id、缓存信息、resultMap、parameterType、resultType等重要配置内容。

它涉及的对象比较多，一般不去修改它。

SqlSource

它是MappedStatement的一个属性，主要作用是根据参数和其他规则组装SQL，也是很复杂的，一般也不用修改它。

BoundSql

对于参数和SQL，主要反映在BoundSql类对象上，在插件中，通过它获取到当前运行的SQL和参数以及参数规则，作出适当的修改，满足特殊的要求。

BoundSql提供3个主要的属性：parameterObject、parameterMappings和sql，下面分别来介绍。

parameterObject为参数本身，可以传递简单对象、POJO、Map或@Param注解的参数：

*  传递简单对象(int、float、String等)，会把参数转换为对应的类，比如int会转换为Integer；
 *  如果传递的是POJO或Map，paramterObject就是传入的POJO或Map不变；
 *  如果传递多个参数，没有@Param注解，parameterObject就是一个Map<String,Object>对象，类似这样的形式\{"1":p1 , "2":p2 , "3":p3 ... "param1":p1 , "param2":p2 , "param3",p3 ...\}，所以在编写的时候可以使用\#\{param1\}或\#\{1\}去引用第一个参数；
 *  如果传递多个参数，有@Param注解，与没有注解的类似，只是将序号的key替换为@Param指定的name；

parameterMappings，它是一个List，元素是ParameterMapping对象，这个对象会描绘sql中的参数引用，包括名称、表达式、javaType、jdbcType、typeHandler等信息。

sql，是写在映射器里面的一条sql。

有了Configuration对象，构建SqlSessionFactory就简单了：

sqlSessionFactory = new SqlSessionFactoryBuilder().bulid(inputStream);

## SqlSession运行过程 ##

### 映射器的动态代理 ###

Mapper映射是通过动态代理来实现的，使用JDK动态代理返回一个代理对象，供调用者访问。

首先看看实现InvocationHandler接口的类，它是执行本代理方法的关键，可以看到，Mapper是一个接口，会生成MapperMethod对象，调用execute方法。

public class MapperProxy<T> implements InvocationHandler, Serializable {
      
      .....
      
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
          if (Object.class.equals(method.getDeclaringClass())) {
            return method.invoke(this, args);
          } else if (isDefaultMethod(method)) {
            return invokeDefaultMethod(proxy, method, args);
          }
        } catch (Throwable t) {
          throw ExceptionUtil.unwrapThrowable(t);
        }
        final MapperMethod mapperMethod = cachedMapperMethod(method);
        return mapperMethod.execute(sqlSession, args);
      }
    }

看下面的代码，MapperMethod采用命令模式，根据不同的sql操作，做不同的处理。

public class MapperMethod {
      public Object execute(SqlSession sqlSession, Object[] args) {
        Object result;
        switch (command.getType()) {
          case INSERT: {
          Object param = method.convertArgsToSqlCommandParam(args);
            result = rowCountResult(sqlSession.insert(command.getName(), param));
            break;
          }
          case UPDATE: {
            Object param = method.convertArgsToSqlCommandParam(args);
            result = rowCountResult(sqlSession.update(command.getName(), param));
            break;
            
            ......
            
          }
        }
      }

最后看下，生成代理类的方法，就是使用JDK动态代理Proxy来创建的。

public class MapperProxyFactory<T> {
    
      public T newInstance(SqlSession sqlSession) {
        final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
        return newInstance(mapperProxy);
      }
    
      @SuppressWarnings("unchecked")
      protected T newInstance(MapperProxy<T> mapperProxy) {
        return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
      }
    
    }

总结下映射器的调用过程，返回的Mapper对象是代理对象，当调用它的某个方法时，其实是调用MapperProxy\#invoke方法，而映射器的XML文件的命名空间对应的就是这个接口的全路径，会根据全路径和方法名，便能够绑定起来，定位到sql，最后会使用SqlSession接口的方法使它能够执行查询。

### SqlSession下的四大对象 ###

通过上面的分析，映射器就是一个动态代理对象，进入到了MapperMethod的execute方法，它经过简单的判断就进入了SqlSession的删除、更新、插入、选择等方法，这些方法如何执行是下面要介绍的内容。

Mapper执行的过程是通过Executor、StatementHandler、ParameterHandler和ResultHandler来完成数据库操作和结果返回的，理解他们是编写插件的关键：

*  Executor：执行器，由它统一调度其他三个对象来执行对应的SQL；
 *  StatementHandler：使用数据库的Statement执行操作；
 *  ParameterHandler：用于SQL对参数的处理；
 *  ResultHandler：进行最后数据集的封装返回处理；

在MyBatis中存在三种执行器：

*  SIMPLE：简易执行器，默认的执行器；
 *  REUSE：执行重用预处理语句；
 *  BATCH:执行重用语句和批量更新，针对批量专用的执行器；

以SimpleExecutor为例，说明执行过程

public class SimpleExecutor extends BaseExecutor {
    
      /**
      * 执行查询操作
      */
      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(this, ms, parameter, rowBounds, resultHandler, boundSql);
          stmt = prepareStatement(handler, ms.getStatementLog());
          return handler.<E>query(stmt, resultHandler);
        } finally {
          closeStatement(stmt);
        }
      }
      
      /**
      * 初始化StatementHandler
      */
      private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
        Statement stmt;
        Connection connection = getConnection(statementLog);
        stmt = handler.prepare(connection);
        handler.parameterize(stmt);
        return stmt;
      }
      
      /**
      * 执行查询
      */
      @Override
      public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
        String sql = boundSql.getSql();
        statement.execute(sql);
        return resultSetHandler.<E>handleResultSets(statement);
      }
    }

可以看到最后会委托给StatementHandler会话器进行处理，它是一个接口，实际创建的是RoutingStatementHandler对象，但它不是真实的服务对象，它是通过适配器模式找到对应的StatementHandler执行的。在MyBatis中，StatementHandler和Executor一样分为三种：SimpleStatementHandler、PreparedStatementHandler、CallableStatementHandler。

Executor会先调用StatementHandler的prepare方法预编译SQL语句，同时设置一些基本运行的参数。然后调用parameterize()方法启用ParameterHandler设置参数，完成预编译，跟着执行查询，用ResultHandler封装结果返回给调用者。

文章来源：[https://www.jianshu.com/p/8d1f499063a1][https_www.jianshu.com_p_8d1f499063a1]

[https://blog.csdn.net/u014745069/article/details/80788127][https_blog.csdn.net_u014745069_article_details_80788127]

[70]: /images/20220219/ab108c4317f8434eaf4b4fef3ec6cfd2.png
[70 1]: /images/20220219/99d39bc3489f4cbdbee00b56e9ac1598.png
[JDBC_MyBatis]: https://www.jianshu.com/p/87566bc74e81
[https_www.jianshu.com_p_8d1f499063a1]: https://www.jianshu.com/p/8d1f499063a1
[https_blog.csdn.net_u014745069_article_details_80788127]: https://blog.csdn.net/u014745069/article/details/80788127