java 动态代理模式（jdk和cglib）

 package proxy.dynamicproxy;

 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;

 /**
  * 需要实现InvocationHandler接口，内部维护一个实际类实例
  *
  */
 public class JdkProxyHandler implements InvocationHandler {

     private Object realObject;

     public Object proxy(Object realObject){
         this.realObject = realObject;
         return Proxy.newProxyInstance(this.realObject.getClass().getClassLoader(),
                 this.realObject.getClass().getInterfaces(), this);
     }

     /**
      *
      * @param proxy 动态生成的代理类实例
      * @param method 方法实例
      * @param args 方法参数
      * @return
      * @throws Throwable
      */
     @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         System.out.println("我是代理人：大明星唱歌开始前，我先宣传一下：巴拉巴拉。。。");

         // 调用实际类的方法，并传入参数，内部是反射机制
         Object ret = method.invoke(this.realObject, args);

         System.out.println("我是代理人：大明星唱歌完毕了，我来总结一下：巴拉巴拉。。。");

         return ret;
     }
 }

 package proxy.dynamicproxy;

 import net.sf.cglib.proxy.Enhancer;
 import net.sf.cglib.proxy.MethodInterceptor;
 import net.sf.cglib.proxy.MethodProxy;

 import java.lang.reflect.Method;

 /**
  * 需要实现MethodInterceptor接口
  * cglib相关依赖：
  * ant-1.6.2.jar
  * asm-3.1.jar
  * asm-util-3.1.jar
  * cglib-2.2.2.jar
  */
 public class CglibProxyHandler implements MethodInterceptor {

     public Object proxy(Object realObject){

         // 使用字节码增强器 四个固定步骤：
         // 1、new字节码增强器
         // 2、设置当前类实例为回调
         // 3、将实际类实例设置为父类
         // 4、创建一个代理类
         Enhancer enhancer = new Enhancer();
         enhancer.setCallback(this);
         enhancer.setSuperclass(realObject.getClass());
         // 这里会生成代理类、代理类的FastClass辅助类、实际类的FastClass辅助类
         // 辅助类为代理类和实际类的每个方法生成一个唯一的id
         // 用于在调用intercept方法时，通过唯一id就可以调用对应的方法
         // 不再走反射机制，提高性能
         return enhancer.create();
     }

     /**
      *
      * @param o 代理类的实例
      * @param method 方法实例
      * @param objects 方法参数
      * @param methodProxy 方法代理
      * @return
      * @throws Throwable
      */
     @Override
     public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

         System.out.println("我是代理人：大明星唱歌开始前，我先宣传一下：巴拉巴拉。。。");

         // 这里如果使用 method.invoke方法，就等同于走了反射机制去调用方法，性能不高
         // 而且还需要另外维护实际类实例
         // Object ret = method.invoke(this.realObject, objects);

         Object ret = methodProxy.invokeSuper(o, objects);

         System.out.println("我是代理人：大明星唱歌完毕了，我来总结一下：巴拉巴拉。。。");

         return ret;
     }
 }

 package proxy.dynamicproxy;

 import net.sf.cglib.core.DebuggingClassWriter;
 import proxy.staticproxy.IStar;
 import proxy.staticproxy.RealStar;

 public class Test {
     public static void main(String[] args) {

         /**
          * 还是以“代理人”和“大明星”为例
          * jdk动态代理：适用于大明星实现某接口的情况，且只能用于实现接口的情况
          *      不能用于未实现任何接口的类，因为生成的动态代理类要继承自Proxy、同时实现大明星接口。
          * cglib动态代理：适用于任何类。它是采用动态代理类直接继承大明星类的方式，将大明星当作父类
          *      覆写大明星类的所有方法（除final修饰的方法，wait方法，notify方法）
          *
          * 优缺点：
          * jdk方式，只能针对接口，底层直接写字节码的方式生成代理类，所以生成代理类速度快
          *      但是代理类执行方法时，通过反射的方式去执行，速度不如cglib方式
          * cglib方式，可以适用于任何类，底层使用ASM框架生成字节码，因为采用FastClass机制
          *      在生成代理类的同时还要生成代理类和大明星类的对应FastClass类（辅助类）
          *      这两个辅助类的作用是：对应FastClass辅助类会为代理类和大明星类的每一个方法
          *      （除final修饰的方法，wait方法，notify方法）生成唯一id，这样在后面的调用方法时
          *      不再通过反射去执行逻辑，而是直接根据id找到对应的方法去执行，提高性能，但相对的，生成字节码速度较慢
          */
         boolean isUseJdkProxy = false;

         if (isUseJdkProxy) {
             System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

             IStar star = (IStar) new JdkProxyHandler().proxy(new RealStar());
             star.sing();
         }
         else {

             System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,
                     "C:\\Users\\Administrator\\IdeaProjects\\untitled\\cglibClass");

             IStar star = (IStar) new CglibProxyHandler().proxy(new RealStar());

             // 这一步里面的具体流程：
             // 动态代理类的sing方法 --> CglibProxyHandler的intercept方法
             //  --> 实际类执行前的行为代理 --> MethodProxy.invokeSuper方法
             //  --> 根据唯一id在FastClass里找到对应的实际方法
             //  --> 代理类的FastClass内部：让代理类调用实际方法
             //  --> 代理类的实际方法内部一般就是直接调用父类(被代理类)的方法
             //  --> 返回父类方法的返回值
             star.sing();

         }
     }
 }