Java中的反射与代理（2）

在经典的GoF设计模式中，有一种模式叫做代理模式，好比以前洋务运动的时候所说的「买办」，还有现在咱们经常听到的「代理人」战争中的「代理」，都是同一个意思——代替某人打理。

例如，很多北漂都找中介或者二房东租过房子，还有倒卖iPhone的黄牛党，对于租房的房客和房东、买iPhone的消费者和苹果公司来说，这些中介或者黄牛，就是对方的代理人，因为他们（买家或卖家）根本不关心谁在和自己交易，只要实现交易即可，而且也免去了一个个对接的麻烦，就像这样：

这个是最普通的代理，也称为「静态」代理，如果用代码来描述，就是：

/**

 * 需要代理的行为

 */

public interface Renting {

   // 租房

   public void renthouse();

}

/**

 * 买方行为

 */

public class Consumer implements Renting {

   @Override

   public void renthouse() {

      System.out.println("租客租房");

   }

}

/**

 * 代理实现

 */

public class RentingProxy implements Renting {

   private Renting renting;

   public RentingProxy(Renting renting) {

      this.renting = renting;

   }

   @Override

   public void renthouse() {

      System.out.println("代理方法前置：租房前看房");

      renting.renthouse();

      System.out.println("代理方法后置：满意签合同");

   }

   public static void main(String[] args) {

      Consumer consumer = new Consumer();

      consumer.renthouse();

      System.out.println("===================");

      Renting proxy = new RentingProxy(consumer);

      proxy.renthouse();

   }

}

这样就完事了。

然鹅，现在国家下了一道文件，要让租房市场更规范，不仅租前要看房，租后要签合同，而且还需要中介公司在看房时提供资质证明。

这下麻烦了。

因为之前代码实现的时候，只考虑到了当前这一家公司的需求，并且把功能写死了（System.out.println("代理方法前置：租房前看房");这段代码代替的是实际需要执行的功能）。

比较直接的想法是，给每个类都写一个封装类，然后引用已有类，在代理对象的方法内调用被代理类的方法。具体来说，就是这么干：

/**

 * 代理的代理

 *

 * @author 湘王

 */

public class Proxy {

    private RentingProxy target;

    public Proxy(RentingProxy target) {

        this.target = target;

    }

    public void zizhi() {

        System.out.println("展示资质");

        target.renthouse();

    }

    public static void main(String[] args) {

        Consumer consumer = new Consumer();

        RentingProxy rentingProxy = new RentingProxy(consumer);

        Proxy proxy = new Proxy(rentingProxy);

        proxy.zizhi();

    }

}

可以看到，这种方式的问题有两个：

1、实现起来比较别扭，不够优雅，而且非常丑陋，包了一层又一层；

2、即使这么干行得通，当前公司的问题倒是解决了。但是如果市场上有10000家公司，是不是要改10000次代码呢？显然是NO！

这个时候，就需要通过「动态代理」来实现了——这也是反射最有用的地方。

更形象地说，动态代理好比一家万能中介公司，不管是租房。还是买票，它都可以实现，只是流程和服务不同而已。而具体的流程和服务，完全可以在有了具体业务对象后确定，而且服务还能动态增加和减少，是不是特别棒？！

这么的好处是：

1、符合开闭原则：对扩展开放，对修改关闭

2、实现无侵入式代码扩展，比如可以在调用时被代理类的方法时定义一些前置或者后置操作（如增加展示资质环节）

而且也做非常「优雅」：

具体来说，动态代理的思路就是：

1、从Class和ClassLoader着手，通过反射得到被代理类的Class对象

2、然后据此创建实例，从而调用该实例的方法（之前写反射代码的时候就是这么干的）

动态代理的实现也有两种思路：

1、JDK，Java原生支持的动态代理方式，实现起来比较简单

2、CGLIB，这也是Spring框架底层使用的动态代理，效率更高且更神奇

先用Java 8的默认接口改造：

/**

 * 需要代理的行为

 */

public interface Renting {

   // 租房

   default public void renthouse() {

      System.out.println("租客租房");

   };

}

再来用JDK的动态代理实现之前的功能：

/**

 * JDK动态代理实现

 */

public class DynamicProxy {

   // JDK动态代理实现

   private static Object getProxyObject(final Object target) {

      return Proxy.newProxyInstance(target.getClass().getClassLoader(),

            // 实现接口InvocationHandler

            target.getClass().getInterfaces(), new InvocationHandler() {

               @Override

               public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                  // 这里可以实现前置方法

                  System.out.println("代理方法前置1：租房前看中介资质");

                  System.out.println("代理方法前置2：租房前看房");

                  if (null != args) {

                     for (Object arg : args) {

                        System.out.println(" - " + arg);

                     }

                  }

                  // 调用接口方法

                  Object result = method.invoke(target, args);

                  // 这里可以实现后置方法

                  System.out.println("代理方法后置：满意签合同");

                  return result;

               }

      });

   }

   public static void main(String[] args) {

      Consumer consumer = new Consumer();

      consumer.renthouse();

      System.out.println("===================");

      Renting logger = (Renting) getProxyObject(consumer);

      logger.renthouse();

   }

}

如果改用CGLIB实现，需要额外引入相关的jar包依赖asm-x.y.jar和cglib-x.y.z.jar（这里的x、y、z代表版本号，我这里用的是asm-2.7.jar和cglib-3.3.0.jar），我就给出代码好了（懒得引了，有兴趣的童鞋可以自己试试）：

/**

 * CGLIB动态代理实现

 */

public class CglibProxy {

   // CGLIB动态代理实现

   private static Object getCglibProxy(final Object target) {

      // 实现MethodInterceptor接口

      MethodInterceptor interceptor = new MethodInterceptor() {

         @Override

         public Object intercept(Object object, Method method, Object[] args, MethodProxy proxy) throws Throwable {

            // 这里可以实现前置方法

            System.out.println("代理方法前置1：租房前看中介资质");

            System.out.println("代理方法前置2：租房前看房");

            if (null != args) {

               for (Object arg : args) {

                  System.out.println(" - " + arg);

               }

            }

            // 调用接口方法

            Object result = method.invoke(target, args);

            // 这里可以实现后置方法

            System.out.println("代理方法后置：满意签合同");

            return result;

         }

      };

      // 增强代理对象

      Enhancer enhancer = new Enhancer();

      // 设置父类，因为CGLIB是针对指定的类生成一个子类，所以需要指定父类

      enhancer.setSuperclass(target.getClass());

      // 设置回调

      enhancer.setCallback(interceptor);

      // 创建并返回代理对象

      return enhancer.create();

   }

   public static void main(String[] args) {

      Consumer consumer = new Consumer();

      consumer.renthouse();

      System.out.println("===================");

      Renting logger = (Renting) getCglibProxy(consumer);

      logger.renthouse();

   }

}

巴特西

Java中的反射与代理（2）

最新文章

热门文章