四、MyBatis终结篇(补充中...)

Dear 丶 2023-02-22 10:33 1阅读 0赞

# 一、MyBatis核心特性 #

MyBatis核心特性

MyBatis和Hibernate 跟 DbUtils、 Spring JDBC 一样，都是**对 JDBC 的一个封装**，我们去看源码，最后一定会看到 Statement 和 ResultSet 这些对象。

1、 使用连接池对连接进行管理  
2、 SQL 和代码分离，集中管理  
3、 结果集映射  
4、 参数映射和动态 SQL  
5、 重复 SQL 的提取  
6、 缓存管理  
7、 插件机制

这么多的工具和不同的框架，在实际的项目里面应该怎么选择？  
在一些业务比较简单的项目中，我们可以使用 Hibernate；如果需要更加灵活的 SQL，可以使用 MyBatis，对于底层的编码，或者性能要求非常高的场合，可以用 JDBC。  
实际上在我们的项目中，MyBatis 和 Spring JDBC 是可以混合使用的

# 二、MyBatis架构分层与模块划分 #

![image-20200630151344356][]

## 2.1 接口层 ##

首先接口层是我们打交道最多的。核心对象是 SqlSession，它是上层应用和 MyBatis打交道的桥梁，SqlSession 上定义了非常多的对数据库的操作方法。接口层在接收到调用请求的时候，会调用核心处理层的相应模块来完成具体的数据库操作。

## 2.2 核心处理层 ##

接下来是核心处理层。既然叫核心处理层，也就是跟数据库操作相关的动作都是在这一层完成的。  
核心处理层主要做了这几件事：  
（1）把接口中传入的参数解析并且映射成 JDBC 类型；  
（2）解析 xml 文件中的 SQL 语句，包括插入参数，和动态 SQL 的生成；  
（3）执行 SQL 语句；  
（4）处理结果集，并映射成 Java 对象。  
插件也属于核心层，这是由它的工作方式和拦截的对象决定的。

## 2.3 基础支持层 ##

最后一个就是基础支持层。基础支持层主要是一些抽取出来的通用的功能（实现复用），用来支持核心处理层的功能。比如数据源、缓存、日志、xml 解析、反射、IO、事务等等这些功能。

# 三、MyBatis缓存 #

缓存目的就是提升查询的效率和减少数据库的压力。跟 Hibernate 一样，MyBatis 也有一级缓存和二级缓存，并且预留了集成在第三方缓存的接口（比如缓存在Redis）。

## 3.1 类体系 ##

MyBatis 跟缓存相关的类都在 cache 包里面，其中有一个 Cache 接口，只有一个默认的实现类 PerpetualCache，它是用 HashMap 实现的。

除此之外，还有很多的装饰器，通过这些装饰器可以额外实现很多的功能：回收策略、日志记录、定时刷新等等。

![image-20200630154258951][]

“装饰者模式（Decorator Pattern） 是指在不改变原有对象的基础之上， 将功能附加到对象上， 提供了比继承更有弹  
性的替代方案（扩展原有对象的功能） 。 ” 无论怎么装饰，经过多少层装饰，最后使用的还是基本的实现类（默认PerpetualCache）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1EzODM4NDE4_size_16_color_FFFFFF_t_70_pic_center]

## 3.2 分类 ##

所有的缓存实现类总体上可分为三类：基本缓存、淘汰算法缓存、装饰器缓存

<table> 
 <thead> 
  <tr> 
   <th>缓存实现类</th> 
   <th>描述</th> 
   <th>作用</th> 
   <th>装饰条件</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>基本缓存</td> 
   <td>缓存基本实现类</td> 
   <td>默认是 PerpetualCache， 也可以自定义比如 RedisCache、 EhCache 等， 具备基本功能的缓存类</td> 
   <td>无</td> 
  </tr> 
  <tr> 
   <td>LruCache</td> 
   <td>LRU 策略的缓存</td> 
   <td>当缓存到达上限时候， 删除最近最少使用的缓存 （Least Recently Use）</td> 
   <td>eviction=“LRU”（默 认）</td> 
  </tr> 
  <tr> 
   <td>FifoCache</td> 
   <td>FIFO 策略的缓存</td> 
   <td>当缓存到达上限时候， 删除最先入队的缓存</td> 
   <td>eviction=“FIFO”</td> 
  </tr> 
  <tr> 
   <td>SoftCache WeakCache</td> 
   <td>带清理策略的缓存</td> 
   <td>通过 JVM 的软引用和弱引用来实现缓存， 当 JVM 内存不足时， 会自动清理掉这些缓存， 基于 SoftReference 和 WeakReference</td> 
   <td>eviction=“SOFT” eviction="WEAK</td> 
  </tr> 
 </tbody> 
