代理模式_proxybuilder.方法如何使用-CSDN博客

有时候，我们不希望一个对象被外界直接访问，而是通过代理，从而来控制其中一些行为，这就是代理模式。
比如，世界杯前夕，很多厂商想趁着这个四年一次的足球狂欢节来推销一波自己的产品，这个时候，找明星代言是最直接有效的方式。作为当今足坛最炙手可热的大球星，里奥·梅西自然成为了首选，无数厂商想找梅西商量合作的事情，为自己的产品做广告代言。但是，再不夺得大力神杯就没机会了的梅西，每天都拼命的训练，自然没有时间和精力去跟这些良莠不齐、鱼目混杂的广告商去谈。于是，就让自己的经纪人代表自己去谈，好了就让自己随便拍个视频就好。就这样，经纪人全权负责，代表着梅西去和广告商谈了。最后觉得蒙牛的“我不是天生强大，而是天生要强”广告词很不错，就答应合作。拍广告的时候必须梅西亲自来，后面的还是经纪人负责到底。

梅西因为一些原因不希望广告商直接来跟自己谈合作，就让经纪人全权代表自己去做这些事情，这是代理模式的情形。

类图：

有没有觉得跟另外一个模式很像呢？不错，就是装饰者模式，它们的结构很相似。但是，目的不一样，装饰者主要是为了给目标对象提供额外的功能（增强），而代理模式主要是为了控制对目标对象的访问，虽然它们两者是相通的。

静态代理：代理对象和目标对象实现一个相同的接口，然后代理对象内部持有一个目标对象。因此，外部调用时，因为两者实现了同一个接口，所以就算使用了代理对象也察觉不到任何异常。实际上调用了代理对象的方法，而代理对象可以做任何处理，也可以调用目标对象的功能。缺点是，不够灵活：编译期就确定了给哪个对象做什么样的代理，不够通用：每一个目标对象需要创建一个代理类。

动态代理：运行时在内存中创建代理对象。

我就不分别做静态代理和动态代理的例子了。下面给大家写一个工具类：代理工具类。

功能：给工具类传入一个目标对象，然后传入执行方法时的处理逻辑（可选，默认只执行目标方法），还可以传入一个接口（可选），就可以得到一个代理对象。
实现：如果设置了接口class，就使用JDK的接口代理，否则使用CGLIB代理。
一、定义执行目标对象方法时处理逻辑的接口，因为是一个函数式接口，所以可以使用Lambda表达式简化使用方式。方法有三个参数，分别是代理对象、目标方法、方法参数

/**
* 执行处理逻辑的函数式接口
* @author z_hh
* @time 2018年8月7日
*/
@FunctionalInterface
public interface InvokeAction {

   /**
   * 执行目标方法时的处理逻辑
   * @param proxy 代理对象
   * @param method 目标方法
   * @param args 方法参数
   * @return Object
   * @throws Throwable
   */
   Object execute(Object proxy, Method method, Object[] args) throws Throwable;

}
二、定义创建代理类的Builder：此处使用了构建者设计模式，方便设置参数。根据是否传入接口的class，提供了JDK接口代理和CGLIB代理两种实现方式

/**
* 生成代理对象的Builder
* @author z_hh
* @time 2018年8月7日
*/
public class ProxyBuilder {

   /**
   * 构造方法私有化
   */
   private ProxyBuilder() {}

   /**
   * 被代理对象实现的接口（不为空使用JDK的代理，否则使用CGLIB代理），可选
   */
   private Class<?> interfaceClazz;

   /**
   * 被代理对象
   */
   private Object realObj;

   /**
   * 执行函数时的动作（默认调用目标方法，不做增强），可选
   */
   private InvokeAction action;

   /**
   * 构造器模式，链式调用设置属性
   * @return Builder
   */
   public static Builder builder() {
       return new Builder();
   }

   public static class Builder {
       private Class<?> interfaceClazz;
       private Object realObj;
       // 执行函数时的动作（默认调用目标方法，不做增强），可选
       private InvokeAction action = (Object obj, Method method, Object[] params) -> {
           return method.invoke(realObj, params);
       };

