设计模式之禅【门面模式】

Bertha 。 2022-06-02 10:51 213阅读 0赞

# 真刀实枪之门面模式 #

*  从投递信件说起
    
     *  写过纸质信件没，如果你是00后，那机会应该很少，不过没关系，先来看看步骤
        
        1.  写信的内容
        2.  写信封
        3.  把信放到信封
        4.  投递到信箱中进行邮递
     *  看下该过程的类图
        
         *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70][]
     *  趁热打铁，代码跟上
        
         *  ILetterProcess
            
                package com.peng.mm;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月26日
                 * @description
                 */
                public interface ILetterProcess {
                    // 写信的内容
                    public void writeContext(String context);
                
                    // 写信封
                    public void fillEnvelope(String address);
                
                    // 把信放到信封里
                    public void letterIntoEnvelope();
                
                    // 然后邮寄
                    public void sendLetter();
                }
         *  LetterProcess
            
                package com.peng.mm;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月26日
                 * @description
                 */
                public class LetterProcess implements ILetterProcess {
                    // 写信
                    @Override
                    public void writeContext(String context) {
                        System.out.println("填写信的内容：" + context);
                    }
                
                    // 填信封
                    @Override
                    public void fillEnvelope(String address) {
                        System.out.println("填写信封的地址和姓名：" + address);
                    }
                
                    // 把信放到信封中，并封好
                    @Override
                    public void letterIntoEnvelope() {
                        System.out.println("把信放到信封里！");
                    }
                
                    // 塞到邮箱中，邮递
                    @Override
                    public void sendLetter() {
                        System.out.println("邮递邮件~~");
                    }
                
                }
         *  Client
            
                package com.peng.mm;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月26日
                 * @description
                 */
                public class Client {
                
                    public static void main(String[] args) {
                        // 创建一个处理信件的过程
                        ILetterProcess process = new LetterProcess();
                        // 开始写信
                        process.writeContext("Hello:kungfu~peng,long long ago...");
                        // 写信封
                        process.fillEnvelope("ShanXi:kungfu~peng");
                        // 将信放到信封里
                        process.letterIntoEnvelope();
                        // 邮寄信件
                        process.sendLetter();
                    }
                
                }
         *  运行结果
            
                填写信的内容：Hello:kungfu~peng,long long ago...
                填写信封的地址和姓名：ShanXi:kungfu~peng
                把信放到信封里！
                邮递邮件~~
     *  回过头来看这个过程，它与高内聚的要求相差甚远，更不要说迪米特法则、接口隔离原则了。首先你得知道它的过程，否则一旦出错，它将夭折在其中的一步；还有就是信多了以后就会非常的麻烦。每封信都得来一遍这样的过程，还不得累死。。。
     *  现在邮局新开个业务，你只要把信件交给我，剩下的你就可以不用管了
        
         *  先来看看类图吧
            
             *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 1][]
         *  现代化邮局的代码
            
             *  ModenPostOffice
                
                    package com.peng.mm;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月26日
                     * @description
                     */
                    public class ModenPostOffice {
                        // 发送邮件的对象
                        private ILetterProcess process = new LetterProcess();
                    
                        // 写信，写封面，将信装进信封，发送为一体的过程
                        public void sendLetter(String context, String address) {
                            process.writeContext(context);
                            process.fillEnvelope(address);
                            process.letterIntoEnvelope();
                            process.sendLetter();
                        }
                    }
             *  Client
                
                    package com.peng.mm;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月26日
                     * @description
                     */
                    public class Client {
                    
                        public static void main(String[] args) {
                            ModenPostOffice mpo = new ModenPostOffice();
                            mpo.sendLetter("Kungfu~peng:hello", "ShanXi:kungfu~peng");
                        }
                    
                    }
     *  对于一个标准化的邮局，是不是还得安全检查
        
         *  先看类图
            
             *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 2][]
         *  动过的代码
            
             *  ModenPostOffice
                
                    package com.peng.mm;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月26日
                     * @description
                     */
                    public class ModenPostOffice {
                        // 发送邮件的对象
                        private ILetterProcess process = new LetterProcess();
                        // 检查信件的对象
                        private Police police = new Police();
                    
                        // 写信，写封面，将信装进信封，发送为一体的过程
                        public void sendLetter(String context, String address) {
                            process.writeContext(context);
                            process.fillEnvelope(address);
                            // 检查信件
                        police.checkLetter(process);
                            process.letterIntoEnvelope();
                            process.sendLetter();
                        }
                    }
             *  Police
                
                    package com.peng.mm;
                    
                    /**
                     * @author kungfu~peng
                     * @data 2017年11月26日
                     * @description
                     */
                    public class Police {
                        // 检查信件，检查无误后盖个戳--此信无病毒
                        public void checkLetter(ILetterProcess letterProcess) {
                            System.out.println("信封已经检查过了，此信无病毒！");
                        }
                    }
                
                 
             *  执行结果
                
                    填写信的内容：Kungfu~peng:hello
                    填写信封的地址和姓名：ShanXi:kungfu~peng
                    信封已经检查过了，此信无病毒！
                    把信放到信封里！
                    邮递邮件~~
         *  高层模块没有任何的改动，但是信件却已经被检查过了，这正是我们所设计的模式，不改变子系统对外暴露的接口、方法，只改变内部的处理逻辑，其他兄弟模块的调用产生了不同的结果--这就是门面模式

### 门面模式的定义 ###

