GOF23设计模式之代理模式（proxy）

一、代理模式概述

　　1、代理模式的核心作用

　　　　（1）通过代理，控制对象的访问；

　　　　（2）可以详细的控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（AOP的微实现）

　　　　　　  代理模式是 AOP（Aspect Oriented Programming 面向切面编程）的核心实现机制。

　　2、代理模式的核心角色

　　　　（1）抽象角色

　　　　　　定义代理角色和真实角色的公共对外方法。

　　　　（2）真实角色

　　　　　　实现抽象角色，定义真实角色所需要实现的业务逻辑，供代理角色调用。

　　　　　　关注真正的业务逻辑。

　　　　（3）代理角色

　　　　　　实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑辅方法来实现抽象方法，并附加自己的操作。

　　　　  将统一的流程控制放在代理角色中处理！

　　3、代理模式的使用场景

　　　　（1）安全代理： 屏蔽对真实角色的访问；

　　　　（2）通过代理类处理远程方法调用（RMI Remote Method Invocation 远程方法调用）；

　　　　（3）延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象。

　　4、代理模式的分类

　　　　（1）静态代理（静态定义代理类）

　　　　（2）动态代理（动态生成代理类）

　　　　　　① JDK自带的动态代理

　　　　　　② javassist字节码操作库实现

　　　　　　③ CGLIB

　　　　　　　 CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。

　　　　　　　 通常可以使用Java的动态代理创建代理，但当要代理的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择。

　　　　　　④ ASM底层使用指令，可维护性较差

　　　　　　　 ASM是一个java字节码操纵框架，它能被用来动态生成类或者增强既有类的功能。

二、代理模式之静态代理

　　示例代码场景：周杰伦开演唱会时，面谈、签合同、订票等操作都是由周杰伦的经纪人来完成，唱歌部分由他本人完成，最后收款也是由经纪人来完成。

　　（1）创建抽象角色

 /**
  * 抽象角色
  * @author CL
  *
  */
 public interface Star {
     /**
      * 面谈
      */
     void confer();
     /**
      * 签合同
      */
     void signConstract();
     /**
      * 订票
      */
     void bookTicket();
     /**
      * 唱歌
      */
     void sing();
     /**
      * 收款
      */
     void collectMoney();
 }

　　（2）定义真实角色

 /**
  * 真实身份（相当于例子中的周杰伦本人）
  * @author CL
  *
  */
 public class RealStar implements Star {

     @Override
     public void confer() {
         System.out.println("周杰伦去面谈");
     }

     @Override
     public void signConstract() {
         System.out.println("周杰伦去签合同");
     }

     @Override
     public void bookTicket() {
         System.out.println("周杰伦去订票");
     }

     @Override
     public void sing() {
         System.out.println("周杰伦去唱歌");
     }

     @Override
     public void collectMoney() {
         System.out.println("周杰伦去收款");
     }

 }

　　（3）定义代理角色

 /**
  * 代理身份（相当于例子中的周杰伦的经纪人）
  * @author CL
  *
  */
 public class ProxyStar implements Star {
     private Star star;

     public ProxyStar(Star star) {
         this.star = star;
     }

     @Override
     public void confer() {
         System.out.println("经纪人去面谈");
     }

     @Override
     public void signConstract() {
         System.out.println("经纪人去签合同");
     }

     @Override
     public void bookTicket() {
         System.out.println("经纪人去订票");
     }

     @Override
     public void sing() {
         star.sing();
     }

     @Override
     public void collectMoney() {
         System.out.println("经纪人去收款");
     }

 }

　　（4）测试

 /**
  * 客户端
  *     只和经纪人联系
  * @author CL
  *
  */
 public class Client {

     public static void main(String[] args) {
         Star real = new RealStar();
         Star proxy = new ProxyStar(real);

         //面谈
         proxy.confer();
         //签合同
         proxy.signConstract();
         //订票
         proxy.bookTicket();
         //唱歌
         proxy.sing();
         //收款
         proxy.collectMoney();
     }
 }

　　控制台输出：

经纪人去面谈
经纪人去签合同
经纪人去订票
周杰伦去唱歌
经纪人收款

三、代理模式之动态代理

　　JDK自带的动态代理：

　　　　① 在客户端，java.lang.reflect.Proxy

　　　　　作用：动态生成代理类和对象

　　　　② 实现java.lang.reflect.InvocationHandler(处理器接口)

　　　　　可以通过invoke方法实现对真实角色的代理访问

　　　　　每次通过Proxy生成代理类对象时都要指定对应的处理器对象

　　（1）创建抽象角色

 public interface Star {
     /**
      * 面谈
      */
     void confer();
     /**
      * 签合同
      */
     void signConstract();
     /**
      * 订票
      */
     void bookTicket();
     /**
      * 唱歌
      */
     void sing();
     /**
      * 收款
      */
     void collectMoney();
 }

　　（2）创建真实角色

 /**
  * 真实身份（相当于例子中的周杰伦本人）
  * @author CL
  *
  */
 public class RealStar implements Star {

     @Override
     public void confer() {
         System.out.println("周杰伦去面谈");
     }

     @Override
     public void signConstract() {
         System.out.println("周杰伦去签合同");
     }

     @Override
     public void bookTicket() {
         System.out.println("周杰伦去订票");
     }

     @Override
     public void sing() {
         System.out.println("周杰伦去唱歌");
     }

     @Override
     public void collectMoney() {
         System.out.println("周杰伦去收款");
     }

 }

　　（3）创建代理角色的处理器

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

 /**
  * 代理角色的处理类
  * jdk自带的动态代理
  * @author CL
  *
  */
 public class StarHandler implements InvocationHandler {
     private Star realStar;

     public StarHandler(Star realStar) {
         this.realStar = realStar;
     }

     //通过invoke方法实现对真实角色的代理访问
     @Override
     public Object invoke(Object proxy, Method method, Object[] args)
             throws Throwable {
         Object obj = null;

         System.out.print("在执行真实角色的方法之前的处理，比如-->");
         System.out.println("面谈，签合同，订票");

         if (method.getName().equals("sing")) {
             obj = method.invoke(realStar, args);
         }

         System.out.print("在执行真实角色的方法之后的处理，比如-->");
         System.out.println("收款");

         return obj;
     }

 }

　　（4）测试

 import java.lang.reflect.Proxy;

 /**
  * 测试JDK自带的动态代理
  * @author CL
  *
  */
 public class Client {

     public static void main(String[] args) {
         Star realStar = new RealStar();

         StarHandler handler = new StarHandler(realStar);

         Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Star.class}, handler);

         proxy.sing();
     }
 }

　　控制台输出：

在执行真实角色的方法之前的处理，比如-->面谈，签合同，订票
周杰伦去唱歌
在执行真实角色的方法之后的处理，比如-->收款