GOF23设计模式-结构型模式2-代理模式

「爱情、让人受尽委屈。」 2021-11-22 11:14 425阅读 0赞

### 设计模式GOF23-代理模式 ###

*  代理模式（Proxy Pattern）
 *   *  核心作用
     *  核心角色
     *  应用场景
     *  分类
     *  静态代理（Static Proxy）示例
     *  动态代理（Dynamic Proxy）示例
     *   *  动态代理 VS 静态代理 的优点
         *  JDK自带的动态代理
     *  开发框架中的应用场景

# 代理模式（Proxy Pattern） #

## 核心作用 ##

*  通过代理控制对对象的访问：可以详细控制访问某个（类）对象的方法，在调用这个方法前做前置处理，在方法后做后置处理。（即AOP的微观实现）
 *  AOP（Aspect Oriented Programming 面向切面编程）的核心机制。

高琪老师用一张明星唱歌的图来具体说明：客户要求周杰伦唱歌，可以有这么几个步骤：面谈–合同起草 – 签字收预付款 – 安排机票和车辆 – **唱歌** \--收尾款。然而，除了唱歌这个动作除了他自己做并且有可能每次都不一样外，其他的步骤都是统一的，要是每年就唱这么一次歌，这些动作他一个人可以完成，但要是唱的次数多了呢，这些重复的动作就浪费了很多时间，在我们的代码中，这些重复的动作就是重复的代码，每个明星都一样，所以，除了唱歌之外的动作是不是可以找个代理人来做呢？明星就只负责唱歌，而客户就跟代理人商量就可以了，并且一个代理人可以为多个明星代理这些动作。在代码中我们叫它为代理类，用来解决除了核心业务的一些其他辅助代码，但是又不得不做，当客户端客户端直接调用代理类就能完成真实的功能。 ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2thbmd4aW5nanVu_size_16_color_FFFFFF_t_70]

## 核心角色 ##

*  抽象角色：  
    \-定义代理角色和真实角色的公共对外方法。
 *  真实角色：  
    \-实现抽象角色，定义真实角色所需要实现的业务逻辑，供代理角色调用。  
    \-关注真正的业务逻辑。
 *  代理角色：  
    \-实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的方法。  
    \-将统一的流程控制放到代理角色中处理。  
    用类图表示如下：  
    ![在这里插入图片描述][20190724220154293.PNG]

## 应用场景 ##

*  安全代理：屏蔽对真实角色的直接访问。
 *  远程调用：通过代理类来处理远程方法的调用（RMI）。
 *  延迟加载：先加载轻量级的代理对象，真正需要时在加载真实的对象
 *  … … 几乎所有的框架里面都有代理模式

## 分类 ##

*  静态代理（静态定义代理类）
 *  动态代理（动态生成代理类）  
    \-JDK自带的动态代理  
    \-Javaassist字节码操作库实现  
    \-CGLIB  
    \-ASM（底层使用指令，可维护性较差）

## 静态代理（Static Proxy）示例 ##

1.  首先创建一个明星接口，定义面谈、签合同、订票、唱歌、收尾款等方法。

/**
     * User：tumbler
     * Desc：静态代理--明星接口
     *       面谈，签合同，订票，唱歌，收尾款等方法
     */
    public interface Star {
        void confer();
        void signContract();
        void bookTicket();
        void sing();
        void collectMoney();
    }

1.  定义真实角色，实现明星接口，重写方法。

/**
     * User：tumbler
     * Desc：静态代理--真实角色
     */
    public class RealStar implements Star{
        @Override
        public void confer() {
            System.out.println("RealStar.真实角色面谈");
        }
    
        @Override
        public void signContract() {
            System.out.println("RealStar.真实角色签合同");
        }
    
        @Override
        public void bookTicket() {
            System.out.println("RealStar.真实角色订票");
        }
    
        @Override
        public void sing() {
            System.out.println("RealStar.真实角色唱歌");
        }
    
        @Override
        public void collectMoney() {
            System.out.println("RealStar.真实角色收尾款");
        }
    }

1.  定义代理角色，实现明星接口，重写方法，加入要代理的真实角色属性，然后代理调用真实角色的唱歌方法取唱歌，因为代理可以干其他的事，但是他不能唱歌，否则明星就失业了。

/**
     * User：tumbler
     * Desc：静态代理--代理角色
     */
    public class ProxyStar implements Star{
        private Star star;  //被代理的真实对象
        public ProxyStar(Star star){
            this.star = star;
        }
        @Override
        public void confer() {
            System.out.println("ProxyStar.代理角色面谈");
        }
        @Override
        public void signContract() {
            System.out.println("ProxyStar.代理角色面谈");
        }
        @Override
        public void bookTicket() {
            System.out.println("ProxyStar.代理角色面谈");
        }
    
        /**
         * 代理角色什么都能干，但就是不能唱歌，要是歌也被代唱了，那真实角色就完蛋了
         * 所以这里调用真实角色唱歌
         */
        @Override
        public void sing() {
            star.sing();
        }
        @Override
        public void collectMoney() {
            System.out.println("ProxyStar.代理角色面谈");
        }
    }