</table>

## 3.3 一级缓存 ##

### 3.3.1 介绍 ###

一级缓存也叫本地缓存，MyBatis 的一级缓存是在会话（SqlSession）层面进行缓存的。MyBatis 的一级缓存是默认开启的，不需要任何的配置。

### 3.3.2 持有缓存位置 ###

要在同一个会话里面共享一级缓存，这个对象肯定是在 SqlSession 里面创建的，作为 SqlSession 的一个属性 DefaultSqlSession 里面只有两个属性，Configuration 是全局的，所以缓存只可能放在 Executor 里面维护——SimpleExecutor/ReuseExecutor/BatchExecutor 的父类 BaseExecutor 的构造函数中持有了 PerpetualCache。

### 3.3.2 功能 ###

在同一个会话里面，多次执行相同的 SQL 语句，会直接从内存取到缓存的结果，不会再发送 SQL 到数据库。但是不同的会话里面，即使执行的 SQL 一模一样（通过一个Mapper 的同一个方法的相同参数调用），也不能使用到一级缓存。

### 3.3.2 不足 ###

一级缓存不能跨会话共享，不同的会话之间对于相同的数据可能有不一样的缓存。在有多个会话或者分布式环境下，会存在脏数据的问题。如果要解决这个问题，就要用到二级缓存。

## 3.4 二级缓存 ##

### 3.4.1 介绍 ###

二级缓存是用来解决一级缓存不能跨会话共享的问题的，范围是 namespace 级别的，可以被多个 SqlSession 共享（只要是同一个接口里面的相同方法，都可以共享），生命周期和应用同步。

### 3.4.2 时机 ###

作为一个作用范围更广的缓存，工作在一级缓存之前，也就是只有取不到二级缓存的情况下才到一个会话中去取一级缓存

### 3.4.3 功能 ###

要跨会话共享的话，SqlSession 本身和它里面的 BaseExecutor 已经满足不了需求了，实际上 MyBatis 用了一个装饰器的类来维护，就是 CachingExecutor。如果启用了二级缓存，MyBatis 在创建 Executor 对象的时候会对 Executor 进行装饰。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1EzODM4NDE4_size_16_color_FFFFFF_t_70_pic_center 1]

CachingExecutor 对于查询请求，会判断二级缓存是否有缓存结果，如果有就直接返回，如果没有委派交给真正的查询器 Executor 实现类，比如 SimpleExecutor 来执行查询，再走到一级缓存的流程。最后会把结果缓存起来，并且返回给用户

### 3.4.4 使用 ###

第一步：在 mybatis-config.xml 中配置了（可以不配置，默认是 true）：

**只要没有显式地设置 cacheEnabled=false，都会用 CachingExecutor 装饰基本的执行器。**  
第二步：在 Mapper.xml 中配置标签：

<cache type="org.apache.ibatis.cache.impl.PerpetualCache"
        size="1024" 
        eviction="LRU" 
        flushInterval="120000" 
        readOnly="false"/>

### 3.4.5 适用场景 ###

一级缓存默认是打开的，二级缓存需要配置才可以开启。那么我们必须思考一个问题，在什么情况下才有必要去开启二级缓存？  
1、在查询为主的应用中使用，比如历史交易、历史订单的查询。因为所有的增删改都会刷新二级缓存，导致二级缓存失效。否则缓存就失去了意义。  
2、如果多个 namespace 中有针对于同一个表的操作，比如 Blog 表，如果在一个namespace 中刷新了缓存，另一个 namespace 中没有刷新，就会出现读到脏数据的情况。所以，推荐在一个 Mapper 里面只操作单表的情况使用。

## 3.5 用第三方缓存存二级缓存 ##

