java动态代理与cglib

转载自：http://langyu.iteye.com/blog/410071

              http://www.cnblogs.com/xiaoluo501395377/p/3383130.html

 

Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：

    1. InvocationHandler：该接口中仅定义了一个invoke方法。每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。

   1: public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{...}

    第一个参数obj一般是指要代理的类，method是被代理的方法，args为该方法的参数数组。这个抽象方法在代理类中动态实现。

    2． Proxy：该类的作用就是用来动态创建一个代理对象的类，其中主要包含以下方法：

   1: public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) throws IllegalArgumentException{…}

   2: //获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组.

   1: public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException{…}

   2: //返回代理类的一个实例，返回后的代理类可以当作被代理类使用.

    loader: 一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载。

    interfaces: 一个Interface对象的数组，表示的是要给需要代理的对象提供一组什么接口，如果提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样就能调用这组接口中的方法了。

    h: 一个InvocationHandler对象，表示的是当这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上。

    Proxy.newProxyInstance (ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)做了以下几件事.

    (1)根据参数loader和interfaces调用getProxyClass(loader, interfaces)创建代理类$Proxy. $Proxy0类实现了interfaces的接口,并继承了Proxy类.

    (2)实例化$Proxy0并在构造方法中把loader传过去, 接着$Proxy0调用父类Proxy的构造器,为h赋值。接着把得到的$Proxy0实例强制转换成代理类. 当执行代理类的方法时,就调用了$Proxy0类中的方法.在执行代理类方法中,调用父类Proxy中的h的invoke()方法.即InvocationHandler.invoke()。

示例：

   1: package com.zero;

   2:  

   3: public interface IHello {

   4:     void say();

   5: }

   1: package com.zero;

   2:  

   3: public class HelloImpl implements IHello {

   4:  

   5:     @Override

   6:     public void say() {

   7:         // TODO Auto-generated method stub

   8:         System.out.println("Say hello!");

   9:     }

  10: }

   1: package com.zero;

   2:  

   3: import java.lang.reflect.InvocationHandler;

   4: import java.lang.reflect.Method;

   5:  

   6: public class JDKProxyHandler implements InvocationHandler {

   7:     // 这个就是我们要代理的真实对象

   8:     private Object realObject;

   9:  

  10:     // 构造方法，给我们要代理的真实对象赋初值

  11:     public JDKProxyHandler(Object target) {

  12:         this.realObject = target;

  13:     }

  14:  

  15:     @Override

  16:     public Object invoke(Object proxy, Method method, Object[] args)

  17:             throws Throwable {

  18:         // TODO Auto-generated method stub

  19:         System.out.println("jdk...invoke() begin");

  20:         System.out.println(method);

  21:         Object result = method.invoke(realObject, args);

  22:         System.out.println("jdk...invoke() end");

  23:         return result;

  24:     }

  25: }

   1: package com.zero;

   2:  

   3: import java.lang.reflect.Proxy;

   4:  

   5: public class JDKProxyTest {

   6:  

   7:     public static void main(String[] args) {

   8:         // TODO Auto-generated method stub

   9:         HelloImpl impl = new HelloImpl();

  10:         // 这里把handler与impl新生成的代理类相关联

  11:         JDKProxyHandler handler = new JDKProxyHandler(impl);

  12:          // 获得代理类($Proxy0 extends Proxy implements IHello)的实例.

  13:         IHello hello = (IHello) Proxy.newProxyInstance(impl.getClass()

  14:                 .getClassLoader(), impl.getClass().getInterfaces(), handler);

  15:         // 这里无论访问哪个方法，都是会把请求转发到handler.invoke

  16:         hello.say();

  17:         System.out.println(hello.getClass());

  18: //class com.sun.proxy.$Proxy0

  19:     }

  20: }

    JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，它的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

示例：

   1: package com.zero;

   2:  

   3: import java.lang.reflect.Method;

   4:  

   5: import org.springframework.cglib.proxy.Enhancer;

   6: import org.springframework.cglib.proxy.MethodInterceptor;

   7: import org.springframework.cglib.proxy.MethodProxy;

   8:  

   9: public class CGlibProxyHander implements MethodInterceptor {

  10:     private Object target;

  11:  

  12:     // target不必须使用接口

  13:     public Object createProxyInstance(Object target) {

  14:         this.target = target;

  15:         Enhancer enhancer = new Enhancer();

  16:         // 实际上是继承了目标类，覆盖目标类所有非final方法，再基础上添加新的代码

  17:         // 使用Enhancer可以对任意类生成代理类，

  18:         // 只要enhancer.setSuperclass(this.target.getClass());

  19:         // 其实质是代理类是目标类的子类。

  20:         enhancer.setSuperclass(this.target.getClass());

  21:         enhancer.setCallback(this);

  22:         return enhancer.create();

  23:     }

  24:  

  25:     // 从参数构成上，intercept的输入参数比invoke多1个，其实前3个参数对象的含义与invoke的含义是相同的

  26:     // 第一个参数表示调用方法来自哪个对象；

  27:     // 第二个参数表示调用方法的Method对象；

  28:     // 第三个参数表示此次调用的输入参数列表；

  29:     // 多出来的参数是MethodProxy 类型的，它应该是cglib生成用来代替Method对象的一个对象，

  30:     // 使用MethodProxy比调用JDK自身的Method直接执行方法效率会有提升

  31:     @Override

  32:     public Object intercept(Object object, Method method, Object[] args,

  33:             MethodProxy methodProxy) throws Throwable {

  34:         Object result = null;

  35:         System.out.println("CGlib代理 " + method.getName() + "()方法");

  36:         result = methodProxy.invoke(this.target, args);

  37:         return result;

  38:     }

  39: }

   1: package com.zero;

   2:  

   3: import java.lang.reflect.Proxy;

   4:  

   5: public class CGlibProxyTest {

   6:  

   7:     public static void main(String[] args) {

   8:         // TODO Auto-generated method stub

   9:         HelloImpl impl = new HelloImpl();

  10:         CGlibProxyHander hander = new CGlibProxyHander();

  11:         

  12:         IHello hello = (IHello) hander.createProxyInstance(impl);

  13:         hello.say();

  14:         System.out.println(hello.getClass());

  15: // class com.sun.proxy.$Proxy0

  16:     }

  17: }