1.  定义客户端测试，客户端只跟代理打交道，代理又去调用真实角色去唱歌，避免了与真实角色的直接接触，并且完成了所有流程。

/**
     * User：tumbler
     * Desc：静态代理--客户端
     */
    public class Client {
        public static void main(String[] args) {
            Star real = new RealStar();
            Star proxy = new ProxyStar(real);
    
            proxy.confer();
            proxy.signContract();
            proxy.bookTicket();
            proxy.sing();  //客户要求代理，代理找真实角色
            proxy.collectMoney();
        }
    }

运行结果：

ProxyStar.代理角色面谈
    ProxyStar.代理角色面谈
    ProxyStar.代理角色面谈
    RealStar.真实角色唱歌       // 真实角色唱歌
    ProxyStar.代理角色面谈

*  UML图：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2thbmd4aW5nanVu_size_16_color_FFFFFF_t_70 1]

## 动态代理（Dynamic Proxy）示例 ##

### 动态代理 VS 静态代理 的优点 ###

*  抽象角色（接口）中申明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，有利于灵活和统一的处理更多的方法。

### JDK自带的动态代理 ###

*  java.lang.reflect.Proxy : 动态生成代理类和对象
 *  java.lang.reflect.InvocationHandler : 处理器接口  
    \-可以通过invoke方法实现对真实角色的代理访问  
    \-每次通过Proxy生成代理类对象时都要指定对应的处理器

1.  创建抽象接口Star，提供面谈、签合同、订票、唱歌、收尾款等方法

/**
     * User：tumbler
     * Desc：动态代理--明星接口
     *       面谈，签合同，订票，唱歌，收尾款等方法
     */
    public interface Star {
        void confer();
        void signContract();
        void bookTicket();
        void sing();
        void collectMoney();
    }

1.  创建真实角色，实现抽象角色，重写方法

/**
     * User：tumbler
     * Desc：动态代理--真实角色
     */
    public class RealStar implements Star {
        @Override
        public void confer() {
            System.out.println("RealStar.真实角色面谈");
        }
    
        @Override
        public void signContract() {
            System.out.println("RealStar.真实角色签合同");
        }
    
        @Override
        public void bookTicket() {
            System.out.println("RealStar.真实角色订票");
        }
    
        @Override
        public void sing() {
            System.out.println("RealStar.真实角色唱歌");
        }
    
        @Override
        public void collectMoney() {
            System.out.println("RealStar.真实角色收尾款");
        }
    }

1.  定义处理器StarHandler，实现InvocationHandler接口，重写invoke方法，将真实角色传入，自动生成代理角色

/**
     * User：tumbler
     * Desc：动态代理--处理器
     */
    public class StarHandler implements InvocationHandler {
        Star realStar;
        public StarHandler(Star realStar) {
            this.realStar = realStar;
        }
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object object = null;
            System.out.println("真正角色执行前...");
            System.out.println("这里可以将需要统一处理的事情（面谈、签合同、订票）放到单独的类或方法取调用");
            if ("sing".equals(method.getName())){
                object = method.invoke(realStar, args);
            }
            System.out.println("真正方法执行后...");
            System.out.println("这里统一做后置处理，例如收尾款");
            return object;
        }
    }

1.  定义客户端测试

/**
     * User：tumbler
     * Desc：动态代理--客户端测试
     */
    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();
        }
    }

运行结果：

真正角色执行前...
    这里可以将需要统一处理的事情（面谈、签合同、订票）放到单独的类或方法取调用
    RealStar.真实角色唱歌
    真正方法执行后...
    这里统一做后置处理，例如收尾款

可以看出，当动态生成代理类后，其实调用代理类的方法后，都走了一遍invoke方法，统一添加了前置或者后置的一些操作，从而做到统一处理。

*  UML图

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2thbmd4aW5nanVu_size_16_color_FFFFFF_t_70 2]

## 开发框架中的应用场景 ##

*  Struts2中的拦截器的实现
 *  数据库连接池关闭处理
 *  Hibernate中延迟加载的实现
 *  Mybatis中实现拦截器插件
 *  AspectJ的实现
 *  Spring中AOP的实现  
    \-日志拦截  
    \-声明式事务的处理
 *  web service
 *  RMI远程方法调用

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2thbmd4aW5nanVu_size_16_color_FFFFFF_t_70]: /images/20211122/3ad8b8f175a54aff98bae7164c47e1ad.png
[20190724220154293.PNG]: /images/20211122/46a18da5279d4d97b4281d98a9914fa8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2thbmd4aW5nanVu_size_16_color_FFFFFF_t_70 1]: /images/20211122/98c4c41ea15946da8a2a91eebbc90e18.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2thbmd4aW5nanVu_size_16_color_FFFFFF_t_70 2]: /images/20211122/fe2639d279d84538887f76192fdfc748.png