导读：java
一、JDK动态代理原理是什么？为何不支持类的代理？spring
二、JDK动态代理实例数组
三、CGLib代理原理是什么？框架
四、CGLib代理实例ide
五、JDK动态代理与CGLib代理的区别是什么？性能
六、总结测试
注：阅读本文以前能够先阅读：什么是代理模式？ 优化
1. JDK动态代理原理是什么？为何不支持类的代理？this
jdk动态代理图：spa
利用拦截器(拦截器必须实现InvocationHanlder)加上反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。是在程序运行的过程当中，根据被代理的接口来动态生成代理类的class文件，并加载运行的过程。
之因此只支持实现了接口的类的代理。从原理上讲是由于JVM动态生成的代理类有以下特性：
继承了Proxy类，实现了代理的接口，最终形式以下（HelloInterface为被代理类实现的接口）：
public final class $Proxy0 extends Proxy implements HelloInterface{ ....... }
然而因为java不能多继承，这里已经继承了Proxy类了，不能再继承其余的类，因此JDK的动态代理不支持对实现类的代理，只支持接口的代理。
从使用上讲，建立代理类时必须传入被代理类实现的接口。
1.1 详细介绍：
在java的动态代理机制中，有两个重要的类或接口，一个是 InvocationHandler(Interface)、另外一个则是 Proxy(Class)，这一个类和接口是实现咱们动态代理所必须用到的。
1.1.1 InvocationHandler
每个动态代理类都必需要实现InvocationHandler这个接口，而且每一个代理类的实例都关联了一个handler，当咱们经过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。
InvocationHandler这个接口的惟一一个方法 invoke 方法：
Object invoke(Object proxy, Method method, Object[] args) throws Throwable
这个方法一共接受三个参数，那么这三个参数分别表明以下：
- proxy: 指代JDK动态生成的最终代理对象
- method: 指代的是咱们所要调用真实对象的某个方法的Method对象
- args: 指代的是调用真实对象某个方法时接受的参数
1.1.2 Proxy
Proxy这个类的做用就是用来动态建立一个代理对象的类，它提供了许多的方法，可是咱们用的最多的就是 newProxyInstance 这个方法：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler) throws IllegalArgumentException
这个方法的做用就是获得一个动态的代理对象，其接收三个参数，咱们来看看这三个参数所表明的含义：
- loader: ClassLoader对象，定义了由哪一个ClassLoader来对生成的代理对象进行加载。
- interfaces: Interface对象的数组，表示的是我将要给我须要代理的对象提供一组什么接口，若是我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了。
- Handler：InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪个InvocationHandler对象上。
因此咱们所说的DynamicProxy（动态代理类）是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，而后该class就宣称它实现了这些 interface。这个DynamicProxy其实就是一个Proxy，它不会作实质性的工做，在生成它的实例时你必须提供一个handler，由它接管实际的工做。
2. JDK动态代理实例
2.1 建立接口类
public interface HelloInterface { void sayHello(); }
2.2 建立被代理类，实现接口
/** * 被代理类 */ public class HelloImpl implements HelloInterface{ @Override public void sayHello() { System.out.println("hello"); } }
2.3建立InvocationHandler实现类
/** * 每次生成动态代理类对象时都须要指定一个实现了InvocationHandler接口的调用处理器对象 */ public class ProxyHandler implements InvocationHandler{ private Object subject; // 这个就是咱们要代理的真实对象，也就是真正执行业务逻辑的类 public ProxyHandler(Object subject) {// 经过构造方法传入这个被代理对象 this.subject = subject; } /** *当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用 */ @Override public Object invoke(Object obj, Method method, Object[] objs) throws Throwable { Object result = null; System.out.println("能够在调用实际方法前作一些事情"); System.out.println("当前调用的方法是" + method.getName()); result = method.invoke(subject, objs);// 须要指定被代理对象和传入参数 System.out.println(method.getName() + "方法的返回值是" + result); System.out.println("能够在调用实际方法后作一些事情"); System.out.println("------------------------"); return result;// 返回method方法执行后的返回值 } }
2.4 测试
public class Mytest { public static void main(String[] args) { //第一步：建立被代理对象 HelloImpl hello = new HelloImpl(); //第二步：建立handler,传入真实对象 ProxyHandler handler = new ProxyHandler(hello); //第三步：建立代理对象，传入类加载器、接口、handler HelloInterface helloProxy = (HelloInterface) Proxy.newProxyInstance( HelloInterface.class.getClassLoader(), new Class[]{HelloInterface.class}, handler); //第四步：调用方法 helloProxy.sayHello(); } }
2.5 结果
能够在调用实际方法前作一些事情 当前调用的方法是sayHello hello sayHello方法的返回值是null 能够在调用实际方法后作一些事情 ------------------------
3. CGLib代理原理是什么？
CGLib采用了很是底层的字节码技术，其原理是经过字节码技术为一个类建立子类，并在子类中采用方法拦截的技术拦截全部父类方法的调用，顺势织入横切逻辑。（利用ASM开源包，对代理对象类的class文件加载进来，经过修改其字节码生成子类来处理）
3.1 CGLib核心类：
一、 net.sf.cglib.proxy.Enhancer：主要加强类，经过字节码技术动态建立委托类的子类实例；
Enhancer多是CGLIB中最经常使用的一个类，和Java1.3动态代理中引入的Proxy类差很少。和Proxy不一样的是，Enhancer既可以代理普通的class，也可以代理接口。Enhancer建立一个被代理对象的子类而且拦截全部的方法调用（包括从Object中继承的toString和hashCode方法）。Enhancer不可以拦截final方法，例如Object.getClass()方法，这是因为Java final方法语义决定的。基于一样的道理，Enhancer也不能对fianl类进行代理操做。这也是Hibernate为何不能持久化final class的缘由。
2、net.sf.cglib.proxy.MethodInterceptor：经常使用的方法拦截器接口，须要实现intercept方法，实现具体拦截处理；
public java.lang.Object intercept(java.lang.Object obj, java.lang.reflect.Method method, java.lang.Object[] args, MethodProxy proxy) throws java.lang.Throwable{}
- obj：动态生成的代理对象
- method ： 实际调用的方法
- args：调用方法入参
- proxy：
- net.sf.cglib.proxy.MethodProxy：java Method类的代理类，能够实现委托类对象的方法的调用；经常使用方法：methodProxy.invokeSuper(proxy, args)；在拦截方法内能够调用屡次
4. CGLib代理实例
4.1 建立被代理类
public class SayHello { public void say(){ System.out.println("hello"); } }
4.2 建立代理类
/** *代理类 */ public class ProxyCglib implements MethodInterceptor{ private Enhancer enhancer = new Enhancer(); public Object getProxy(Class clazz){ //设置须要建立子类的类 enhancer.setSuperclass(clazz); enhancer.setCallback(this); //经过字节码技术动态建立子类实例 return enhancer.create(); } //实现MethodInterceptor接口方法 public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("能够在调用实际方法前作一些事情"); //经过代理类调用父类中的方法 Object result = proxy.invokeSuper(obj, args); System.out.println("能够在调用实际方法后作一些事情"); return result; } }
4.3 测试
public class Mytest { public static void main(String[] args) { ProxyCglib proxy = new ProxyCglib(); //经过生成子类的方式建立代理类 SayHello proxyImp = (SayHello)proxy.getProxy(SayHello.class); proxyImp.say(); } }
4.4 结果
能够在调用实际方法前作一些事情 hello 能够在调用实际方法后作一些事情
5. JDK动态代理与CGLib代理的区别是什么？
5.1 原理区别：
java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。核心是实现InvocationHandler接口，使用invoke()方法进行面向切面的处理，调用相应的通知。
而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，经过修改其字节码生成子类来处理。核心是实现MethodInterceptor接口，使用intercept()方法进行面向切面的处理，调用相应的通知。
1、若是目标对象实现了接口，默认状况下会采用JDK的动态代理实现AOP
2、若是目标对象实现了接口，能够强制使用CGLIB实现AOP
3、若是目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换
5.2 性能区别：
1、CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，在jdk6以前比使用Java反射效率要高。惟一须要注意的是，CGLib不能对声明为final的方法进行代理，由于CGLib原理是动态生成被代理类的子类。
2、在jdk6、jdk7、jdk8逐步对JDK动态代理优化以后，在调用次数较少的状况下，JDK代理效率高于CGLIB代理效率，只有当进行大量调用的时候，jdk6和jdk7比CGLIB代理效率低一点，可是到jdk8的时候，jdk代理效率高于CGLIB代理。
5.3 各自局限：
1、JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理。
2、cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现加强，但由于采用的是继承，因此不能对final修饰的类进行代理。
6. 总结
扩展阅读：动态代理是基于什么原理？