jdk动态代理实现的接口,jdk静态代理和动态代理

　　00-1010前言为什么需要java 1中常用的代理模式？JDK动态代理2。cglib静态代理3。spring中代理的使用总结

　　00-1010代理模式在JDK可以说是几乎无处不在，spring框架和日常开发。下图描述了agent模式的业务场景，对于有一定开发经验的同学来说应该不难理解；

　　现在，我突然收到一个为事务性操作(如添加或删除现有类)添加审计日志的需求。很多人首先想到的是在每一个添加或删除日志的地方添加日志。如果这样的课太多，会很麻烦。比较好的方法是使用代理类，在不修改原有类的情况下扩展log函数(spring aop函数就是这种情况)；

　　00-1010总结一下，java中常用的代理实现主要有：

　　Jdk动态代理；Cglib静态代理

前言

JDK动态代理基于拦截器和反射实现，不需要第三方库的支持，只需要JDK环境。

　　必须实现InvocationHandler接口；使用Proxy.newProxyInstance生成代理对象；代理对象必须实现接口；采用内部asm技术动态生成字节码；让我们看一个jdk动态代理的简单案例来深入理解它的用法。

　　公共类JDK proxy demo { interface Foo { void Foo()；}静态类Target实现Foo { @ Override public void Foo(){ system . out . println( Target Foo )；}} /** * jdk代理只能代理接口*在内部，它动态生成字节码()* @ param args */public static void main(string[]args){ target target=new target()；class loader class loader=JDK proxy demo . class . get class loader()；Foo proxy=(Foo)proxy . New proxy instance(Class loader，new Class[]{Foo.class}，New InvocationHandler() {//proxy代理对象本身//方法执行方法//方法参数@ override公共对象invoke (object proxy，method，object[]args)throws rowable { system . out . println( before )；object result=method . invoke(target，args)；//代理类返回目标方法执行的结果system . out . println( after )；返回结果；} });proxy . foo()；}}运行这段代码并观察效果。

　　公共静态对象new proxy instance(Class loader loader，Class？[]接口，

　　 InvocationHandler h) throws IllegalArgumentException代码本身很简单，最重要的就是Proxy.newProxyInstance 这个方法，理解这里面的几个参数至关重要，分别说明下几个参数的含义：

　　classLoader，类加载器；interfaces，目标对象接口；InvocationHandler，真正完成相关方法反射代理的处理器；

JDK动态代理，其关键的步骤就是在InvocationHandler 中执行目标实现类的方法反射调用

　　

由于JDK动态代理，底层是采用了asm字节码技术动态生成，我们无法通过debug源码的方式去学习，为了深入了解其原理，不妨模拟下其实现的过程吧；

　　要模拟这个过程，大概需要下面的这些准备：

　　接口和接口实现类；自定义的invocationHandler；自定义的Proxy对象（实现与目标类相同的接口）；1、自定义接口和实现

interface Foo{ void foo(); } static class Target implements Foo{ @Override public void foo() { System.out.println(" target foo"); } }

2、自定义的invocationHandler；

　　通过上面的demo也可以看到，invocationHandler其实就是一个接口，真正执行时，需要传入到Proxy对象中，通过接口回调的方式实现，这里只需要参照JDK中的invocationHandler，定义好方法参数即可；

public interface MyInvocationHandler { Object invoke(Object proxy, Method method, Object[] params); }

3、自定义的Proxy对象

　　这段代码的逻辑大致如下：

　　以构造的方式将自定义invocationHandler传入；通过反射拿到目标接口的方法；通过自定义invocationHandler的接口回调，通过反射完成代理逻辑实现；

import java.lang.reflect.Method;public class MyProxy implements SelfJdkProxy.Foo { private SelfJdkProxy.MyInvocationHandler invocationHandler; public MyProxy(SelfJdkProxy.MyInvocationHandler invocationHandler) { this.invocationHandler = invocationHandler; } @Override public void foo() { try { Method foo = SelfJdkProxy.Foo.class.getMethod("foo"); invocationHandler.invoke(this, foo, new Object[0]); } catch (NoSuchMethodException e) { e.printStackTrace(); } } @Override public int bar() { Method bar = null; Object result = null; try { bar = SelfJdkProxy.Foo.class.getMethod("bar"); result = invocationHandler.invoke(this, bar, new Object[0]); } catch (NoSuchMethodException e) { e.printStackTrace(); } return (int) result; }}

运行上面的代码，观察效果，可以看到，输出效果是一样的，通过这个实现，我们简单模拟了JDK动态代理内部的简单实现；

二、cglib静态代理

JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要cglib了；

　　cglib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。

　　下面先看一个简单的cglib使用案例

　　1、原始目标方法

/** * 原始目标方法 */public class CglibTarget { public void save() { System.out.println("save()"); } public void save(int i) { System.out.println("save(int)"); } public void save(long i) { System.out.println("save(long)"); }}

2、代理实现核心逻辑

/** * cglib代理是通过父子继承关系创建代理 * 代理对象自身是作为一个子类型的存在 */public class CglibProxyDemo { static class Target { public void foo() { System.out.println(" target foo"); } } public static void main(String[] args) { Target target = new Target(); Target proxy = (Target)Enhancer.create(Target.class, new MethodInterceptor() { // o : 代理类对象自身 //method : 代理类执行的方法 //args : 方法执行参数 //methodProxy : 方法代理【采用这个参数，可以避免使用方法反射进行调用，但是内部未使用反射】 @Override public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { /* System.out.println("before"); Object result = method.invoke(target, args); System.out.println("after"); return result;*/ //methodProxy 使用 ，使用目标进行代理 /*System.out.println("before"); Object result = methodProxy.invoke(target,args); System.out.println("after"); return result;*/ //methodProxy 使用 ，使用自身进行代理 System.out.println("before"); Object result = methodProxy.invokeSuper(o,args); System.out.println("after"); return result; } }); proxy.foo(); }}

cglib的使用相对JDK代理来说，显得更灵活，用起来也很方便，比较核心的地方在于通过调用CglibProxy这个方法的setMethodInterceptor，在回调接口中完成代理逻辑的实现；

　　这里需要说明的是，在MethodInterceptor 接口回调方法中，提供了两种完成代理逻辑实现的方式，

　　method.invoke(target,args); 基于反射实现；methodProxy.invoke(target,args); 直接调用目标类的方法；methodProxy.invokeSuper(o,args);直接调用目标类的方法；

需要特别注意的是，CGLib创建的动态代理对象性能比JDK创建的动态代理对象的性能高不少，但CGLib在创建代理对象时所花费的时间却比JDK多得多，所以对于单例对象，因无需频繁创建对象，用CGLib合适，反之，使用JDK方式要更为合适一些。同时，由于CGLib由于是采用动态创建子类的方法，对于final方法，无法进行代理。

　　

同样来说，cglib底层的字节码技术的实现导致我们很难通过debug的方式去调试源码，下面来通过代码模拟上面的实现过程；

　　自定义一个类，模拟Enhancer 实现

　　整段代码逻辑做如下说明

　　注入MethodInterceptor ，模拟cglib的create方法中的Enhancer；继承CglibTarget，即cglib采用的是继承目标类的方式完成代理；将代理类中的方法重写，并通过methodInterceptor.intercept 完成接口回调；将目标类中的方法，以静态代码块方式注入，避免每次调用重新实例化；自定义saveSuper方法，模拟MethodProxy 的实现过程；

/** * cglib的代理是基于继承，并重写父类方法进行增强 */public class CglibProxy extends CglibTarget { private MethodInterceptor methodInterceptor; public void setMethodInterceptor(MethodInterceptor methodInterceptor) { this.methodInterceptor = methodInterceptor; } static Method save0; static Method save1; static Method save2; static MethodProxy save0Proxy; static MethodProxy save1Proxy; static MethodProxy save2Proxy; static { try { save0 = CglibTarget.class.getMethod("save"); save1 = CglibTarget.class.getMethod("save", int.class); save2 = CglibTarget.class.getMethod("save", long.class); save0Proxy = MethodProxy.create(CglibTarget.class, CglibProxy.class, "()V", "save", "saveSuper"); save1Proxy = MethodProxy.create(CglibTarget.class, CglibProxy.class, "(I)V", "save1", "saveSuper"); save2Proxy = MethodProxy.create(CglibTarget.class, CglibProxy.class, "(J)V", "save2", "saveSuper"); } catch (NoSuchMethodException e) { throw new NoSuchMethodError(e.getMessage()); } } public void saveSuper() { super.save(); } public void saveSuper(int i) { super.save(i); } public void saveSuper(long i) { super.save(i); } @Override public void save() { try { methodInterceptor.intercept(this, save0, new Object[0], save0Proxy); } catch (Throwable throwable) { //throwable.printStackTrace(); throw new UndeclaredThrowableException(throwable); } } @Override public void save(int i) { try { methodInterceptor.intercept(this, save1, new Object[]{i}, save1Proxy); } catch (Throwable throwable) { //throwable.printStackTrace(); throw new UndeclaredThrowableException(throwable); } } @Override public void save(long i) { try { methodInterceptor.intercept(this, save2, new Object[]{i}, save2Proxy); } catch (Throwable throwable) { //throwable.printStackTrace(); throw new UndeclaredThrowableException(throwable); } }}

编写测试类

public class CglibTest { public static void main(String[] args) { CglibProxy proxy = new CglibProxy(); CglibTarget target = new CglibTarget(); proxy.setMethodInterceptor(new MethodInterceptor() { @Override public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { System.out.println("before..."); //return method.invoke(target,args); //return methodProxy.invoke(target,args); return methodProxy.invokeSuper(o,args); } }); proxy.save(); }}

运行上面的代码，通过控制台输出结果，可以看到和上面的效果一致；

　　这里需要对这个MethodProxy稍作说明，通过上面的案例可以看到，cglib的回调逻辑中，不仅可以通过类似JDK的反射实现代理，还可以通过MethodProxy提供的invoke()或者invokeSuper()方式实现，之所以说，cglib在某些情况下比JDK代理高效，就在于通过MethodProxy的两个方法，将不走反射，而是直接调用目标类的方法；

三、spring中代理的使用

在spring框架中，使用代理模式比较典型的场景就是AOP的实现了，代理逻辑核心要点如下：

　　默认使用 JDK 动态代理，这样可以代理所有的接口类型；如果目标对象没有实现任何接口，则默认采用CGLIB代理；可强制使用CGLIB，指定proxy-target-class = true 或者基于注解@EnableAspectJAutoProxy(proxyTargetClass = true)下面以AOP的功能使用为入口，来感受下以上三点在AOP的代理中的实现，

　　来看下面这段以spring底层模拟实现的方式的AOP功能代码

import org.aopalliance.intercept.MethodInterceptor;import org.aopalliance.intercept.MethodInvocation;import org.springframework.aop.aspectj.AspectJExpressionPointcut;import org.springframework.aop.framework.ProxyFactory;import org.springframework.aop.support.DefaultPointcutAdvisor;public class SpringAopTest { public static void main(String[] args) { //1、定义切点 AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut(); pointcut.setExpression("execution(* foo())"); //2、定义通知 MethodInterceptor advice = new MethodInterceptor() { @Override public Object invoke(MethodInvocation methodInvocation) throws Throwable { return methodInvocation.proceed(); } }; //3、定义切面 DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice); //4、创建代理 Target1 target1 = new Target1(); ProxyFactory proxyFactory = new ProxyFactory(); proxyFactory.setTarget(target1); proxyFactory.addAdvisor(advisor); F1 proxy = (F1)proxyFactory.getProxy(); //查看代理类的类型 System.out.println(proxy.getClass()); proxy.foo(); proxy.bar(); } interface F1 { void foo(); void bar(); } static class Target1 implements F1 { @Override public void foo() { System.out.println("Target1 foo() ..."); } @Override public void bar() { System.out.println("Target1 bar() ..."); } } static class Target2 implements F1 { @Override public void foo() { System.out.println("Target2 foo() ..."); } @Override public void bar() { System.out.println("Target2 bar() ..."); } }}

主要逻辑思路可以参考注释，然后运行这段代码，观察控制台效果

　　通过控制台输出结果，可以大致得出下面几点结论，

　　AOP技术底层采用了代理实现；如果目标类实现了接口，spring默认情况下使用的是JDK代理；可以通过修改ProxyConfig中的属性proxyTargetClass 值来改变代理方式；

　　根据这个属性的不同，将会产生下面几种代理方式

　　proxyTargetClass = false; 目标实现了接口，采用JDK代理实现；proxyTargetClass = false; 目标没有实现接口，采用cglib实现；proxyTargetClass = true; 总是使用cglib实现；关于上面这几点，我们来通过上面代码的微调来观察效果，上面为什么会输出的是cglib的代理呢？因为在程序中并没有设置这个属性，因此被判断为并未实现接口，所以走的是cglib代理，

　　调整1：设置代理类的接口

　　再次运行上面的代码，这次走的就是JDK动态代理

　　调整2：设置proxyTargetClass 属性为true

　　再次运行上面的代码，这次走的就是cglib代理

总结

到此这篇关于jdk动态代理使用的文章就介绍到这了,更多相关jdk动态代理使用内容请搜索盛行IT以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

jdk动态代理实现的接口,jdk静态代理和动态代理

目录

前言

二、cglib静态代理

三、spring中代理的使用

总结

相关文章阅读