1.引入pom，maven：mybatis-redis 包

2.Mapper.xml 配置，type 使用 RedisCache：

3.普通Redis地址配置

最后二级缓存存在了Redis里面，具体不多说 比较少见。

# 四、源码：基础案例 #

## 4.2 基本代码（不融入spring） ##

因为 Spring 对 MyBatis 的一些操作进行的封装，我们不能直接看到它的本质，所以先看下不使用容器的时候

//读取配置
            String resource = "mybatis/mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            //创建SqlSession会话工厂
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            //创建会话
            SqlSession session = sqlSessionFactory.openSession();
            //执行SQL
            try {
        
                BookMarkDao mapper = session.getMapper(BookMarkDao.class);
                BookMarkQuery bookMarkQuery = new BookMarkQuery();
                bookMarkQuery.setUserId(new Long("123"));
                List<BookMarkDO> bookMarkList = mapper.find(bookMarkQuery);
                System.out.println(bookMarkList);
            } finally {
        
                session.close();
            }

看到了 MyBatis 里面的几个核心对象：  
SqlSessionFactoryBuiler、 SqlSessionFactory、 SqlSession 和 Mapper 对象。 这几个核心对象在 MyBatis 的整个工作流程里面的不同环节发挥作用。 如果说我们不用容器，自己去管理这些对象的话，我们必须思考一个问题：什么时候创建和销毁这些对象？

从每个对象的作用的角度来理解一下，只有理解了它们是干什么的，才知道什么时候应该创建，什么时候应该销毁

## 4.2 四个核心类作用及生命周期 ##

### 1）SqlSessionFactoryBuiler ###

首先是 SqlSessionFactoryBuiler。它是用来构建 SqlSessionFactory 的， 而  
SqlSessionFactory 只需要一个，所以只要构建了这一个 SqlSessionFactory，它的使命  
就完成了，也就没有存在的意义了。所以它的生命周期只存在于方法的局部。

### 2）SqlSessionFactory ###

SqlSessionFactory 是用来创建 SqlSession 的，每次应用程序访问数据库，都需要  
创建一个会话。 因为我们一直有创建会话的需要，所以 SqlSessionFactory 应该存在于  
应用的整个生命周期中（作用域是应用作用域）。创建 SqlSession 只需要一个实例来做  
这件事就行了，否则会产生很多的混乱，和浪费资源。所以我们要采用单例模式。

### 3）SqlSession ###

SqlSession 是一个会话，因为它不是线程安全的，不能在线程间共享。 所以我们在  
请求开始的时候创建一个 SqlSession 对象，在请求结束或者说方法执行完毕的时候要及  
时关闭它（一次请求或者操作中）。

### 4）Mapper ###

Mapper（实际上是一个代理对象）是从 SqlSession 中获取的。

BookMarkDao mapper = session.getMapper(BookMarkDao.class);

它的作用是发送 SQL 来操作数据库的数据。它应该在一个 SqlSession 事务方法之  
内。

### 5) 总结 ###

<table> 
 <thead> 
  <tr> 
   <th>对象</th> 
   <th>生命周期</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>SqlSessionFactoryBuiler</td> 
   <td>方法局部（method）</td> 
  </tr> 
  <tr> 
   <td>SqlSessionFactory（单例）</td> 
   <td>应用级别（application）</td> 
  </tr> 
  <tr> 
   <td>SqlSession</td> 
   <td>请求和操作（request/method）</td> 
  </tr> 
  <tr> 
   <td>Mapper</td> 
   <td>方法（method）</td> 
  </tr> 
 </tbody> 
</table>

# 五、传统Mybatis核心步骤与疑问 #

第一步，我们通过建造者模式创建一个工厂类，配置文件的解析就是在这一步完成的，包括 mybatis-config.xml 和Mapper 适配器文件。

问题：解析的时候怎么解析的，做了什么，产生了什么对象，结果存放到了哪里。解析的结果决定着我们后面有什么对象可以使用，和到哪里去取。

第二步，通过 SqlSessionFactory 创建一个 SqlSession。  
问题：SqlSession 是用来操作数据库的，返回了什么实现类，除了 SqlSession，还创建了什么对象，创建了什么环境？

第三步，获得一个 Mapper 对象。

