Mybatis框架和插件将动态代理玩出了新境界

静态代理

又是一年毕业季，很多小伙伴开始去大城市打拼。来大城市第一件事就是租房，免不了和中介打交道，因为很多房东很忙，你根本找不到他。从这个场景中就可以抽象出来代理模式。

ISubject：被访问者资源的抽象SubjectImpl：被访问者具体实现类（房东）SubjectProxy：被访问者的代理实现类（中介）

UML图如下

举个例子来理解一下这个设计模式老板让记录一下用户服务的响应时间，用代理模式来实现这个功能。

public interface IUserService { public void request（）;}

public class UserServiceImpl implements IUserService { @Override public void request（） { System.out.println（“this is userService”）; }}

public class UserServiceProxy implements IUserService { private IUserService userService; public UserServiceProxy（IUserService userService） { this.userService = userService; } @Override public void request（） { long startTime = System.currentTimeMillis（）; userService.request（）; System.out.println（“reques cost ：” + （System.currentTimeMillis（） - startTime））; } public static void main（String［］ args） { IUserService userService = new UserServiceImpl（）; UserServiceProxy userServiceProxy = new UserServiceProxy（userService）; // this is userService // reques cost ：0 userServiceProxy.request（）; }}

一切看起来都非常的美好，老板又发话了，把产品服务的响应时间也记录一下吧。又得写如下3个类

IProductService ProductServiceImpl ProductServiceProxy

UserServiceProxy和ProductServiceProxy这两个代理类的逻辑都差不多，却还得写2次。其实这个还好，如果老板说，把现有系统的几十个服务的响应时间都记录一下吧，你是不是要疯了？这得写多少代理类啊？

动态代理

黑暗总是暂时的，终究会迎来黎明，在JDK1.3之后引入了一种称之为动态代理（Dynamic Proxy）的机制。使用该机制，我们可以为指定的接口在系统运行期间动态地生成代理对象，从而帮助我们走出最初使用静态代理实现AOP的窘境

动态代理的实现主要由一个类和一个接口组成，即java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。

让我们用动态代理来改造一下上面记录系统响应时间的功能。虽然要为IUserService和IProductService两种服务提供代理对象，但因为代理对象中要添加的横切逻辑是一样的。所以我们只需要实现一个InvocationHandler就可以了。代码如下

public class RequestCostInvocationHandler implements InvocationHandler { private Object target; public RequestCostInvocationHandler（Object target） { this.target = target; } /** 被代理对象的任何方法被执行时，都会先进入这个方法 */ @Override public Object invoke（Object proxy， Method method， Object［］ args） throws Throwable { if （method.getName（）.equals（“request”）） { long startTime = System.currentTimeMillis（）; // 执行目标对象的方法 method.invoke（target， args）; System.out.println（“reques cost ：” + （System.currentTimeMillis（） - startTime））; } return null; } public static void main（String［］ args） { // 3个参数解释如下 // classloader，生成代理类 // 代理类应该实现的接口 // 实现InvocationHandler的切面类 IUserService userService = （IUserService） Proxy.newProxyInstance（IUserService.class.getClassLoader（）， new Class［］{IUserService.class}， new RequestCostInvocationHandler（new UserServiceImpl（）））; IProductService productService = （IProductService） Proxy.newProxyInstance（IProductService.class.getClassLoader（）， new Class［］{IProductService.class}， new RequestCostInvocationHandler（new ProductServiceImpl（）））; // this is userService // reques cost ：0 userService.request（）; // this is productService // reques cost ：0 productService.request（）; }}

UML图如下。恭喜你，你现在已经理解了Spring AOP是怎么回事了，就是这么简单，今天先不展开谈Spring

先简单谈谈动态代理在Mybatis中是如何被大佬玩的出神入化的

Mybatis核心设计思路

相信用过mybatis的小伙伴都能理解下面这段代码，通过roleMapper这个接口直接从数据库中拿到一个对象

Role role = roleMapper.getRole（3L）;

直觉告诉我，一个接口是不能运行的啊，一定有接口的实现类，可是这个实现类我自己没写啊，难道mybatis帮我们生成了？你猜的没错，mybatis利用动态代理帮我们生成了接口的实现类，这个类就是org.apache.ibatis.binding.MapperProxy，我先画一下UML图，MapperProxy就是下图中的SubjectProxy类

和上面的UML类图对比一下，发现不就少了一个SubjectImpl类吗？那应该就是SubjectProxy类把SubjectImple类要做的事情做了呗，猜对了。SubjectProxy通过SubjectImple和SubjectImple.xml之间的映射关系知道自己应该执行什么SQL。所以mybatis最核心的思路就是这么个意思，细节之类的可以看源码，理清最主要的思路，看源码就能把握住重点。

Mybatis插件原理

mybatis的插件也用到了动态代理，还用到了责任链模式，我就不从源码角度分析了。说一下大概实现，我们用插件肯定是为了在原先的基础上增加新功能。增加一个插件，mybatis就在原先类的基础上用动态代理生成一个代理对象，如果有多个插件，就在代理对象的基础上再生成代理对象，形式和如下函数差不多

plugin2（ plugin1（ start（） ） ）

我再给你写个例子，你再看看相关的源码分析文章（也许我以后会写），很快就能理解了。

在mybatis中要想用插件，有如下2个步骤1.在mybatis-config.xml中配置插件，如下所示

《plugins》 《plugin interceptor=“org.xrq.mybatis.plugin.FirstInterceptor” /》 《plugin interceptor=“org.xrq.mybatis.plugin.SecondInterceptor” /》《/plugins》

2.插件类还得实现Interceptor接口

我现在给一个需求，一个应用返回字符串0，我加一个插件在字符串的左右两边加plugin1，再加一个插件在字符串的左右两边加plugin2，开写

返回字符串的接口

public interface IGetStr { public String getStrZero（）; public String getStrOne（）;}

返回字符串的实现类

public class GetStrImpl implements IGetStr { @Override public String getStrZero（） { return “0”; } @Override public String getStrOne（） { return “1”; }}

定义拦截器接口

public interface Interceptor { /** 执行拦截逻辑的方法 */ Object intercept（Invocation invocation）; /** * target是被拦截的对象，它的作用是给被拦截对象生成一个代理对象，并返回它。 * 为了方便，可以直接使用Mybatis中org.apache.ibatis.plugin类的wrap方法生成代理对象 * 我这里也写了一个Plugin方法 */ Object plugin（Object target）;}

看到一个不认识的类Invocation，定义如下

public class Invocation { private final Object target; private final Method method; private final Object［］ args; public Invocation（Object target， Method method， Object［］ args） { this.target = target; this.method = method; this.args = args; } public Object proceed（） throws InvocationTargetException， IllegalAccessException { return method.invoke（target， args）; }}

就是简单的封装了一下目标对象，目标方法和目标方法的参数。proceed方法就是执行目标对象的目标方法

Plugin算是一个工具类，生成代理对象

public class Plugin implements InvocationHandler { /** 目标对象 */ private final Object target; /** Interceptor对象 */ private final Interceptor interceptor; public Plugin（Object target， Interceptor interceptor） { this.target = target; this.interceptor = interceptor; } /** 生成代理对象 */ public static Object wrap（Object target， Interceptor interceptor） { return Proxy.newProxyInstance（target.getClass（）.getClassLoader（）， new Class［］{IGetStr.class}， new Plugin（target， interceptor））; } /** 被代理对象的方法执行时，这个方法会被执行 */ @Override public Object invoke（Object proxy， Method method， Object［］ args） throws Throwable { // 只为方法getStrZero生成代理对象 if （method.getName（）.equals（“getStrZero”）） { return interceptor.intercept（new Invocation（target， method， args））; } return method.invoke（target， args）; }}

写第一个插件

public class FirstInterceptor implements Interceptor { /** 执行拦截逻辑的方法 */ @Override public Object intercept（Invocation invocation） { try { return “plugin1 ” + invocation.proceed（） + “ plugin1”; } catch （Exception e） { return null; } } /** 为原先的类生成代理对象 */ @Override public Object plugin（Object target） { return Plugin.wrap（target， this）; }}

有2个方法

plugin是为插件生成代理对象，用了我自己写的Plugin工具类intercept是增加拦截逻辑，invocation.proceed（）是执行目标对象的目标方法，前文说过了哈，这里我们只对输出做了改变

第二个插件和第一个插件类似

public class SecondInterceptor implements Interceptor { @Override public Object intercept（Invocation invocation） { try { return “plugin2 ” + invocation.proceed（） + “ plugin2”; } catch （Exception e） { return null; } } @Override public Object plugin（Object target） { return Plugin.wrap（target， this）; }}

用一个容器保存插件，这里用到了责任链模式

public class InterceptorChain { /** 放拦截器 */ private final List《Interceptor》 interceptors = new ArrayList《Interceptor》（）; public Object pluginAll（Object target） { for （Interceptor interceptor ： interceptors） { target = interceptor.plugin（target）; } return target; } public void addInterceptor（Interceptor interceptor） { interceptors.add（interceptor）; }}

pluginAll方法是精髓，为每个插件一层一层的生成代理对象，就像套娃娃一样。

验证一下

public class Main { public static void main（String［］ args） { // 配置插件 InterceptorChain interceptorChain = new InterceptorChain（）; interceptorChain.addInterceptor（new FirstInterceptor（））; interceptorChain.addInterceptor（new SecondInterceptor（））; // 获得代理对象 IGetStr getStr = new GetStrImpl（）; getStr = （IGetStr） interceptorChain.pluginAll（getStr）; String result = getStr.getStrZero（）; // plugin2 plugin1 0 plugin1 plugin2 System.out.println（result）; result = getStr.getStrOne（）; // 1 System.out.println（result）; }}

大功告成，可以看到先定义的插件先执行。

类有点多，如果看的有点晕，多看几次，你就很容易理解了，我这里还是精简了很多。

一个InvocationHandler接口被大佬玩出了新境界，果然编程这件事还得靠想象力。