Mybatis底层实现原理

红太狼 2022-01-14 14:17 470阅读 0赞

## Mybatis底层原理 ##

终于发现，原来Mybatis的底层原理是涉及到动态代理的，想想我们是如何使用Mybatis的？有一个接口类，有一个xml类型的Mapper，将xml类型的Mapper与接口类对应起来，就可以调用接口的方法，来实现xml类型Mapper中的SQL语句了。

可是接口的方法怎么可以被调用呢？之前我一直百思不得其姐，看了这篇博客，算是弄明白了——原来正是用了动态代理。

我们知道代理模式就是在原有的功能上，又增添或者增强了一些功能。这里，就是将接口类中的方法增强了，或者说，将接口实例化了。

总的来说，分为几个大块：

1.  解析Mapper（configuration）
2.  动态代理（MapperProxyFactory）
3.  封装JDBC（SqlSession）

先来看看Mapper是如何解析的吧

## 一、解析Mapper ##

**Configuration**：MyBatis所有的配置信息都保存在Configuration对象之中，配置文件中的大部分配置都会存储到该类中。

**MapperRegistry**：这个里面会存MapperProxyFactory，也就是Mapper接口的动态代理工厂。

看如下源码：

public void parse() { 
        // 若当前Mapper.xml尚未加载，则加载
        if (!configuration.isResourceLoaded(resource)) {  
          // 解析<mapper>节点
          configurationElement(parser.evalNode("/mapper"));
          // 将当前Mapper.xml标注为『已加载』（下回就不用再加载了）
          configuration.addLoadedResource(resource);
          // 【关键】将Mapper Class添加至Configuration中
          bindMapperForNamespace(); //绑定namespace
        }
    
        parsePendingResultMaps();
        parsePendingCacheRefs();
        parsePendingStatements();
      }

这个函数主要做了两件事：

1.  解析节点，并将解析结果注册进**configuration**中；
2.  将当前映射文件所对应的DAO接口的Class对象注册进configuration中  
    这一步极为关键！是为了给DAO接口创建代理对象，下文会详细介绍。（因为代理也是通过反射来完成的，需要class的名字）

下面再进入bindMapperForNamespace()函数，看一看它做了什么：

private void bindMapperForNamespace() { 
        // 获取当前映射文件对应的DAO接口的全限定名
        String namespace = builderAssistant.getCurrentNamespace();
        if (namespace != null) { 
          // 将全限定名解析成Class对象
          Class<?> boundType = null;
          try { 
            boundType = Resources.classForName(namespace);
          } catch (ClassNotFoundException e) { 
          }
          if (boundType != null) { 
            if (!configuration.hasMapper(boundType)) { 
              // 将当前Mapper.xml标注为『已加载』（下回就不用再加载了）
              configuration.addLoadedResource("namespace:" + namespace);
              // 将DAO接口的Class对象注册进configuration中
              configuration.addMapper(boundType);
            }
          }
        }
      }

这个函数主要做了两件事：

1.  将节点上定义的namespace属性（即：当前映射文件所对应的DAO接口的权限定名）解析成Class对象
2.  将该**Class对象存储**在**configuration对**象里的属性**MapperRegistry**中，

## 二、动态代理 ##

**MapperRegistry**：有且仅有两个属性：Configuration（和上面的那个不一样）和**knownMappers**。

**knownMappers**的类型为**Map<Class<?>, MapperProxyFactory<?>>**，它是一个Map，**key为dao接口的class对象**，而**value为该Mapper接口代理对象的工厂**。那么这个代理对象工厂是什么，又怎么产生的呢？  
下面我们就来看一下MapperProxyFactory这个类究竟有些啥：

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

这个类有三个重要成员：

1.  mapperInterface属性：这个属性就是DAO接口的Class对象，当创建MapperProxyFactory对象的时候需要传入
2.  methodCache属性：这个属性用于存储当前DAO接口中所有的方法。
3.  newInstance函数：这个函数用于创建DAO接口的代理对象，它需要传入一个MapperProxy对象作为参数。而MapperProxy类实现了InvocationHandler接口，由此可知它是动态代理中的处理类，所有对目标函数的调用请求都会先被这个处理类截获，所以可以在这个处理类中添加目标函数调用前、调用后的逻辑。

然后通过**MapperRegistry**的**addMapper()函数**，来将代理工厂一一加入MapperRegistry中，等待调用。