问题：Mapper 是一个接口，没有实现类，是不能被实例化的，那获取到的这个Mapper 对象是什么对象？为什么要从 SqlSession 里面去获取？为什么传进去一个接口，然后还要用接口类型来接收？

第四步，调用接口方法。

问题：我们的接口没有创建实现类，为什么可以调用它的方法？那它调用的是什么方法？它又是根据什么找到我们要执行的 SQL 的？也就是接口方法怎么和 XML 映射器里面的 StatementID 关联起来的？此外，我们的方法参数是怎么转换成 SQL 参数的？获取到的结果集是怎么转换成对象的？

# 六、逐步分析 #

待分析的基础代码：

InputStream inputStream = Resources.getResourceAsStream(resource);
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession session = sqlSessionFactory.openSession();
    BlogMapper mapper = session.getMapper(BlogMapper.class);
    Blog blog = mapper.selectBlogById(1);

## 6.1 解析配置创建SqlSessionFactory ##

核心代码：

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

new 了一个 SqlSessionFactoryBuilder，非常明显的建造者模式，它里面定义了很多个 build 方法的重载，最终返回的是一个 SqlSessionFactory 对象（单例模式）。可以点进去 build 方法：

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
        
        try {
        
          XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
          return build(parser.parse());
        } catch (Exception e) {
        
          //。。。。	
        } finally {
        
    	  //。。。。	
    }
    
    public SqlSessionFactory build(Configuration config) {
        
        return new DefaultSqlSessionFactory(config);
    }

核心两句话：

1.创建XMLConfigBuilder，调用parse进行解析

2.运用解析出来的Configuration，创建DefaultSqlSessionFactory

### 6.1.1 XMLConfigBuilder ###

XMLConfigBuilder 是抽象类 BaseBuilder 的一个子类，专门用来解析全局配置文件，针对不同的构建目标还有其他的一些子类，比如：

XMLMapperBuilder：解析 Mapper 映射器  
XMLStatementBuilder：解析增删改查标签

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1EzODM4NDE4_size_16_color_FFFFFF_t_70_pic_center 2]

调用 XMLConfigBuilder的 parse()方法，它会返回一个 Configuration ，配置文件里面所有的信息都会放在 Configuration 里面 。查看parse方法：

public Configuration parse() {
        
        if (parsed) {
        
          throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        }
        parsed = true;
        parseConfiguration(parser.evalNode("/configuration"));
        return configuration;
      }
    
      private void parseConfiguration(XNode root) {
        
        try {
        
          //分步骤解析
          //issue #117 read properties first
          //1.properties
          propertiesElement(root.evalNode("properties"));
          //2.类型别名
          typeAliasesElement(root.evalNode("typeAliases"));
          //3.插件
          pluginElement(root.evalNode("plugins"));
          //4.对象工厂
          objectFactoryElement(root.evalNode("objectFactory"));
          //5.对象包装工厂
          objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
          //6.设置
          settingsElement(root.evalNode("settings"));
          // read it after objectFactory and objectWrapperFactory issue #631
          //7.环境
          environmentsElement(root.evalNode("environments"));
          //8.databaseIdProvider
          databaseIdProviderElement(root.evalNode("databaseIdProvider"));
          //9.类型处理器
          typeHandlerElement(root.evalNode("typeHandlers"));
          //10.映射器
          mapperElement(root.evalNode("mappers"));
        } catch (Exception e) {
        
          throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
        }
      }

依次解析这里面的节点：configuration以及下属properties、settings、typeAliases等等，全部设置到内部属性Configuration里，也说明了写mybatis配置文件的顺序不能错。

其中这些标签配置里看下重点的mappers是怎么被解析的，我们的SQL、mapper是怎么解析的。（其它都是配置加载各种分支非重点）

### 6.1.2 mappers标签解析 ###

主要是在上面代码：

XMLConfigBuilder\#parse==>parseConfiguration==>mapperElement(root.evalNode(“mappers”));里

