• MyBatis——源码解析MyBatis框架底层的执行原理

    文章目录：

    1.前言

    2.案例项目源码

    3.MyBatis源码解析底层执行原理

    3.1 读取mybatis配置文件创建出SqlSeesionFactory对象

    3.2 通过SqlSeesionFactory对象进而创建出SqlSession对象

    3.3 通过SqlSession的getMapper获取到接口代理对象

    3.4 通过mapper接口的代理对象执行CRUD

    1.前言

    MyBatis框架大家肯定都用过的，废话我就不再多说了，这篇文章就给大家分享一下有关MyBatis框架底层的执行原理吧（Debug！！！）

    2.案例项目源码

    我这里写了一个简单的MyBatis相关的maven项目，把源码分享给大家，一会的debug就以这个项目的测试代码为主。

    首先给出pom依赖。

    1. <dependencies>
    2.     <dependency>
    3.       <groupId>org.mybatis</groupId>
    4.       <artifactId>mybatis</artifactId>
    5.       <version>3.5.1</version>
    6.     </dependency>
    7.  
    8.     <dependency>
    9.       <groupId>mysql</groupId>
    10.       <artifactId>mysql-connector-java</artifactId>
    11.       <version>5.1.9</version>
    12.     </dependency>
    13.  
    14.     <dependency>
    15.       <groupId>org.projectlombok</groupId>
    16.       <artifactId>lombok</artifactId>
    17.       <version>1.18.20</version>
    18.     </dependency>
    19.  
    20.     <dependency>
    21.       <groupId>junit</groupId>
    22.       <artifactId>junit</artifactId>
    23.       <version>4.11</version>
    24.       <scope>test</scope>
    25.     </dependency>
    26.   </dependencies>
    27.  
    28.   <build>
    29.     <!--资源插件：处理src/main/java目录中的xml-->
    30.     <resources>
    31.       <resource>
    32.         <directory>src/main/java</directory><!--所在的目录-->
    33.         <includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
    34.           <include>**/*.properties</include>
    35.           <include>**/*.xml</include>
    36.         </includes>
    37.         <filtering>false</filtering>
    38.       </resource>
    39.     </resources>
    40.   </build>

    下面是实体类，以及数据库中表结构信息。

    1. package com.szh.entity;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import lombok.NoArgsConstructor;
    6.  
    7. /**
    8.  *
    9.  */
    10. @Data
    11. @NoArgsConstructor
    12. @AllArgsConstructor
    13. public class Student {
    14.     private Integer id;
    15.     private String name;
    16.     private Integer age;
    17.     private String email;
    18. }

    然后是对应的mapper接口和xml映射文件。

    1. package com.szh.dao;
    2.  
    3. import com.szh.entity.Student;
    4.  
    5. import java.util.List;
    6.  
    7. /**
    8.  *
    9.  */
    10. public interface StudentDao {
    11.  
    12.     List<Student> selectAll();
    13.  
    14. }
    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <!DOCTYPE mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    5. <mapper namespace="com.szh.dao.StudentDao">
    6.  
    7.     <sql id="column">
    8.         id, name, age, email
    9.     </sql>
    10.  
    11.     <select id="selectAll" resultType="com.szh.entity.Student">
    12.         select <include refid="column"></include>
    13.         from student
    14.     </select>
    15.  
    16. </mapper>

    接下来是数据库配置文件和mybatis核心配置文件。

    1. jdbc.driver=com.mysql.jdbc.Driver
    2. jdbc.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&amp;characterEncoding=utf-8
    3. jdbc.username=root
    4. jdbc.password=12345678
    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <!DOCTYPE configuration
    3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
    5. <configuration>
    6.     <properties resource="jdbc.properties" />
    7.  
    8.     <!--设置日志-->
    9.     <settings>
    10.         <setting name="logImpl" value="STDOUT_LOGGING"/>
    11.     </settings>
    12.  
    13.     <environments default="development">
    14.         <environment id="development">
    15.             <transactionManager type="JDBC"/>
    16.             <!--配置数据源：创建Connection对象-->
    17.             <dataSource type="POOLED">
    18.                 <!-- driver：驱动内容 -->
    19.                 <property name="driver" value="${jdbc.driver}"/>
    20.                 <!-- 连接数据库的url -->
    21.                 <property name="url" value="${jdbc.url}"/>
    22.                 <!-- 用户名 -->
    23.                 <property name="username" value="${jdbc.username}"/>
    24.                 <!-- 密码 -->
    25.                 <property name="password" value="${jdbc.password}"/>
    26.             </dataSource>
    27.         </environment>
    28.     </environments>
    29.  
    30.     <mappers>
    31.         <mapper class="com.szh.dao.StudentDao"/>
    32. <!--        <package name="com.szh.dao"/>-->
    33.     </mappers>
    34. </configuration>

    最后给出获取mybatis中核心对象（SqlSeesion、SqlSeesionFactory这些对象）的工具类、以及测试代码。

    1. package com.szh.utils;
    2.  
    3. import org.apache.ibatis.io.Resources;
    4. import org.apache.ibatis.session.SqlSession;
    5. import org.apache.ibatis.session.SqlSessionFactory;
    6. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    7.  
    8. import java.io.IOException;
    9. import java.io.InputStream;
    10.  
    11. /**
    12.  *  工具类：创建SqlSession对象
    13.  */
    14. public class MyBatisUtil {
    15.  
    16.     private static SqlSessionFactory factory = null;
    17.  
    18.     static {
    19.         String config = "mybatis.xml";
    20.         try {
    21.             InputStream inputStream = Resources.getResourceAsStream(config);
    22.             factory = new SqlSessionFactoryBuilder().build(inputStream);
    23.         } catch (IOException e) {
    24.             e.printStackTrace();
    25.         }
    26.     }
    27.  
    28.     public static SqlSession getSqlSession() {
    29.         SqlSession session = null;
    30.         if (factory != null) {
    31.             session = factory.openSession();
    32.         }
    33.         return session;
    34.     }
    35. }
    1. package com.szh;
    2.  
    3. import com.szh.dao.StudentDao;
    4. import com.szh.entity.Student;
    5. import com.szh.utils.MyBatisUtil;
    6. import org.apache.ibatis.session.SqlSession;
    7. import org.junit.Test;
    8.  
    9. import java.util.List;
    10.  
    11. /**
    12.  *
    13.  */
    14. public class MyTest {
    15.  
    16.     @Test
    17.     public void testSelectStudents() {
    18.         SqlSession session = MyBatisUtil.getSqlSession();
    19.         StudentDao studentDao = session.getMapper(StudentDao.class);
    20.         //com.sun.proxy.$Proxy == StudentDaoImpl
    21.         System.out.println("studentDao === " + studentDao.getClass().getName());
    22.         List<Student> studentList = studentDao.selectAll();
    23.         studentList.forEach(stu-> System.out.println("stu = " + stu));
    24.         session.close();
    25.     }
    26.  
    27. }

    下面我们测试一下，确保项目可以正常运行，然后再进行debug。

    3.MyBatis源码解析底层执行原理

    3.1 读取mybatis配置文件创建出SqlSeesionFactory对象

    由于我们这里要摸清MyBatis框架到底是如何执行的？如何创建SqlSeesionFactory、SqlSession这些对象的？怎样解析配置文件的？

    所以debug的源头就从下面这张图开始。

    然后我们按F7跟进去，这里需要按两次，因为有两个方法需要确定跟哪个？我们进到build方法中。 

    上图也就是跟进去的build方法，可以看到这个inputStream中读取的就是我们当前项目的 mybatis 核心配置文件了。

    接下来再次F7跟进这个build方法中。

    此时在下图可以看到，有一个XMLConfigBuilder这个类，从名字上大致可以猜到它就是来解析我们的 mybatis 核心配置文件（mybatis.xml）。

    在 parseConfiguration 这个方法中，我们可以通过 Evaluate 计算一下这个root 的值是什么。 

    1. <configuration>
    2. 	<properties resource="jdbc.properties"/>
    3. 	
    4. 	<settings>
    5. 		<setting name="logImpl" value="STDOUT_LOGGING"/>
    6. 	</settings>
    7. 	
    8. 	<environments default="development">
    9. 		<environment id="development">
    10. 		<transactionManager type="JDBC"/>
    11. 		<dataSource type="POOLED">
    12. 			<property name="driver" value="${jdbc.driver}"/>
    13. 			<property name="url" value="${jdbc.url}"/>
    14. 			<property name="username" value="${jdbc.username}"/>
    15. 			<property name="password" value="${jdbc.password}"/>
    16. 		</dataSource>
    17. 		</environment>
    18. 	</environments>
    19. 	
    20. 	<mappers>
    21. 		<mapper class="com.szh.dao.StudentDao"/>
    22. 	</mappers>
    23. </configuration>

    👆👆👆  我们就看到了熟悉的内容了，properties标签、settings、mappers这些，这不就是我们mybatis核心配置文件中的内容吗？

    所以下面我们就详细看下 parseConfiguration 方法中如何进行这些标签解析的。（由于这里的标签很多，而我在配置文件中只定义了图中打断点的这几个，所以就依次来看这几个吧，其他的都是大同小异了）

    先来看第一个 properties。

    跟进去之后，我们可以通过 Evaluate 计算一下这个context 的值是什么。

    <properties resource="jdbc.properties"/>

    显然这里的context != null，走进这个if判断中，然后它会从 properties 标签中依次获取相关属性值（resource、url），那么我的配置文件中使用的是resource。

    所以会走到下面那个if中。 

    按照上面的依次跟进源码，就可以看到，这里它调了defaults.putAll就是将resource对应的属性值（db.properties）中的内容放到了这个map集合中。也就是上图的内容。 

    将db.properties中的四项内容（driver、url、root、password）存入map之后，它将这个map集合（defaults）set到了configuration对象中（这个对象很重要！！！），后面我们会经常看到它，这里有个印象。

    到此，我们配置文件中的 properties 属性就被读取解析完了。

    按照上面那张图，下面要读取解析的就是 environments 了。（仍然F7跟进去）

    跟进去之后，会看到传入的参数是context，通过 Evaluate 计算得到，这个context不是别的，就是核心配置文件中environments标签的所有内容。 

    1. <environments default="development">
    2. 	<environment id="development">
    3. 		<transactionManager type="JDBC"/>
    4. 		<dataSource type="POOLED">
    5. 			<property name="driver" value="com.mysql.jdbc.Driver"/>
    6. 			<property name="url" value="jdbc:mysql://localhost:3306/ssm?useUnicode=true&amp;characterEncoding=utf-8"/>
    7. 			<property name="username" value="root"/>
    8. 			<property name="password" value="12345678"/>
    9. 		</dataSource>
    10. 	</environment>
    11. </environments>

    上面的源码首先去获取了 environments 标签中的 default 属性值，在配置文件中我写的就是 development。

    for循环第一次，会先读取  environments 标签中的第一个 environment 标签的id值，然后通过 isSpecifiedEnvironment 方法去判断此id是否和 environments 标签中我们刚刚通过 default 获取的那个值一致，如果一致，就可以确定当前走的是哪一套 sql 数据源的配置。

    那么这里肯定是 equals 为 true的，因为我只写了一个 environment 标签，如果有多个，for循环会依次遍历直到找到与 default 属性值匹配的id。

    当default与id匹配成功之后，就会走进当前的environment标签中，而我的配置文件在这个标签中首先定义了事务

    <transactionManager type="JDBC"/>

    所以下面也会走事务的相关源码，可以看到这里正常的获取到事务中的type属性值是JDBC，最后会去创建JDBC相关的事务工厂类。

    有关事务的配置走完之后，下面就走到了重要的 dataSource 了。

    1. <!--配置数据源：创建Connection对象-->
    2.             <dataSource type="POOLED">
    3.                 <!-- driver：驱动内容 -->
    4.                 <property name="driver" value="${jdbc.driver}"/>
    5.                 <!-- 连接数据库的url -->
    6.                 <property name="url" value="${jdbc.url}"/>
    7.                 <!-- 用户名 -->
    8.                 <property name="username" value="${jdbc.username}"/>
    9.                 <!-- 密码 -->
    10.                 <property name="password" value="${jdbc.password}"/>
    11.             </dataSource>

    跟着下面截图来看。

    跟进去之后，我们首先通过 Evaluate 计算一下 context 的值。 这不就是我们的数据源信息吗？所以它这里其实也是先获取相关的type属性值POOLED，然后再读取这些数据源信息存入Properties这个map集合中，最后返回当前的数据源工厂类对象。

    1. <dataSource type="POOLED">
    2.     <property name="driver" value="com.mysql.jdbc.Driver"/>
    3.     <property name="url" value="jdbc:mysql://localhost:3306/ssm?useUnicode=true&amp;characterEncoding=utf-8"/>
    4.     <property name="username" value="root"/>
    5.     <property name="password" value="12345678"/>
    6. </dataSource>

    最后它这里是通过建造者模式将刚刚的事务、数据源这些信息设置到了当前的Environment对象中，然后又调用了 configuration 对象，将environment对象set到其中，这是我们又一次见到了 configuration 对象。

    到此，我们配置文件中的 environments 属性就被读取解析完了。

    按照上面那张图，下面要读取解析的就是 mappers 了。（仍然F7跟进去）

    跟进来之后，我们首先通过 Evaluate 计算一下传入参数parent的值是什么。 

    1. <mappers>
    2. 	<mapper class="com.szh.dao.StudentDao"/>
    3. </mappers>

    好的，通过结果大家肯定心里就有数了，此时我们读取解析的就是核心配置文件中 mappers 的相关内容。

    因为mappers标签中可以定义多个mapper标签、或者是 package标签，所以这里必然要通过 for 循环依次获取 mappers 标签中的所有子标签。

    走进for循环之后，我们仔细看源码就会发现，这些if、else是很有趣的，它们之后存在着一种优先级。也就是说如果我们在myabtis核心配置文件中的mappers标签中声明了package、通过mapper标签定义 resource、url、class这些属性的时候，它会先读取加载谁呢？下面的源码告诉你答案。 

    我们并未定义 package所以不会走第一个if，而是走到else，而我们在子标签mapper中也没有定义resource、url，所以会走到第三个 else if 中。

    在这，我们又看到了 configuration 对象，调用了 addMapper 将我们这个mapper接口注册到了其中。 

    然后依次按F8单步执行就行，走到下面这张图。之后F7跟进这个build方法中，在这个方法中可以看到传入的参数就是刚刚我们一再强调的那个 configuration 对象，然后通过 new DefaultSqlSessionFactory 的构造器传入这个configuration 对象，成功创建出 SqlSeesionFactory 对象。

    3.2 通过SqlSeesionFactory对象进而创建出SqlSession对象

    跟进去之后就可以看到，这里仍然是用了上面提到的那个 configuration 对象获取相关 environment 配置信息、事务信息。

    最后是 new DefaultSqlSession 通过 environment 配置信息、事务信息以及设置自动提交为false创建出 SqlSession 对象。 

    依次F8单步执行，回到最初打断点的地方，执行一步，可以看到当前SqlSession对象中存在了两个重要的对象：

    1. configuration：读取解析配置文件中相关的environment、mappers等各种信息。
    2. executor：执行器，负责执行处理mapper中的各种sql语句。

    3.3 通过SqlSession的getMapper获取到接口代理对象

    所以这一系列的源码追踪到此，可以看到MyBatis的底层就是通过JDK动态代理创建出了mapper接口的代理对象。 

    3.4 通过mapper接口的代理对象执行CRUD

    在下图的断点中，直接F7跟进去。会跳转到下面第二张图中。 

    这里大家自己F8单步执行，就能看到try中的if、else if中的内容都没有执行，而是直接来到了下面的final、return这里。为什么会这样，简单解释一下：

    这个 MapperMethod 是执行代理增强功能的类，而当前我们位于 MapperProxy 这个类中，它实现了 InvocationHandler 这个接口，而该接口中（也就是上图中）的invoke方法就是代理增强功能代码所写的位置了。

    而第一个if是说，如果传进来的是Object对象，则直接执行本对象自己的方法，并非执行mapper对象的接口中的方法。就例如Object中原始的toString、hashCode方法一样。所以这个if不会走。

    而这个else if 说的是判断此方法是否是接口中的默认方法（JDK1.8之后接口中可以定义 default XXX修饰的默认方法），那么断点走到这里的method显然就是selectAll方法，所以这个else if不会走。

    那么在上图中，自然就走到了最后的 final、return这里，F7跟进这个execute方法中。此时就走进了 MapperMethod 这个类中。

    首先看一下这个类中有两个成员变量。解释如下：👇👇👇

    在上图中F8单步执行，就会走到 case SELECT 这里。这里我们对 command 这个成员变量进行计算，就可以看到它的 name和type 到底是什么了。

    它的name正是我上面给大家的项目源码中StudentDao.xml中的那个selectAll，而type就对应着标签具体是CRUD的哪一个。

    它这里还会通过method成员变量（对应mapper接口中的方法），获取到此方法的返回值是List、还是void决定走哪个判断语句。

    F8单步执行一步，然后F7进入下面这个 executeForMany 方法中。因为先前已经在switch-case中获取到mapper接口中的selectAll的返回值是List，所以这里就使用sqlSession对象调用了selectList方法来查询。

    我们F7跟进这个selectList方法中看看。

     

    上图中有多个mappedStatement是因为我后来又在接口中添了几个方法，大家只关注我上面给出的selectAll就行了。

    跟进来之后，就可以看到这里是通过configuration对象获取到其中的mappedStatement来创建出MappedStatement对象，这个东西是什么呢？其实就是Executor执行器真正要执行的那些sql语句（xml中的那些sql标签）。

    可以理解为 mapper接口中有多少个方法，configuration对象中的 mappedStatement 就有多少组。因为底层都通过反射机制完成了mapper接口方法和xml映射文件标签的绑定！！！

    走到最后，我们Evaluate计算出result的内容，这不就是我们数据库中的所有student信息吗？（大家对照我上面给出的源码即可）。 

    最终程序的运行结果：👇👇👇 和上面的result是一样一样的。😄😄😄

  • 相关阅读:
    设计模式 18 中介者模式
    3.6 C++高级编程_异常
    pdf转jpg的方法【ps和工具方法】
    百度文库最新AI旋转验证码识别
    160. 相交链表
    医院敏感文件交互 如何保障安全和效率？
    SpringMVC之全局异常管理
    10 个杀手级的 Python 自动化脚本
    建筑能源管理（3）——建筑能源监管
    java.util.HashMap cannot be cast to com.XXX.XXX
  • 原文地址：https://blog.csdn.net/weixin_43823808/article/details/125345541