ag亚游官方下载ag亚游官方下载


AG亚游集团

【Mybtais】Mybatis 插件 Plugin开发(一)动态代理步步解析

需求:

  对原有系统中的方法进行‘拦截’,在方法执行的前后添加新的处理逻辑。

分析:

  不是办法的办法就是,对原有的每个方法进行修改,添加上新的逻辑;如果需要拦截的方法比较少,选择此方法到是会节省成本。但是面对成百上千的方法怎么办?此时需要用到动态代理来实现。

场景:

  例如:对原有的系统添加日志记录、添加性能分析等等。。。

举例:

  如下,需要对Sleep对象的sleep方法进行“拦截”,并在此方法的执行前后添加新的逻辑。想知道‘睡觉前干了什么?睡觉后干了什么?’

interface Sleep { public void sleep();}

public class SleepImpl implements Sleep{ public void sleep() { System.out.println("我于"+new SimpleDateFormat("yyyy-MM-dd HH:mm").format(new Date())+"开始睡觉"); }}

  创建动态代理类,实现InvocationHandler接口即可。下面的wrap方法:传入要被代理的对象target。返回包装后的代理对象。$Proxy 打断点会看到这样的对象。针对下面的sleepProxy对象,sleepProxy.sleep()调用需要拦截的方法。实际上调用的是Plugin中的invoke方法。invoke方法中的method.invoke(target,args)是真是的调用被代理对象的sleep方法。所以直接在此语句的前后添加相应的逻辑即可满足需要。

public class Plugin implements InvocationHandler { private Object target; Plugin(Object target){ this.target = target; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //睡觉前做的事 Object result = method.invoke(target, args); //睡觉后做的事 return result; } public static Object wrap(Object target){ return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new Plugin(target)); }}

public class Main { public static void main(String[] args) { //要被代理的对象 Sleep sleep = new SleepImpl(); //代理对象 Sleep sleepProxy = (Sleep)Plugin.wrap(sleep); sleepProxy.sleep(); }}

到此,你以为就结束了?不 ,这个仅仅是 说了在睡觉 前后做了什么事,加入还想知道,你在睡觉前后吃了什么东西?当然睡觉后吃东西有点说不通。但 意会就可以了。还有其他巴拉巴拉的需求。你该怎么做?是不是要把所有的 新的逻辑都方法 Plugin中invoke方法中去?这样不合适吧!乱 乱 乱 这样。那咱们能不能抽象出来一个拦截接口,接口中有拦截后要做什么的方法。各种需求只需要实现这个拦截接口即可!

interface Interceptor { public void interceptBefore()throws Exception; public void interceptAfter()throws Exception;}

public class SleepBeforeAndAfter implements Interceptor { public void interceptBefore() throws Exception { System.out.println("之前。。。"); } public void interceptAfter() throws Exception { System.out.println("之后。。。"); }}

然后动态代理类Plugin需要修改

/** * 动态代理 * * @author 魏正迪 * 2018年10月13日 */public class Plugin implements InvocationHandler { private Object target; private List<Interceptor> iList = new ArrayList<Interceptor>(); Plugin(Object target , List<Interceptor> iList){ this.target = target; this.iList = iList; } public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { for(Interceptor i :iList){ i.interceptBefore(); } Object result = method.invoke(target, args); for(Interceptor i :iList){ i.interceptAfter(); } return result; } public static Object wrap(Object target,List<Interceptor> iList){ return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new Plugin(target,iList) ); }}

public class Main { public static void main(String[] args) { Sleep sleep = new SleepImpl(); List<Interceptor> iList = new ArrayList<Interceptor>(); iList.add(new SleepBeforeAndAfter()); Sleep sleepProxy = (Sleep)Plugin.wrap(sleep,iList); sleepProxy.sleep(); }}

现在想对每个对象的方法进行拦截,直接实现Interceptor接口即可!实现其中的两个方法。此时我们新加的逻辑和原有的逻辑并没有什么交集。假如我们想在interceptor中的两个方法中使用被代理对象的各种属性,此时该怎么做?首先想到是将interceptor接口的两个方法添加参数。

public class SleepBeforeAndAfter implements Interceptor { public void interceptBefore(Object target, Method method, Object[] args) throws Exception { System.out.println("之前。。。interceptBefore(Object target, Method method, Object[] args)"); } public void interceptAfter(Object target, Method method, Object[] args) throws Exception { System.out.println("之后。。。interceptAfter(Object target, Method method, Object[] args)"); }}

到此,个人感觉没啥问题了【大牛如发现明显不符的请指出】。但但但但是我们奔着简单明了、面向对象的思想(其实就是mybatis源码插件设计)。我们做出进一步的精简。于是Invocation对象产生了。看到Method对象传进来了。我们是不是可以想到,我们不再 在Plugin中的invoke方法中调用method.invoke(target,args);了,而是在Intercetpor中处理完前后逻辑后进行调用。这样分工明确了。

/** * 拦截对象的包装 * @author 魏正迪 * 2018年10月13日 */public class Invocation { private Object target; private Object []args; private Method method; Invocation(Object target,Method method,Object[] args){ this.target = target; this.args = args; this.method = method; } /** * 执行拦截对象的对应的方法 * @return * @throws Exception */ public Object process() throws Exception{ return method.invoke(target, args); } }

此时拦截器Interceptor应该是这样的

interface Interceptor { public Object intercept(Invocation invocation)throws Exception;}

public class SleepBeforeAndAfter implements Interceptor { public Object intercept(Invocation invocation) throws Exception{ System.out.println("拦截sleep方法要执行的方法之前"); Object result = invocation.process(); System.out.println("拦截sleep方法要执行的方法之后"); return result; }}

此时Plugin应该是这样的

public class Plugin implements InvocationHandler { private Object target; private Interceptor interceptor; Plugin(Object target,Interceptor interceptor){ this.target = target; this.interceptor = interceptor; } 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){ return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new Plugin(target,interceptor) ); }}

public class Main { public static void main(String[] args) { Sleep sleep = new SleepImpl(); SleepBeforeAndAfter s = new SleepBeforeAndAfter(); Sleep sleepProxy1 = (Sleep)Plugin.wrap(sleep,s); sleepProxy1.sleep(); Sleep sleepProxy2 = (Sleep)Plugin.wrap(sleepProxy1, s); sleepProxy2.sleep(); }}

到此,mybatis插件开发的引言完毕!其实是使用了动态代理和责任链结合的方式。

  

 

欢迎阅读本文章: 王凤霞

AG备用网站

AG亚游集团