private void mapperElement(XNode parent) throws Exception {
        
        if (parent != null) {
        
          for (XNode child : parent.getChildren()) {
        
            if ("package".equals(child.getName())) {
        
              String mapperPackage = child.getStringAttribute("name");
              configuration.addMappers(mapperPackage);
            } else {
        
              String resource = child.getStringAttribute("resource");
              String url = child.getStringAttribute("url");
              String mapperClass = child.getStringAttribute("class");
              if (resource != null && url == null && mapperClass == null) {
        
                ErrorContext.instance().resource(resource);
                InputStream inputStream = Resources.getResourceAsStream(resource);
                XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
                mapperParser.parse();
              } else if (resource == null && url != null && mapperClass == null) {
        
                ErrorContext.instance().resource(url);
                InputStream inputStream = Resources.getUrlAsStream(url);
                XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
                mapperParser.parse();
              } else if (resource == null && url == null && mapperClass != null) {
        
                Class<?> mapperInterface = Resources.classForName(mapperClass);
                configuration.addMapper(mapperInterface);
              } else {
        
                throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
              }
            }
          }
        }
      }

标签的解析 ，里面有四类：

<table> 
 <thead> 
  <tr> 
   <th>扫描类型</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>resource</td> 
   <td>相对路径</td> 
  </tr> 
  <tr> 
   <td>url</td> 
   <td>绝对路径</td> 
  </tr> 
  <tr> 
   <td>package</td> 
   <td>包</td> 
  </tr> 
  <tr> 
   <td>class</td> 
   <td>单个接口</td> 
  </tr> 
 </tbody> 
</table>

其中主要是两个，addMapper解析接口，XMLMapperBuilder 解析XML

#### addMapper ####

无论是按 package 扫描，还是按接口扫描，最后都会调用到 MapperRegistry 的addMapper()方法。  
MapperRegistry 里面维护的其实是一个 Map 容器，存储接口和代理工厂的映射关系。

在 addMapper()方法跟进去 里面创建了一个 MapperAnnotationBuilder，又一个parse方法，都是对注解的解析，比如@Options（设置自增key），@SelectKey（返回自增key），@ResultMap 等等

最后同样会解析成 MappedStatement 对象，也就是说在 XML 中配置，和使用注解配置，最后起到一样的效果

#### XMLMapperBuilder ####

XML，具体是XMLMapperBuilder.parse()方法，源码：

public void parse() {
        
        if (!configuration.isResourceLoaded(resource)) {
        
          configurationElement(parser.evalNode("/mapper"));
          configuration.addLoadedResource(resource);
          bindMapperForNamespace();
        }
    
        parsePendingResultMaps();
        parsePendingCacheRefs();
        parsePendingStatements();
      }

主要有两个方法：  
1.configurationElement()—— 解 析 所 有 的 子 标 签 ， 其 中buildStatementFromContext()最终获得 MappedStatement 对象。  
2.bindMapperForNamespace()——把 namespace（接口类型）和工厂类绑定起来

### 6.1.3 小结 ###

完成了 config 配置文件、Mapper 文件、Mapper 接口上的注解的解析 得到了一个最重要的对象Configuration，这里面存放了全部的配置信息，它在属性里面还有各种各样的容器。  
最后，返回了一个 DefaultSqlSessionFactory，里面持有了 Configuration 的实例。

## 6.2 会话创建过程openSession ##

第二步，跟数据库的每一次连接，都需要创建一个会话，用openSession()方法来创建。

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
        
        Transaction tx = null;
        try {
        
          final Environment environment = configuration.getEnvironment();
          final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
          tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
          final Executor executor = configuration.newExecutor(tx, execType);
          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();
        }
      }

DefaultSqlSessionFactory —— openSessionFromDataSource()这个会话里面，需要包含一个 Executor 用来执行 SQL。

Executor 又要指定事务类型和执行器的类型。所以我们会先从 Configuration 里面拿到 Enviroment，Enviroment 里面就有事务工厂。

### 6.2.1 创建 Transaction ###

如果配置的是 JDBC，则会使用 Connection 对象的 commit()、rollback()、close()管理事务。  
如果配置成 MANAGED，会把事务交给容器来管理，比如 JBOSS，Weblogic。（这里翻过车，SpringBoot+Resin不去配的话没得事物了，事物失效，Tomcat可以）