public <T> void addMapper(Class<T> type) { 
        if (type.isInterface()) { 
          if (hasMapper(type)) { 
            throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
          }
          boolean loadCompleted = false;
          try { 
            // 创建MapperProxyFactory对象，并put进knownMappers中
            knownMappers.put(type, new MapperProxyFactory<T>(type));
            MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
            parser.parse();
            loadCompleted = true;
          } finally { 
            if (!loadCompleted) { 
              knownMappers.remove(type);
            }
          }
        }
      }

当MyBatis初始化完毕后，configuration对象中存储了所有Mapper接口的Class对象和相应的MapperProxyFactory对象（用于创建Mapper接口的代理对象）。接下来，就到了使用Mapper接口中函数的阶段了。

SqlSession sqlSession = sqlSessionFactory.openSession();
    try { 
        ProductMapper productMapper = sqlSession.getMapper(ProductMapper.class);
        List<Product> productList = productMapper.selectProductList();
        for (Product product : productList) { 
            System.out.printf(product.toString());
        }
    } finally { 
        sqlSession.close();
    }

它根据上游传递进来Mapper接口的Class对象，从configuration中取出了该Mapper接口对应的代理对象生成工厂：MapperProxyFactory。

## 三、JDBC ##

Mybatis操作数据的底层还是JDBC，包括连接数据库、执行语句等等。

*  **SqlSession**：作为MyBatis工作的主要顶层API，表示和数据库交互时的会话，完成必要数据库增删改查功能。
 *  **Executor**：MyBatis执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓存的维护
 *  **StatementHandler**：封装了JDBC Statement操作，负责对JDBC statement 的操作，如设置参数等
 *  **ParameterHandler** ：负责对用户传递的参数转换成JDBC Statement 所对应的数据类型
 *  **ResultSetHandler** ：负责将JDBC返回的ResultSet结果集对象转换成List类型的集合
 *  **TypeHandler**：负责java数据类型和jdbc数据类型(也可以说是数据表列类型)之间的映射和转换
 *  **MappedStatement** ：MappedStatement维护一条<select|update|delete|insert>节点的封装
 *  **SqlSource**：负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回
 *  **BoundSql**：表示动态生成的SQL语句以及相应的参数信息  
    首先会通过 SessionFactory 去获取 SqlSession

## Mybatis缓存 ##

MyBatis提供查询缓存，用于减轻数据库压力，提高性能。MyBatis提供了一级缓存和二级缓存。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc1MTcxMA_size_16_color_FFFFFF_t_70]  
一级缓存是SqlSession级别的缓存，每个SqlSession对象都有一个哈希表用于缓存数据，不同SqlSession对象之间缓存不共享。同一个SqlSession对象对象执行2遍相同的SQL查询，在第一次查询执行完毕后将结果缓存起来，这样第二遍查询就不用向数据库查询了，直接返回缓存结果即可。MyBatis默认是开启一级缓存的。

二级缓存是mapper级别的缓存，二级缓存是跨SqlSession的，多个SqlSession对象可以共享同一个二级缓存。不同的SqlSession对象执行两次相同的SQL语句，第一次会将查询结果进行缓存，第二次查询直接返回二级缓存中的结果即可。MyBatis默认是不开启二级缓存的，可以在配置文件中使用如下配置来开启二级缓存：

当SQL语句进行更新操作(删除/添加/更新)时，会清空对应的缓存，保证缓存中存储的都是最新的数据。MyBatis的二级缓存对细粒度的数据级别的缓存实现不友好，比如如下需求：对商品信息进行缓存，由于商品信息查询访问量大，但是要求用户每次都能查询最新的商品信息，此时如果使用mybatis的二级缓存就无法实现当一个商品变化时只刷新该商品的缓存信息而不刷新其它商品的信息，因为mybaits的二级缓存区域以mapper为单位划分，当一个商品信息变化会将所有商品信息的缓存数据全部清空。解决此类问题需要在业务层根据需求对数据有针对性缓存，具体业务具体实现。

解析过程：  
https://www.cnblogs.com/qingchen521/p/10327440.html  
动态代理：  
https://blog.csdn.net/w372426096/article/details/82622418  
缓存：  
https://www.cnblogs.com/luoxn28/p/6417892.html  
SQLSession是啥  
https://www.cnblogs.com/minixiong/p/10135257.html

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzc1MTcxMA_size_16_color_FFFFFF_t_70]: /images/20220114/70c8eebe771e4cf49f36829876c72d01.png