*  Facade Pattern
 *  也叫做外观模式
 *  Provide a unified interface to a set of interfaces in a subsystem.Facade defines a higher-level interface that makes the subsystem easier to use.(要求一个子系统的外部与其内部的通讯必须通过一个统一的对象进行，门面模式提供一个高层次的接口，使得子系统更容易使用)
 *  门面模式注重“统一的对象”，也就是说 提供了一个访问子系统的接口，除了这个接口，不允许有任何访子系统的行为发生

### 通用类图 ###

*  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 3][]
 *  更简单的说，门面对象就是外界访问子系统内部的唯一通道，不管子系统是多么的杂乱无章，只要门面对象在，就可以做到“金玉其外，败絮其中”，也就是说该角色没有实际的业务逻辑，只是一个委托类
 *  Facade门面角色：客户端可以调用这个角色的方法
 *  subsystem子系统角色：可以同时有一个或者多个子系统，子系统并不知道门面的存在，对子系统而言，门面只是另外一个客户端而已
    
     *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 4][]

### 简单的写一下通用代码 ###

*  门面
    
     *  Facade
        
            package mm2;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月26日
             * @description
             */
            public class Facade {
                private ClassA a = new ClassA();
                private ClassB b = new ClassB();
                private ClassC c = new ClassC();
            
                public void execute(){
                    a.methodA();
                    b.methodB();
                    c.methodC();
                }
            
            }
 *  子系统
    
     *  ClassA
        
            package mm2;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月26日
             * @description
             */
            public class ClassA {
            
                public void methodA() {
                    System.out.println("执行子系统下A类的方法！");
                }
            
            }
     *  ClassB
        
            package mm2;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月26日
             * @description 
             */
            public class ClassB {
            
                public void methodB() {
                    System.out.println("执行子系统下B类的方法！");
                }
            
            }
     *  ClassC
        
            package mm2;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月26日
             * @description
             */
            public class ClassC {
            
                public void methodC() {
                    System.out.println("执行子系统下C类的方法！");
                }
            
            }
 *  场景
    
     *  Client
        
            package mm2;
            
            /**
             * @author kungfu~peng
             * @data 2017年11月26日
             * @description
             */
            public class Client {
                public static void main(String[] args) {
                    // 创建门面对象
                    new Facade().execute();
                }
            }
 *  执行结果
    
        执行子系统下A类的方法！
        执行子系统下B类的方法！
        执行子系统下C类的方法！

### 门面模式的应用 ###

*  门面模式的优点
    
    1.  减少系统的相互依赖
    2.  提高了灵活性
    3.  提高了安全性
 *  门面模式的缺点
    
    1.  最大的不符合开闭原则
 *  门面模式的使用场景
    
    1.  为一个复杂的模块或者子系统提供一个共外界访问的接口
    2.  子系统相对独立--外界对子系统的访问只需要黑箱操作即可
    3.  预防低水平人员带来的风险扩散--降低个人代码质量对整体项目的影响风险

### 门面模式额注意事项 ###

*  一个子系统可以有多少门面
    
    1.  一般情况下一个就够了
    2.  多个门面的使用情况
        
        1.  子系统已经庞大到不能忍受的地步
        2.  子系统可以提供不同的访问路径
    3.  门面不参与子系统内的业务逻辑
        
        1.  先看一个例子
            
                package mm2;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月26日
                 * @description
                 */
                public class Facade {
                    private ClassA a = new ClassA();
                    private ClassB b = new ClassB();
                    private ClassC c = new ClassC();
                
                    public void executeA() {
                        a.methodA();
                    }
                
                    public void executeB() {
                        b.methodB();
                    }
                
                    public void executeC() {
                        a.methodA();// 注意
                        c.methodC();
                    }
                
                }
        2.  这样的设计是非常不靠谱的，为什么这么说，因为门面类不可以参与业务逻辑，而executeC已经参与了业务逻辑，不仅违反了单一职责原则，同时也破坏了系统的封装性
        3.  那该怎么办--建立一个委托类Context
            
                package mm2;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月26日
                 * @description
                 */
                public class Context {
                    private ClassA a = new ClassA();
                    private ClassC c = new ClassC();
                
                    public void complexMethod() {
                        a.methodA();
                        c.methodC();
                    }
                
                }
        4.  门面类对应修改为：
            
                package mm2;
                
                /**
                 * @author kungfu~peng
                 * @data 2017年11月26日
                 * @description
                 */
                public class Facade {
                    private ClassA a = new ClassA();
                    private ClassB b = new ClassB();
                    private ClassC c = new ClassC();
                    Context ct = new Context();
                
                    public void executeA() {
                        a.methodA();
                    }
                
                    public void executeB() {
                        b.methodB();
                    }
                
                    public void executeC() {
                        ct.complexMethod();
                    }
                
                }

### 最佳实践 ###

*  门面模式是一个非常好的封装方法
    
    1.  子系统非常复杂时，封装出一个或多个门面来
    2.  大项目避免人员带来的风险

### 声明 ###

*  摘自秦小波《设计模式之禅》第2版；
 *  仅供学习，严禁商业用途；
 *  代码手写，没有经编译器编译，有个别错误，自行根据上下文改正；

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70]: /images/20220602/6c4d93574d8749b19d9164a08401084c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 1]: /images/20220602/798dc405b8bf48ba915f5bec80fd2cdb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 2]: /images/20220602/474a6254bb3c4949a1bba507b2e2979e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 3]: /images/20220602/1b0a1f2c6bd44b3aa2b3b8019099f99f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VpZWllaTQzOA_size_16_color_FFFFFF_t_70 4]: /images/20220602/1fead92d7d674af9aa04376ad1dfc1a0.png