因为我们跑的是本地main程序，如果配置成 MANAGE 不会有任何事务。  
如 果 是 Spring + MyBatis ， 则 没 有 必 要 配 置 ， 因 为 我 们 会 直 接 在applicationContext.xml 里面配置数据源和事务管理器，覆盖 MyBatis 的配置。

### 6.2.2 Executor类型 ###

Executor 的基本类型有三种：SIMPLE、BATCH、REUSE，默认是 SIMPLE（settingsElement()读取默认值），他们都继承了抽象类 BaseExecutor。

为什么要让抽象类实现接口，然后让具体实现类继承抽象类？（模板方法模式）

定义一个算法的骨架， 并允许子类为一个或者多个步骤提供实现。模板方法使得子类可以在不改变算法结构的情况下， 重新定义算法的某些步骤。 ”

三种类型的区别（通过 update()方法对比）？

SimpleExecutor：每执行一次 update 或 select，就开启一个 Statement 对象，用完立刻关闭 Statement 对象。  
ReuseExecutor：执行 update 或 select，以 sql 作为 key 查找 Statement 对象，存在就使用，不存在就创建，用完后，不关闭 Statement 对象，而是放置于 Map 内，供下一次使用。简言之，就是重复使用 Statement 对象。  
BatchExecutor：执行 update（没有 select，JDBC 批处理不支持 select），将所有 sql 都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个 Statement 对象，每个 Statement 对象都是 addBatch()完毕后，等待逐一执行executeBatch()批处理。与 JDBC 批处理相同。

如果配置了 cacheEnabled=ture，会用装饰器模式对 executor 进行包装：new  
CachingExecutor(executor)。

### 6.2.3 小结 ###

创建会话的过程，我们获得了一个 DefaultSqlSession，里面包含了一个Executor，它是 SQL 的执行者。

## 6.3 获取Mapper对象 ##

在解析 mapper 标签和 Mapper.xml 的时候已经把接口类型和类型对应的 MapperProxyFactory 放到了一个 Map 中。获取 Mapper 代理对象，实际上是从Map 中获取对应的工厂类后，调用MapperProxyFactory.newInstance() 方法创建对象

即JDK 动态代理：

return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[]{
         mapperInterface }, mapperProxy);

普通JDK 动态代理代理，在实现了 InvocationHandler 的代理类里面，需要传入一个被代理对象的实现类

mybatis不需要实现类的原因：我们只需要根据接口类型+方法的名称，就可以找到Statement ID 了，而唯一要做的一件事情也是这件，所以不需要实现类

## 6.5 执行SQL ##

获得 Mapper 对象的过程，实质上是获取了一个 MapperProxy 的代理对象。MapperProxy 中有 sqlSession、mapperInterface、methodCache。

由于所有的 Mapper 都是 MapperProxy 代理对象，所以任意的方法都是执行MapperProxy 的 invoke()方法，debug进mapper（代理对象）的执行方法。

### 6.5.1 MapperProxy.invoke() ###

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);
        }
        //先从缓存里拿MapperMethod
        final MapperMethod mapperMethod = cachedMapperMethod(method);
        return mapperMethod.execute(sqlSession, args);
      }
      private MapperMethod cachedMapperMethod(Method method) {
        
        return methodCache.computeIfAbsent(method, k -> new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
      }

这里可以看出Mapper方法的抽象是MapperMethod，先从methodCache缓存Map中取，没有则new一个。

然后执行MapperMethod的execute

### 6.5.2 mapperMethod.execute ###

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;
        }
        case DELETE: {
        
          Object param = method.convertArgsToSqlCommandParam(args);
          result = rowCountResult(sqlSession.delete(command.getName(), param));
          break;
        }
        case SELECT:
          if (method.returnsVoid() && method.hasResultHandler()) {
        
            executeWithResultHandler(sqlSession, args);
            result = null;
          } else if (method.returnsMany()) {
        
            result = executeForMany(sqlSession, args);
          } else if (method.returnsMap()) {
        
            result = executeForMap(sqlSession, args);
          } else if (method.returnsCursor()) {
        
            result = executeForCursor(sqlSession, args);
          } else {
        
            Object param = method.convertArgsToSqlCommandParam(args);
            result = sqlSession.selectOne(command.getName(), param);
            if (method.returnsOptional()
                && (result == null || !method.getReturnType().equals(result.getClass()))) {
        
              result = Optional.ofNullable(result);
            }
          }
          break;
        case FLUSH:
          result = sqlSession.flushStatements();
          break;
        default:
          //...
      }
      if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
        
        throw new BindingException("...");
      }
      return result;
    }

