从零开始手写 mybatis(二)mybatis interceptor 插件机制详解
前景回顾
第一节 从零开始手写 mybatis(一)MVP 版本 中我们实现了一个最基本的可以运行的 mybatis。
常言道,万事开头难,然后中间难。
mybatis 的插件机制是 mybatis 除却动态代理之外的第二大灵魂。
下面我们一起来体验一下这有趣的灵魂带来的痛苦与快乐~
插件的作用
在实际开发过程中,我们经常使用的Mybaits插件就是分页插件了,通过分页插件我们可以在不用写count语句和limit的情况下就可以获取分页后的数据,给我们开发带来很大
的便利。除了分页,插件使用场景主要还有更新数据库的通用字段,分库分表,加解密等的处理。
这篇博客主要讲Mybatis插件原理,下一篇博客会设计一个Mybatis插件实现的功能就是每当新增数据的时候不用数据库自增ID而是通过该插件生成雪花ID,作为每条数据的主键。
JDK动态代理+责任链设计模式
Mybatis的插件其实就是个拦截器功能。它利用JDK动态代理和责任链设计模式的综合运用。采用责任链模式,通过动态代理组织多个拦截器,通过这些拦截器你可以做一些你想做的事。
所以在讲Mybatis拦截器之前我们先说说JDK动态代理+责任链设计模式。
JDK 动态代理案例
package com.github.houbb.mybatis.plugin; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class JdkDynamicProxy { /** * 一个接口 */ public interface HelloService{ void sayHello(); } /** * 目标类实现接口 */ static class HelloServiceImpl implements HelloService{ @Override public void sayHello() { System.out.println("sayHello......"); } } /** * 自定义代理类需要实现InvocationHandler接口 */ static class HelloInvocationHandler implements InvocationHandler { private Object target; public HelloInvocationHandler(Object target){ this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("------插入前置通知代码-------------"); //执行相应的目标方法 Object rs = method.invoke(target,args); System.out.println("------插入后置处理代码-------------"); return rs; } public static Object wrap(Object target) { return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),new HelloInvocationHandler(target)); } } public static void main(String[] args) { HelloService proxyService = (HelloService) HelloInvocationHandler.wrap(new HelloServiceImpl()); proxyService.sayHello(); } }
- 输出
------插入前置通知代码------------- sayHello...... ------插入后置处理代码-------------
优化1:面向对象
上面代理的功能是实现了,但是有个很明显的缺陷,就是 HelloInvocationHandler 是动态代理类,也可以理解成是个工具类,我们不可能会把业务代码写到写到到invoke方法里,
不符合面向对象的思想,可以抽象一下处理。
定义接口
可以设计一个Interceptor接口,需要做什么拦截处理实现接口就行了。
public interface Interceptor { /** * 具体拦截处理 */ void intercept(); }
实现接口
public class LogInterceptor implements Interceptor{ @Override public void intercept() { System.out.println("------插入前置通知代码-------------"); } }
和
public class TransactionInterceptor implements Interceptor{ @Override public void intercept() { System.out.println("------插入后置处理代码-------------"); } }
实现代理
public class InterfaceProxy implements InvocationHandler { private Object target; private List<Interceptor> interceptorList = new ArrayList<>(); public InterfaceProxy(Object target, List<Interceptor> interceptorList) { this.target = target; this.interceptorList = interceptorList; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //处理多个拦截器 for (Interceptor interceptor : interceptorList) { interceptor.intercept(); } return method.invoke(target, args); } public static Object wrap(Object target, List<Interceptor> interceptorList) { InterfaceProxy targetProxy = new InterfaceProxy(target, interceptorList); return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), targetProxy); } }
测试验证
public static void main(String[] args) { List<Interceptor> interceptorList = new ArrayList<>(); interceptorList.add(new LogInterceptor()); interceptorList.add(new TransactionInterceptor()); HelloService target = new HelloServiceImpl(); HelloService targetProxy = (HelloService) InterfaceProxy.wrap(target, interceptorList); targetProxy.sayHello(); }
- 日志
------插入前置通知代码------------- ------插入后置处理代码------------- sayHello......
这里有一个很明显的问题,所有的拦截都在方法执行前被处理了。
优化 2:灵活指定前后
上面的动态代理确实可以把代理类中的业务逻辑抽离出来,但是我们注意到,只有前置代理,无法做到前后代理,所以还需要在优化下。
所以需要做更一步的抽象,
把拦截对象信息进行封装,作为拦截器拦截方法的参数,把拦截目标对象真正的执行方法放到Interceptor中完成,这样就可以实现前后拦截,并且还能对拦截对象的参数等做修改。
实现思路
代理类上下文
设计一个 Invocation 对象。
public class Invocation { /** * 目标对象 */ private Object target; /** * 执行的方法 */ private Method method; /** * 方法的参数 */ private Object[] args; public Invocation(Object target, Method method, Object[] args) { this.target = target; this.method = method; this.args = args; } /** * 执行目标对象的方法 */ public Object process() throws Exception{ return method.invoke(target,args); } // 省略 Getter/Setter }
调整接口
- Interceptor.java
public interface Interceptor { /** * 具体拦截处理 */ Object intercept(Invocation invocation) throws Exception; }
- 日志实现
public class MyLogInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Exception { System.out.println("------插入前置通知代码-------------"); Object result = invocation.process(); System.out.println("------插入后置处理代码-------------"); return result; } }
重新实现代理类
public class MyInvocationHandler implements InvocationHandler { private Object target; private Interceptor interceptor; public MyInvocationHandler(Object target, Interceptor interceptor) { this.target = target; this.interceptor = interceptor; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Invocation invocation = new Invocation(target, method, args); // 返回的依然是代理类的结果 return interceptor.intercept(invocation); } public static Object wrap(Object target, Interceptor interceptor) { MyInvocationHandler targetProxy = new MyInvocationHandler(target, interceptor); return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), targetProxy); } }
最核心的就在于构建了 invocation,然后执行对应的方法。
测试
- 代码
public static void main(String[] args) { HelloService target = new HelloServiceImpl(); Interceptor interceptor = new MyLogInterceptor(); HelloService targetProxy = (HelloService) MyInvocationHandler.wrap(target, interceptor); targetProxy.sayHello(); }
- 日志
------插入前置通知代码------------- sayHello...... ------插入后置处理代码-------------
优化 3:划清界限
上面这样就能实现前后拦截,并且拦截器能获取拦截对象信息。
但是测试代码的这样调用看着很别扭,对应目标类来说,只需要了解对他插入了什么拦截就好。
再修改一下,在拦截器增加一个插入目标类的方法。
实现
接口调整
public interface Interceptor { /** * 具体拦截处理 * * @return 方法执行的结果 * @since 0.0.2 */ Object intercept(Invocation invocation) throws Exception; /** * 插入目标类 * * @return 代理 * @since 0.0.2 */ Object plugin(Object target); }
实现调整
可以理解为把静态方法调整为对象方法。
public class MyLogInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Exception { System.out.println("------插入前置通知代码-------------"); Object result = invocation.process(); System.out.println("------插入后置处理代码-------------"); return result; } @Override public Object plugin(Object target) { return MyInvocationHandler.wrap(target, this); } }
测试
- 代码
public static void main(String[] args) { HelloService target = new HelloServiceImpl(); Interceptor interceptor = new MyLogInterceptor(); HelloService targetProxy = (HelloService) interceptor.plugin(target); targetProxy.sayHello(); }
- 日志
------插入前置通知代码------------- sayHello...... ------插入后置处理代码-------------
责任链模式
多个拦截器如何处理?
测试代码
public static void main(String[] args) { HelloService target = new HelloServiceImpl(); //1. 拦截器1 Interceptor interceptor = new MyLogInterceptor(); target = (HelloService) interceptor.plugin(target); //2. 拦截器 2 Interceptor interceptor2 = new MyTransactionInterceptor(); target = (HelloService) interceptor2.plugin(target); // 调用 target.sayHello(); }
其中 MyTransactionInterceptor 实现如下:
public class MyTransactionInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Exception { System.out.println("------tx start-------------"); Object result = invocation.process(); System.out.println("------tx end-------------"); return result; } @Override public Object plugin(Object target) { return MyInvocationHandler.wrap(target, this); } }
日志如下:
------tx start------------- ------插入前置通知代码------------- sayHello...... ------插入后置处理代码------------- ------tx end-------------
当然很多小伙伴看到这里其实已经想到使用责任链模式,下面我们一起来看一下责任链模式。
责任链模式
责任链模式
public class InterceptorChain { private List<Interceptor> interceptorList = new ArrayList<>(); /** * 插入所有拦截器 */ public Object pluginAll(Object target) { for (Interceptor interceptor : interceptorList) { target = interceptor.plugin(target); } return target; } public void addInterceptor(Interceptor interceptor) { interceptorList.add(interceptor); } /** * 返回一个不可修改集合,只能通过addInterceptor方法添加 * 这样控制权就在自己手里 */ public List<Interceptor> getInterceptorList() { return Collections.unmodifiableList(interceptorList); } }
测试
public static void main(String[] args) { HelloService target = new HelloServiceImpl(); Interceptor interceptor = new MyLogInterceptor(); Interceptor interceptor2 = new MyTransactionInterceptor(); InterceptorChain chain = new InterceptorChain(); chain.addInterceptor(interceptor); chain.addInterceptor(interceptor2); target = (HelloService) chain.pluginAll(target); // 调用 target.sayHello(); }
- 日志
------tx start------------- ------插入前置通知代码------------- sayHello...... ------插入后置处理代码------------- ------tx end-------------
个人的思考
拦截器是否可以改进?
实际上个人感觉这里可以换一种角度,比如定义拦截器接口时,改为:
这样可以代码中可以不用写执行的部分,实现起来更加简单,也不会忘记。
public interface Interceptor { /** * 具体拦截处理 */ void before(Invocation invacation); /** * 具体拦截处理 */ void after(Invocation invacation); }
不过这样也有一个缺点,那就是对于 process 执行的部分不可见,丧失了一部分灵活性。
抽象实现
对于 plugin() 这个方法,实际上实现非常固定。
应该对于接口不可见,直接放在 chain 中统一处理即可。
手写 mybatis 引入插件
说了这么多,如果你理解之后,那么接下来的插件实现部分就是小菜一碟。
只是将上面的思想做一个简单的实现而已。
快速体验
config.xml
引入插件,其他部分省略。
<plugins> <plugin interceptor="com.github.houbb.mybatis.plugin.SimpleLogInterceptor"/> </plugins>
SimpleLogInterceptor.java
我们就是简单的输出一下入参和出参。
public class SimpleLogInterceptor implements Interceptor{ @Override public void before(Invocation invocation) { System.out.println("----param: " + Arrays.toString(invocation.getArgs())); } @Override public void after(Invocation invocation, Object result) { System.out.println("----result: " + result); } }
执行测试方法
输出日志如下。
----param: [com.github.houbb.mybatis.config.impl.XmlConfig@3b76982e, MapperMethod{type='select', sql='select * from user where id = ?', methodName='selectById', resultType=class com.github.houbb.mybatis.domain.User, paramType=class java.lang.Long}, [Ljava.lang.Object;@67011281] ----result: User{id=1, name='luna', password='123456'} User{id=1, name='luna', password='123456'}
是不是灰常的简单,那么是怎么实现的呢?
核心实现
接口定义
public interface Interceptor { /** * 前置拦截 * @param invocation 上下文 * @since 0.0.2 */ void before(Invocation invocation); /** * 后置拦截 * @param invocation 上下文 * @param result 执行结果 * @since 0.0.2 */ void after(Invocation invocation, Object result); }
启动插件
在 openSession() 的时候,我们启动插件:
public SqlSession openSession() { Executor executor = new SimpleExecutor(); //1. 插件 InterceptorChain interceptorChain = new InterceptorChain(); List<Interceptor> interceptors = config.getInterceptorList(); interceptorChain.add(interceptors); executor = (Executor) interceptorChain.pluginAll(executor); //2. 创建 return new DefaultSqlSession(config, executor); }
这里我们就看到了一个责任链,实现如下。
责任链
public class InterceptorChain { /** * 拦截器列表 * @since 0.0.2 */ private final List<Interceptor> interceptorList = new ArrayList<>(); /** * 添加拦截器 * @param interceptor 拦截器 * @return this * @since 0.0.2 */ public synchronized InterceptorChain add(Interceptor interceptor) { interceptorList.add(interceptor); return this; } /** * 添加拦截器 * @param interceptorList 拦截器列表 * @return this * @since 0.0.2 */ public synchronized InterceptorChain add(List<Interceptor> interceptorList) { for(Interceptor interceptor : interceptorList) { this.add(interceptor); } return this; } /** * 代理所有 * @param target 目标类 * @return 结果 * @since 0.0.2 */ public Object pluginAll(Object target) { for(Interceptor interceptor : interceptorList) { target = DefaultInvocationHandler.proxy(target, interceptor); } return target; } }
其中的 DefaultInvocationHandler 实现如下:
/** * 默认的代理实现 * @since 0.0.2 */ public class DefaultInvocationHandler implements InvocationHandler { /** * 代理类 * @since 0.0.2 */ private final Object target; /** * 拦截器 * @since 0.0.2 */ private final Interceptor interceptor; public DefaultInvocationHandler(Object target, Interceptor interceptor) { this.target = target; this.interceptor = interceptor; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Invocation invocation = new Invocation(target, method, args); interceptor.before(invocation); // invoke Object result = method.invoke(target, args); interceptor.after(invocation, result); return result; } /** * 构建代理 * @param target 目标对象 * @param interceptor 拦截器 * @return 代理 * @since 0.0.2 */ public static Object proxy(Object target, Interceptor interceptor) { DefaultInvocationHandler targetProxy = new DefaultInvocationHandler(target, interceptor); return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), targetProxy); } }
小结
本节的实现并不难,难在要理解 mybatis 整体对于插件的设计理念,技术层面还是动态代理,结合了责任链的设计模式。
这种套路学会之后,其实很多类似的框架,我们自己在实现的时候都可以借鉴这种思想。
拓展阅读
参考资料
低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。
持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。
转载内容版权归作者及来源网站所有,本站原创内容转载请注明来源。
- 上一篇
数据库主从不一致,怎么解?
在聊数据库与缓存一致性问题之前,先聊聊数据库主库与从库的一致性问题。 问:常见的数据库集群架构如何? 答:一主多从,主从同步,读写分离。 如上图: 一个主库提供写服务 多个从库提供读服务,可以增加从库提升读性能 主从之间同步数据 画外音:任何方案不要忘了本心,加从库的本心,是提升读性能。 问:为什么会出现不一致? 答:主从同步有时延,这个时延期间读从库,可能读到不一致的数据。 如上图: 服务发起了一个写请求 服务又发起了一个读请求,此时同步未完成,读到一个不一致的脏数据 数据库主从同步最后才完成 画外音:任何数据冗余,必将引发一致性问题。 问:如何避免这种主从延时导致的不一致? 答:常见的方法有这么几种。 方案一:忽略 任何脱离业务的架构设计都是耍流氓,绝大部分业务,例如:百度搜索,淘宝订单,QQ消息,58帖子都允许短时间不一致。 画外音:如果业务能接受,最推崇此法。 如果业务能够接受,别把系统架构搞得太复杂。 方案二:强制读主 如上图: 使用一个高可用主库提供数据库服务 读和写都落到主库上 采用缓存来提升系统读性能 这是很常见的微服务架构,可以避免数据库主从一致性问题。 方案三:选择...
- 下一篇
非常叼的工单系统,工单结束,工作完成;非常叼的权限管控,精细到页面按钮及API
最近在研究工单系统的时候,被我找到一个非常流弊的工单系统,我们都知道工单系统最麻烦的就是流程和模版的维护,并且,在工单处理过程中很可能会添加一些操作,这些操作被称之为钩子。就按我目前调研的结果来说,目前其实没有啥工单系统能实现的这么好的。 这个工单系统就把流程设计,模版设计等等做的非常不错,而且对权限的把控非常详细,包括API接口、菜单、页面按钮权限,都可以灵活的控制,非常的不错。 Demo:http://fdevops.com:8001/#/dashboard Github:https://github.com/lanyulei/ferry 如果觉得不错就给作者一个star,你的star没准就是作者继续维护下去的动力呢。 功能介绍 系统管理 用户管理不仅仅包括了用户,还有角色、职位、部门的管理,方便后面的工单处理人扩展。 菜单管理,对菜单,页面按钮,甚至是API接口的管理。 登陆日志,对用户登陆和退出的日志记录。 流程中心 流程申请,对流程进行分类管理,方便维护与可视化。 工单列表,拆分了4个分类,包括:我待办的工单,我创建的工单,我相关的工单,还有所有工单。 转交工单,如果你当前有...
相关文章
文章评论
共有0条评论来说两句吧...
文章二维码
点击排行
推荐阅读
最新文章
- CentOS关闭SELinux安全模块
- 2048小游戏-低调大师作品
- Springboot2将连接池hikari替换为druid,体验最强大的数据库连接池
- CentOS6,7,8上安装Nginx,支持https2.0的开启
- SpringBoot2配置默认Tomcat设置,开启更多高级功能
- CentOS7编译安装Gcc9.2.0,解决mysql等软件编译问题
- Red5直播服务器,属于Java语言的直播服务器
- Linux系统CentOS6、CentOS7手动修改IP地址
- CentOS7,8上快速安装Gitea,搭建Git服务器
- CentOS8,CentOS7,CentOS6编译安装Redis5.0.7