       /**
       * 设置被代理对象
       * @param realObj
       * @return Builder
       */
       public Builder realObj(Object realObj) {
           this.realObj = realObj;
           return this;
       }

       /**
       * 设置代理对象执行方法时的行为
       * @param realObj
       * @return Builder
       */
       public Builder action(InvokeAction action) {
           this.action = action;
           return this;
       }

       /**
       * 设置被代理对象的接口
       * @param interfaceClazz
       * @return Builder
       */
       public Builder interfaceClazz(Class<?> interfaceClazz) {
           this.interfaceClazz = interfaceClazz;
           return this;
       }

       /**
       * 创建代理对象
       * 如果设置了interfaceClazz，只能将返回值强转为接口的类型
       * 否则，可以将返回值强转为接口类型或者被代理者类型
       * @return object
       */
       public Object build() {
           ProxyBuilder proxyBuilder = new ProxyBuilder();
           // 不能为空
           proxyBuilder.realObj = Objects.requireNonNull(this.realObj, "被代理对象不能为空！");
           proxyBuilder.action = this.action;
           proxyBuilder.interfaceClazz = this.interfaceClazz;
           // 生成代理对象
           return proxyBuilder.build();
       }
   }

   private Object build() {
       // 使用CGLIB代理
       if (Objects.isNull(interfaceClazz)) {
           return buildByCglib();
       }
       // 使用JDK代理
       return buildByJdk();
   }

   private Object buildByJdk() {
       System.out.println(">>>>>>>>>>使用JDK创建代理对象<<<<<<<<<<");
       return Proxy.newProxyInstance(realObj.getClass().getClassLoader(),
               new Class[] {interfaceClazz},
               new InvocationHandler() {
                   @Override
                   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                       return action.execute(proxy, method, args);
                   }
               });
   }

   private Object buildByCglib() {
       System.out.println(">>>>>>>>>>使用CGLIB创建代理对象<<<<<<<<<<");
       Enhancer enhancer = new Enhancer();
       enhancer.setSuperclass(realObj.getClass());
       enhancer.setCallback(new MethodInterceptor() {
           @Override
           public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
               return action.execute(proxy, method, args);
           }
       });
       return enhancer.create();
   }

}
三、创建一个歌手的接口和一个实现类

/**
* 歌手
* @author z_hh
* @time 2018年8月7日
*/
public interface Singer {

   /**
   * 唱歌
   */
   void sing();

   /**
   * 跳舞
   */
   void dance();

   /**
   * 自我介绍
   * @return 介绍内容
   */
   String introduce();

}
/**
* 周杰伦
* @author z_hh
* @time 2018年8月7日
*/
public class Jay implements Singer {

   @Override
   public void sing() {
       System.out.println("周杰伦唱歌《等你下课》");

   }

   @Override
   public void dance() {
       System.out.println("周杰伦跳舞《极乐净土》");

   }

   @Override
   public String introduce() {
       return "大家好，我叫纠结伦";
   }

}
四、使用我们的ProxyBuilder创建Jay的代理对象：针对不同的方法做不同的处理

Jay jay = new Jay();
       Object proxy = ProxyBuilder.builder()
               .realObj(jay)
               .action((Object obj, Method method, Object[] params) -> {
                   String methodName = method.getName();
                   // 处理sing方法
                   if (Objects.equals(methodName, "sing")) {
                       // 前置
                       System.out.println("前置：哈哈哈，我是代理人，先交一百块钱，我让杰伦唱歌给你听！");
                       // 目标方法执行
                       Object result = method.invoke(jay, params);
                       // 后置
                       System.out.println("后置：歌唱完了，钱花的很值吧？！");
                       // 我们在InvokeAction定义的方法具有返回值
                       return result;
                   }
                   // 处理dance方法
                   if (Objects.equals(methodName, "dance")) {
                       // 前置
                       System.out.println("前置：嘿嘿嘿，我是代理人，杰伦开始跳舞啦！");
                       // 目标方法执行
                       return method.invoke(jay, params);
                   }
                   // 其它方法，不做增强
                   return method.invoke(jay, params);
               })
               .interfaceClazz(Singer.class)