分类INSERT、UPDATE、DELETE、SELECT执行，以查询方法为例跟进，进select的executeForMany里

private <E> Object executeForMany(SqlSession sqlSession, Object[] args) {
        
        List<E> result;
        Object param = method.convertArgsToSqlCommandParam(args);
        if (method.hasRowBounds()) {
        
          RowBounds rowBounds = method.extractRowBounds(args);
          result = sqlSession.selectList(command.getName(), param, rowBounds);
        } else {
        
          result = sqlSession.selectList(command.getName(), param);
        }
        // issue #510 Collections & arrays support
        if (!method.getReturnType().isAssignableFrom(result.getClass())) {
        
          if (method.getReturnType().isArray()) {
        
            return convertToArray(result);
          } else {
        
            return convertToDeclaredCollection(sqlSession.getConfiguration(), result);
          }
        }
        return result;
      }

最终还是交给sqlSession，它的selectList去查询

### 6.5.3 DefaultSqlSession.selectList() ###

selectOne()最终也是调用了 selectList()

public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
        
        try {
        
          MappedStatement ms = configuration.getMappedStatement(statement);
          return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
        } catch (Exception e) {
        
          throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
        } finally {
        
          ErrorContext.instance().reset();
        }
      }

在 SelectList()中，我们先根据 command name（Statement ID）从 Configuration中拿到 MappedStatement，这个 ms 上面有我们在 xml 中配置的所有属性，包括 id、statementType、sqlSource、useCache、入参、出参等等。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1EzODM4NDE4_size_16_color_FFFFFF_t_70_pic_center 3]

然后执行了 Executor 的 query()方法。 Executor 有三种基本类型，SIMPLE/REUSE/BATCH，还有一种包装类型，CachingExecutor。

如果启用了二级缓存，就会先调用 CachingExecutor 的 query()方法，里面有缓存相关的操作，然后才是再调用基本类型的执行器，比如默认的 SimpleExecutor。

此处惊奇的发现网上大量文章说要主动去开启二级缓存是错的！跟进源码Configuration属性boolean cacheEnabled = true;默认true，发现二级缓存默认开启，通过官方文档也证实了：  
![在这里插入图片描述][20200703151805359.png_pic_center]

执行executor.query实际上是CachingExecutor的query，公司Springboot项目也是

### 6.5.4 CachingExecutor\#query ###

public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
        
        BoundSql boundSql = ms.getBoundSql(parameterObject);
        CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
        return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
      }

根据MappedStatement、参数、limit、sql创建缓存的key。

public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
          throws SQLException {
        
        Cache cache = ms.getCache();
        if (cache != null) {
        
          flushCacheIfRequired(ms);
          if (ms.isUseCache() && resultHandler == null) {
        
            ensureNoOutParams(ms, boundSql);
            @SuppressWarnings("unchecked")
            List<E> list = (List<E>) tcm.getObject(cache, key);
            if (list == null) {
        
              list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
              tcm.putObject(cache, key, list); // issue #578 and #116
            }
            return list;
          }
        }
        return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
      }

先从缓存取否则，执行delegate.query，这里就交给父类BaseExecutor执行query了

### 6.5.5 BaseExecutor.query() ###

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 {
        
            list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
          }
        } finally {
        
          queryStack--;
        }
        if (queryStack == 0) {
        
          for (DeferredLoad deferredLoad : deferredLoads) {
        
            deferredLoad.load();
          }
          // issue #601
          deferredLoads.clear();
          if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        
            // issue #482
            clearLocalCache();
          }
        }
        return list;
      }

1）是否清空本地缓存

queryStack 用于记录查询栈，防止递归查询重复处理缓存。flushCache=true 的时候，会先清理本地缓存（一级缓存）：clearLocalCache();

2）从一级缓存取  
利用CacheKey。这个 CacheKey 就是缓存的 Key，localCache.getObject(key)，从一级缓存取。如果没有缓存，会从数据库查询：queryFromDatabase()

