一、***模式介绍

***模式：为其他对象提供一种***以便控制对这个对象的访问。

可以详细控制访问某个类（对象）的方法，在调用这个方法前作的前置处理（统一的流程代码放到***中处理）。调用这个方法后做后置处理。

例如：明星的经纪人，租房的中介等等都是***

***模式分类：

1.静态（静态定义类，我们自己静态定义的***类。比如我们自己定义一个明星的经纪人类）

2.动态（通过程序动态生成类，该***类不是我们自己定义的。而是由程序自动生成）比较重要！！

JDK自带的动态***

javaassist字节码操作库实现

CGLIB

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

静态***模式结构图：

静态***模式一般会有三个角色：

抽象角色：指***角色（经纪人）和真实角色（明星）对外提供的公共方法，一般为一个接口

真实角色：需要实现抽象角色接口，定义了真实角色所要实现的业务逻辑，以便供***角色调用。也就是真正的业务逻辑在此。

***角色：需要实现抽象角色接口，是真实角色的***，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。

将统一的流程控制都放到***角色中处理！

二、***模式代码实现

2.1 静态***模式

这里定义一个抽象角色接口（Star）、***角色实现（ProxyStar）、真实角色实现（RealStar）

抽象角色接口：提供了与明星合作的一系列流程

                            package         com.fz.proxy.staticProxy;       
                 
         /**       
                  * 抽象角色：提供***角色和真实角色对外提供的公共方法       
                  */       
         public         interface         Star {       
                     void         confer();        //面谈       
                     void         signContract();        //签合同       
                     void         bookTicket();        //订票       
                     void         sing();        //唱歌       
                     void         collectMoney();        //收尾款       
         }       
     
     

***角色实现类：***角色中***了真实角色所需要的操作（唱歌）

                            package         com.fz.proxy.staticProxy;       
                  
         /**       
                  * ***角色（明星经纪人）：       
                  */       
         public         class         ProxyStar         implements         Star{       
                     private         Star star;        //真实对象的引用（明星）       
                     @Override       
                     public         void         confer() {       
                         System.out.println(        "ProxyStar.confer()"        );       
                     }       
                     @Override       
                     public         void         signContract() {       
                         System.out.println(        "ProxyStar.signContract()"        );       
                     }       
                     @Override       
                     public         void         bookTicket() {       
                         System.out.println(        "ProxyStar.bookTicket()"        );       
                     }       
                     @Override       
                     public         void         sing() {       
                         star.sing();        //真实对象的操作（明星唱歌）       
                     }       
                     @Override       
                     public         void         collectMoney() {       
                         System.out.println(        "ProxyStar.collectMoney()"        );       
                     }       
                     public         ProxyStar(Star star) {        //通过构造器给真实角色赋值       
                         this        .star = star;       
                     }       
         }       
     
     

真实角色实现类：这里的真实角色中其实只做了一个唱歌的操作，这是真实角色真正的业务逻辑部分

                            package         com.fz.proxy.staticProxy;       
                 
         /**       
                  * 真实角色（明星艺人）：       
                  */       
         public         class         RealStar         implements         Star{       
                     @Override       
                     public         void         confer() {       
                         System.out.println(        "RealStar.confer()"        );       
                     }       
                     @Override       
                     public         void         signContract() {       
                         System.out.println(        "RealStar.signContract()"        );       
                     }       
                     @Override       
                     public         void         bookTicket() {       
                         System.out.println(        "RealStar.bookTicket()"        );       
                     }       
                     @Override       
                     public         void         sing() {       
                         System.out.println(        "张学友.sing()"        );        //真实角色的操作：真正的业务逻辑       
                     }       
                     @Override       
                     public         void         collectMoney() {       
                         System.out.println(        "RealStar.collectMoney()"        );       
                     }       
         }       
     
     

测试***类：

                            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.confer()

ProxyStar.signContract()

ProxyStar.bookTicket()

张学友.sing() //这里是真实角色的业务逻辑处理

ProxyStar.collectMoney()

以上代码UML图如下：

2.2 动态***代码实现

动态***是不需要定义***角色的，通过一个处理器来处理***角色的业务逻辑。