门面模式(外观Facade模式)

• 外观模式UML图

外观模式UML

• 定义

  外观模式(也成为门面模式)要求一个子系统的外部与其内部的通信必须通过一个统一的对象进行。它提供一个高层次的接口，使得子系统更易于使用

• 类型：结构型模式
  

• 使用场景

  在真实的应用系统中，一个子系统可能由很多类组成。子系统的客户为了它们的需要，需要和子系统中的一些类进行交互。客户和子系统的类进行直接的交互会导 致客户端对象和子系统之间高度耦合。

• 代码举例说明

  public class Facede {
    //各种子系统的操作
    private Light light;
    private Door door;
    private Window window;
  
    public void goHome(){
         light.on();
         door.open();
         window.open();
     }
  
     public void leftHome(){
         light.off();
         door.close();
         window.close();
     }
  }

• 通用代码实现

  [java] view plaincopyprint?

  1. // 子系统01，邮局接收信件的业务   
  2. class Subsystem01 {   
  3.     public void receiveLetters() {   
  4.         System.out.println("邮局接收用户的信件...");   
  5.     }   
  6. }  

  [java] view plaincopyprint?

  1. // 子系统02，邮局检查信件并分类的业务   
  2. class Subsystem02 {   
  3.     public void checkLetters() {   
  4.         System.out.println("邮局检查用户的信件...");   
  5.     }   
  6. }  

  [java] view plaincopyprint?

  1. // 子系统03，邮局让邮递员送信给收信人   
  2. class Subsystem03 {   
  3.     public void sendToReceiver() {   
  4.         System.out.println("邮递员送信 ...");   
  5.     }   
  6. }  

  [java] view plaincopyprint?

  1. // 子系统04，邮局新推出的赠送贺卡的特殊业务   
  2. class Subsystem04 {   
  3.     public void sendGreetingCard() {   
  4.         System.out.println("邮局的额外送贺卡服务 ...");   
  5.     }   
  6. }  

  [java] view plaincopyprint?

  1. // Facade01 ，只是普通的送信   
  2. class Facade01 {   
  3.     private Subsystem01 subsystem01;   
  4.     private Subsystem02 subsystem02;   
  5.     private Subsystem03 subsystem03;   
  6.      
  7.     public Facade01() {   
  8.         this.subsystem01 = new Subsystem01();   
  9.         this.subsystem02 = new Subsystem02();   
  10.         this.subsystem03 = new Subsystem03();   
  11.     }   
  12.      
  13.     // 普通的送信，委托给各个必要的子系统   
  14.     public void commonSendLetters() {   
  15.         this.subsystem01.receiveLetters();   
  16.         this.subsystem02.checkLetters();   
  17.         this.subsystem03.sendToReceiver();   
  18.     }      
  19. }  

  [java] view plaincopyprint?

  1. //Facade02 ，增加了送贺卡的业务   
  2. class Facade02 {   
  3.   
  4.     // 委托 Facade01 进行普通业务的处理   
  5.     private Facade01 facade01;   
  6.     private Subsystem04 subsystem04;   
  7.     
  8.     public Facade02() {   
  9.         this.facade01 = new Facade01();   
  10.         this.subsystem04 = new Subsystem04();   
  11.     }   
  12.   
  13.     // 特殊的送信   
  14.     public void specialSendLetters() {   
  15.         this.facade01.commonSendLetters();   
  16.         // 普通的送信之后再赠送贺卡   
  17.         this.subsystem04.sendGreetingCard();   
  18.     }   
  19. }  

  [java] view plaincopyprint?

  1. // 测试类，即客户寄信   
  2. public class Client {   
  3.   
  4.     public static void main(String[] args) {   
  5.         Facade01 facade01 = new Facade01();   
  6.         facade01.commonSendLetters();   
  7.        
  8.         System.out.println();   
  9.          
  10.         Facade02 facade02 = new Facade02();   
  11.         facade02.specialSendLetters();   
  12.     }   
  13. }  

  运行结果

  [java] view plaincopyprint?

  1. 邮局接收用户的信件...   
  2. 邮局检查用户的信件...   
  3. 邮递员送信 ...   
  4.   
  5. 邮局接收用户的信件...   
  6. 邮局检查用户的信件...   
  7. 邮递员送信 ...   
  8. 邮局的额外送贺卡服务 ...  
     

  
  

• 总结优缺点

  • 优点
    1. 使用方便，使用外观模式客户端完全不需要知道子系统的实现过程；
    2. 降低客户端与子系统的耦合；
  • 缺点
    1. 减少了可变性和灵活性；
    2. 在不引入抽象外观类的情况下，增加新的子系统可能需要修改外观类或客户端的源代码，违背了“开闭原则”；

Facade模式与 Mediator模式（中介者）的比较：

在 Facade 模式中，Facade 并不参与 Subsystem 类中的业务逻辑，所有的业务功能实际上全由各个 Subsystem 完成， Facade 只是在客户与 Subsystem 之间存在的一道门，客户只能拿着这道门的钥匙来获得业务功能、服务；而在 Mediator模式中，Mediator类是一个调停者、中介者，它完完全全地负责协调各个 Colleague 同事类之间的信息交互，以此来完成其工作。