建议收藏,MyBatis插件原理详解

开发 前端
我将以 Executor 为例,分析 MyBatis 是如何为 Executor 实例植入插件的。Executor 实例是在开启 SqlSession 时被创建的,因此,我们从源头进行分析。先来看一下 SqlSession 开启的过程。

 插件原理分析

mybatis插件涉及到的几个类:

我将以 Executor 为例,分析 MyBatis 是如何为 Executor 实例植入插件的。Executor 实例是在开启 SqlSession 时被创建的,因此,我们从源头进行分析。先来看一下 SqlSession 开启的过程。

  1. public SqlSession openSession() { 
  2.     return openSessionFromDataSource(configuration.getDefaultExecutorType(), nullfalse); 
  3.  
  4. private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) { 
  5.     Transaction tx = null
  6.     try { 
  7.         // 省略部分逻辑 
  8.          
  9.         // 创建 Executor 
  10.         final Executor executor = configuration.newExecutor(tx, execType); 
  11.         return new DefaultSqlSession(configuration, executor, autoCommit); 
  12.     }  
  13.     catch (Exception e) {...}  
  14.     finally {...} 

Executor 的创建过程封装在 Configuration 中,我们跟进去看看看。

  1. // Configuration类中 
  2. public Executor newExecutor(Transaction transaction, ExecutorType executorType) { 
  3.     executorType = executorType == null ? defaultExecutorType : executorType; 
  4.     executorType = executorType == null ? ExecutorType.SIMPLE : executorType; 
  5.     Executor executor; 
  6.      
  7.     // 根据 executorType 创建相应的 Executor 实例 
  8.     if (ExecutorType.BATCH == executorType) {...}  
  9.     else if (ExecutorType.REUSE == executorType) {...}  
  10.     else { 
  11.         executor = new SimpleExecutor(this, transaction); 
  12.     } 
  13.     if (cacheEnabled) { 
  14.         executor = new CachingExecutor(executor); 
  15.     } 
  16.      
  17.     // 植入插件 
  18.     executor = (Executor) interceptorChain.pluginAll(executor); 
  19.     return executor; 

如上,newExecutor 方法在创建好 Executor 实例后,紧接着通过拦截器链 interceptorChain 为 Executor 实例植入代理逻辑。那下面我们看一下 InterceptorChain 的代码是怎样的。

  1. public class InterceptorChain { 
  2.     private final List<Interceptor> interceptors = new ArrayList<Interceptor>(); 
  3.     public Object pluginAll(Object target) { 
  4.         // 遍历拦截器集合 
  5.         for (Interceptor interceptor : interceptors) { 
  6.             // 调用拦截器的 plugin 方法植入相应的插件逻辑 
  7.             target = interceptor.plugin(target); 
  8.         } 
  9.         return target; 
  10.     } 
  11.     /** 添加插件实例到 interceptors 集合中 */ 
  12.     public void addInterceptor(Interceptor interceptor) { 
  13.         interceptors.add(interceptor); 
  14.     } 
  15.     /** 获取插件列表 */ 
  16.     public List<Interceptor> getInterceptors() { 
  17.         return Collections.unmodifiableList(interceptors); 
  18.     } 

上面的for循环代表了只要是插件,都会以责任链的方式逐一执行(别指望它能跳过某个节点),所谓插件,其实就类似于拦截器。

这里就用到了责任链设计模式,责任链设计模式就相当于我们在OA系统里发起审批,领导们一层一层进行审批。

以上是 InterceptorChain 的全部代码,比较简单。它的 pluginAll 方法会调用具体插件的 plugin 方法植入相应的插件逻辑。如果有多个插件,则会多次调用 plugin 方法,最终生成一个层层嵌套的代理类。形如下面:

当 Executor 的某个方法被调用的时候,插件逻辑会先行执行。执行顺序由外而内,比如上图的执行顺序为 plugin3 → plugin2 → Plugin1 → Executor。

plugin 方法是由具体的插件类实现,不过该方法代码一般比较固定,所以下面找个示例分析一下。

  1. // TianPlugin类 
  2. public Object plugin(Object target) { 
  3.     return Plugin.wrap(target, this); 
  4.  
  5. //Plugin 
  6. public static Object wrap(Object target, Interceptor interceptor) { 
  7.     /* 
  8.      * 获取插件类 @Signature 注解内容,并生成相应的映射结构。形如下面: 
  9.      * { 
  10.      *     Executor.class : [query, updatecommit], 
  11.      *     ParameterHandler.class : [getParameterObject, setParameters] 
  12.      * } 
  13.      */ 
  14.     Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor); 
  15.     Class<?> type = target.getClass(); 
  16.     // 获取目标类实现的接口 
  17.     Class<?>[] interfaces = getAllInterfaces(type, signatureMap); 
  18.     if (interfaces.length > 0) { 
  19.         // 通过 JDK 动态代理为目标类生成代理类 
  20.         return Proxy.newProxyInstance( 
  21.             type.getClassLoader(), 
  22.             interfaces, 
  23.             new Plugin(target, interceptor, signatureMap)); 
  24.     } 
  25.     return target; 

如上,plugin 方法在内部调用了 Plugin 类的 wrap 方法,用于为目标对象生成代理。Plugin 类实现了 InvocationHandler 接口,因此它可以作为参数传给 Proxy 的 newProxyInstance 方法。

到这里,关于插件植入的逻辑就分析完了。接下来,我们来看看插件逻辑是怎样执行的。

执行插件逻辑

Plugin 实现了 InvocationHandler 接口,因此它的 invoke 方法会拦截所有的方法调用。invoke 方法会对所拦截的方法进行检测,以决定是否执行插件逻辑。该方法的逻辑如下:

  1. //在Plugin类中 
  2. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
  3.     try { 
  4.         /* 
  5.          * 获取被拦截方法列表,比如: 
  6.          *    signatureMap.get(Executor.class),可能返回 [query, updatecommit
  7.          */ 
  8.         Set<Method> methods = signatureMap.get(method.getDeclaringClass()); 
  9.         // 检测方法列表是否包含被拦截的方法 
  10.         if (methods != null && methods.contains(method)) { 
  11.             // 执行插件逻辑 
  12.             return interceptor.intercept(new Invocation(target, method, args)); 
  13.         } 
  14.         // 执行被拦截的方法 
  15.         return method.invoke(target, args); 
  16.     } catch (Exception e) { 
  17.         throw ExceptionUtil.unwrapThrowable(e); 
  18.     } 

invoke 方法的代码比较少,逻辑不难理解。首先,invoke 方法会检测被拦截方法是否配置在插件的 @Signature 注解中,若是,则执行插件逻辑,否则执行被拦截方法。插件逻辑封装在 intercept 中,该方法的参数类型为 Invocation。Invocation 主要用于存储目标类,方法以及方法参数列表。下面简单看一下该类的定义。

  1. public class Invocation { 
  2.  
  3.     private final Object target; 
  4.     private final Method method; 
  5.     private final Object[] args; 
  6.  
  7.     public Invocation(Object target, Method method, Object[] args) { 
  8.         this.target = target; 
  9.         this.method = method; 
  10.         this.args = args; 
  11.     } 
  12.     // 省略部分代码 
  13.     public Object proceed() throws InvocationTargetException, IllegalAccessException { 
  14.         //反射调用被拦截的方法 
  15.         return method.invoke(target, args); 
  16.     } 

关于插件的执行逻辑就分析到这,整个过程不难理解,大家简单看看即可。

自定义插件

下面为了让大家更好的理解Mybatis的插件机制,我们来模拟一个慢sql监控的插件。

 

  1. /** 
  2.  * 慢查询sql 插件 
  3.  */ 
  4. @Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})}) 
  5. public class SlowSqlPlugin implements Interceptor { 
  6.  
  7.     private long slowTime; 
  8.  
  9.     //拦截后需要处理的业务 
  10.     @Override 
  11.     public Object intercept(Invocation invocation) throws Throwable { 
  12.         //通过StatementHandler获取执行的sql 
  13.         StatementHandler statementHandler = (StatementHandler) invocation.getTarget(); 
  14.         BoundSql boundSql = statementHandler.getBoundSql(); 
  15.         String sql = boundSql.getSql(); 
  16.  
  17.         long start = System.currentTimeMillis(); 
  18.         //结束拦截 
  19.         Object proceed = invocation.proceed(); 
  20.         long end = System.currentTimeMillis(); 
  21.         long f = end - start; 
  22.         System.out.println(sql); 
  23.         System.out.println("耗时=" + f); 
  24.         if (f > slowTime) { 
  25.             System.out.println("本次数据库操作是慢查询,sql是:"); 
  26.             System.out.println(sql); 
  27.         } 
  28.         return proceed; 
  29.     } 
  30.  
  31.     //获取到拦截的对象,底层也是通过代理实现的,实际上是拿到一个目标代理对象 
  32.     @Override 
  33.     public Object plugin(Object target) { 
  34.         //触发intercept方法 
  35.         return Plugin.wrap(target, this); 
  36.     } 
  37.  
  38.     //设置属性 
  39.     @Override 
  40.     public void setProperties(Properties properties) { 
  41.         //获取我们定义的慢sql的时间阈值slowTime 
  42.         this.slowTime = Long.parseLong(properties.getProperty("slowTime")); 
  43.     } 

然后把这个插件类注入到容器中。

然后我们来执行查询的方法。

耗时28秒的,大于我们定义的10毫秒,那这条SQL就是我们认为的慢SQL。

通过这个插件,我们就能很轻松的理解setProperties()方法是做什么的了。

回顾分页插件

也是实现mybatis接口Interceptor。

  1. @SuppressWarnings({"rawtypes""unchecked"}) 
  2. @Intercepts( 
  3.     { 
  4.         @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}), 
  5.         @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}), 
  6.     } 
  7. public class PageInterceptor implements Interceptor { 
  8.         @Override 
  9.     public Object intercept(Invocation invocation) throws Throwable { 
  10.         ... 
  11.     } 

intercept方法中

  1. //AbstractHelperDialect类中 
  2. @Override 
  3. public String getPageSql(MappedStatement ms, BoundSql boundSql, Object parameterObject, RowBounds rowBounds, CacheKey pageKey) { 
  4.         String sql = boundSql.getSql(); 
  5.         Page page = getLocalPage(); 
  6.         //支持 order by 
  7.         String orderBy = page.getOrderBy(); 
  8.         if (StringUtil.isNotEmpty(orderBy)) { 
  9.             pageKey.update(orderBy); 
  10.             sql = OrderByParser.converToOrderBySql(sql, orderBy); 
  11.         } 
  12.         if (page.isOrderByOnly()) { 
  13.             return sql; 
  14.         } 
  15.         //获取分页sql 
  16.         return getPageSql(sql, page, pageKey); 
  17.  } 
  18. //模板方法模式中的钩子方法 
  19.  public abstract String getPageSql(String sql, Page page, CacheKey pageKey); 

AbstractHelperDialect类的实现类有如下(也就是此分页插件支持的数据库就以下几种):

我们用的是MySQL。这里也有与之对应的。

  1. @Override 
  2.    public String getPageSql(String sql, Page page, CacheKey pageKey) { 
  3.        StringBuilder sqlBuilder = new StringBuilder(sql.length() + 14); 
  4.        sqlBuilder.append(sql); 
  5.        if (page.getStartRow() == 0) { 
  6.            sqlBuilder.append(" LIMIT ? "); 
  7.        } else { 
  8.            sqlBuilder.append(" LIMIT ?, ? "); 
  9.        } 
  10.        pageKey.update(page.getPageSize()); 
  11.        return sqlBuilder.toString(); 
  12.    } 

到这里我们就知道了,它无非就是在我们执行的SQL上再拼接了Limit罢了。同理,Oracle也就是使用rownum来处理分页了。下面是Oracle处理分页

  1. @Override 
  2.     public String getPageSql(String sql, Page page, CacheKey pageKey) { 
  3.         StringBuilder sqlBuilder = new StringBuilder(sql.length() + 120); 
  4.         if (page.getStartRow() > 0) { 
  5.             sqlBuilder.append("SELECT * FROM ( "); 
  6.         } 
  7.         if (page.getEndRow() > 0) { 
  8.             sqlBuilder.append(" SELECT TMP_PAGE.*, ROWNUM ROW_ID FROM ( "); 
  9.         } 
  10.         sqlBuilder.append(sql); 
  11.         if (page.getEndRow() > 0) { 
  12.             sqlBuilder.append(" ) TMP_PAGE WHERE ROWNUM <= ? "); 
  13.         } 
  14.         if (page.getStartRow() > 0) { 
  15.             sqlBuilder.append(" ) WHERE ROW_ID > ? "); 
  16.         } 
  17.         return sqlBuilder.toString(); 
  18.     } 

其他数据库分页操作类似。关于具体原理分析,这里就没必要赘述了,因为分页插件源代码里注释基本上全是中文。

Mybatis插件应用场景

  • 水平分表
  • 权限控制
  • 数据的加解密

总结

Spring-Boot+Mybatis继承了分页插件,以及使用案例、插件的原理分析、源码分析、如何自定义插件。

涉及到技术点:JDK动态代理、责任链设计模式、模板方法模式。

Mybatis插件关键对象总结:

  • Inteceptor接口:自定义拦截必须实现的类。
  • InterceptorChain:存放插件的容器。
  • Plugin:h对象,提供创建代理类的方法。
  • Invocation:对被代理对象的封装。

本文转载自微信公众号「Java后端技术全栈」,可以通过以下二维码关注。转载本文请联系Java后端技术全栈公众号。

 

责任编辑:武晓燕 来源: Java后端技术全栈
相关推荐

2022-03-24 07:38:07

注解SpringBoot项目

2021-10-26 11:45:22

Vue面试前端

2019-11-25 16:05:20

MybatisPageHelpeJava

2021-01-26 09:25:02

Nginx开源软件服务器

2022-08-24 11:54:10

Pandas可视化

2021-05-27 05:34:22

Git开源控制系统

2020-12-17 08:02:42

MyBatis插件框架

2019-09-02 14:53:53

JVM内存布局GC

2023-04-28 08:30:56

MyBatis架构API

2013-07-16 15:35:54

Eclipse插件Android开发学习

2020-12-09 16:57:15

数据分析大数据

2022-05-23 10:55:19

华为数字化转型架构蓝图

2013-05-27 15:07:36

Eclipse插件

2022-05-18 11:35:17

Python字符串

2021-10-12 13:35:30

C++Set红黑树

2012-05-10 13:45:45

jQuery

2022-07-20 09:05:06

Python编程语言

2020-07-06 11:53:08

TCP三次握手协议

2019-09-03 10:55:20

Python函数lambad

2022-07-20 00:15:48

SQL数据库编程语言
点赞
收藏

51CTO技术栈公众号