3）从数据库查询  
a)缓存  
先在缓存localCache用个占位符占好。等之后执行查询后，移除占位符，放入数据。  
b)查询  
执行 Executor 的 doQuery()；默认是 SimpleExecutor 的doQuery

### 6.5.6SimpleExecutor.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();
          StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
          stmt = prepareStatement(handler, ms.getStatementLog());
          return handler.query(stmt, resultHandler);
        } finally {
        
          closeStatement(stmt);
        }
      }

#### （1） 创建 StatementHandler ####

这里会根据 MappedStatement 里面的 statementType 决定创建StatementHandler 的 类 型 。 默 认 是 PREPARED 。

1、STATEMENT:直接操作sql，不进行预编译，获取数据：$—Statement  
2、PREPARED:预处理，参数，进行预编译，获取数据：\#—–PreparedStatement:默认  
3、CALLABLE:执行存储过程————CallableStatement

<update id="update5" statementType="PREPARED">
        update tb_car set xh=#{xh} where id=#{id}
    </update>

StatementHandler 里面包含了处理参数的 ParameterHandler 和处理结果集的ResultSetHandler。

这两个对象都是在上面 new 的时候创建的 。这三个对象都是可以被插件拦截的四大对象（还有个Executor），所以在创建之后都要用拦截器进行包装的方法。

#### （2）预编译Statement，处理参数 ####

用 new 出来的 StatementHandler 创建 Statement 对象——prepareStatement()方法对语句进行预编译，处理参数。

#### （3）执行 StatementHandler 的 query()方法 ####

RoutingStatementHandler 的 query()方法。delegate 委派，最终由PreparedStatementHandler（上面statementType 决定的） 的 query()方法执行。

#### （4）PreparedStatement 的 execute() ####

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

前两是执行 JDBC 包中的 PreparedStatement ，原生SQL执行

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1EzODM4NDE4_size_16_color_FFFFFF_t_70_pic_center 4]

MyBatis只要是最后的handleResultSets，处理结果；

#### （5）ResultSetHandler 处理结果集 ####

ResultSetHandler 只有一个实现类：DefaultResultSetHandler。实现的步骤就是将Statement执行后的结果集，按照Mapper文件中配置的ResultType或ResultMap来封装成对应的对象，最后将封装的对象返回 。

通过不断while循环调用下一行结果，取匹配Map里的对象映射，对属性赋值

@Override
      public List<Object> handleResultSets(Statement stmt) throws SQLException {
        
        ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
    
        final List<Object> multipleResults = new ArrayList<Object>();
    
        int resultSetCount = 0;
        // 第一个结果集
        ResultSetWrapper rsw = getFirstResultSet(stmt);
        // 获取 resultMap 
        List<ResultMap> resultMaps = mappedStatement.getResultMaps();
        int resultMapCount = resultMaps.size();
        // 判断 ResultMap 是否为空，空则抛异常
        validateResultMapsCount(rsw, resultMapCount);
        // 处理第一个结果集
        while (rsw != null && resultMapCount > resultSetCount) {
        
          ResultMap resultMap = resultMaps.get(resultSetCount);
          // 将结果集映射为对应的 ResultMap 对象
          handleResultSet(rsw, resultMap, multipleResults, null);
          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);
      }

[image-20200630151344356]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9zMS5heDF4LmNvbS8yMDIwLzA2LzMwL05JUHRRcy5wbmc?x-oss-process=image/format,png
[image-20200630154258951]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9zMS5heDF4LmNvbS8yMDIwLzA3LzAzL05YVld6ZC5wbmc?x-oss-process=image/format,png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1EzODM4NDE4_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200703151506118.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1EzODM4NDE4,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1EzODM4NDE4_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200703151529827.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1EzODM4NDE4,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1EzODM4NDE4_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20200703151632470.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1EzODM4NDE4,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1EzODM4NDE4_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20200703151712456.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1EzODM4NDE4,size_16,color_FFFFFF,t_70#pic_center
[20200703151805359.png_pic_center]: https://img-blog.csdnimg.cn/20200703151805359.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1EzODM4NDE4_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20200703150817907.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1EzODM4NDE4,size_16,color_FFFFFF,t_70#pic_center