前言

• 23種設計模式速記
• 單例（singleton）模式
• 工廠方法（factory method）模式
• 抽象工廠（abstract factory）模式
• 建造者/構建器（builder）模式
• 原型（prototype）模式
• 享元（flyweight）模式
• 持續更新中......

23種設計模式快速記憶的請看上面第一篇，本篇和大家一起來學習外觀(門面)模式相關內容，外觀模式一定是我們平常使用最多的一種。 

總體概覽

模式定義
為子系統中的一組接口提供一個一致的接口，Facade 模式定義了一個高層接口，這個接口使得這一子系統更加容易使用。

通過創建一個統一的外觀類，用來包裝子系統中一個 / 多個復雜的類，客戶端可通過調用外觀類的方法來調用內部子系統中所有方法。

解決的問題

• 避免了系統與系統之間的高耦合度
• 使得復雜的子系統用法變得簡單

實例說明
步驟1：定義subsystem角色

class SubSystemOne { 
    public void methodOne() { 
        System.out.println("子系統方法一"); 
    } 
} 
 
class SubSystemTwo { 
    public void methodTwo() { 
        System.out.println("子系統方法二"); 
    } 
} 
 
class SubSystemThree { 
    public void methodThree() { 
        System.out.println("子系統方法三"); 
    } 
} 
 
class SubSystemFour { 
    public void methodFour() { 
        System.out.println("子系統方法四"); 
    } 
} 

步驟2：定義Facade角色

class Facade { 
    SubSystemOne one; 
    SubSystemTwo two; 
    SubSystemThree three; 
    SubSystemFour four; 
 
    public Facade() { 
        this.one = new SubSystemOne(); 
        this.two = new SubSystemTwo(); 
        this.three = new SubSystemThree(); 
        this.four = new SubSystemFour(); 
    } 
 
    public void MethodA() { 
        System.out.println("方法組A()----"); 
        one.methodOne(); 
        two.methodTwo(); 
        four.methodFour(); 
    } 
 
    public void MethodB() { 
        System.out.println("方法組B()----"); 
        two.methodTwo(); 
        three.methodThree(); 
    } 
} 

步驟3：驗證輸出結果

/** 
 * 外觀/門面模式 
 */ 
public class FacadePattern { 
 
    public static void main(String[] args) { 
        Facade facade = new Facade(); 
        facade.MethodA(); 
        facade.MethodB(); 
        System.out.println("----over----"); 
    } 
} 

輸出如下：

方法組A()---- 
子系統方法一 
子系統方法二 
子系統方法四 
方法組B()---- 
子系統方法二 
子系統方法三 
----over---- 

優點

• 減少系統的相互依賴；
• 外觀模式通過封裝子系統，向上層模塊提供統一的接口，從而降低的上層模塊與子系統的過度耦合；
• 提高了靈活性；
• 提高安全性。

缺點
不符合開閉原則：在不對外觀類進行抽象的時候，如果需要添加新的子系統，就需要對Facade類進行修改。

應用場景

• 要為一個復雜的子系統對外提供一個簡單的接口
• 提供子系統的獨立性
• 客戶程序與多個子系統之間存在很大的依賴性

           引入外觀類將子系統與客戶以及其他子系統解耦，可以提高子系統的獨立性和可移植性。

• 在層次化結構中，可以使用外觀模式定義系統中每一層的入口

          層與層之間不直接產生聯系，而通過外觀類建立聯系，降低層之間的耦合度。

與適配器模式的區別
外觀模式的實現核心主要是：由外觀類去保存各個子系統的引用，實現由一個統一的外觀類去包裝多個子系統類，然而客戶端只需要引用這個外觀類，然后由外觀類來調用各個子系統中的方法。

這樣的實現方式非常類似適配器模式，然而外觀模式與適配器模式不同的是：適配器模式是將一個對象包裝起來以改變其接口，而外觀是將一群對象 ”包裝“起來以簡化其接口。它們的意圖是不一樣的，適配器是將接口轉換為不同接口，而外觀模式是提供一個統一的接口來簡化接口。

源碼中的應用

#tomcat 
org.apache.catalina.connector.RequestFacade 
org.apache.catalina.connector.ResponseFacade 
#mybatis 
Configuration 
...... 

RequestFacade源碼分析
Tomcat中門面模式使用的很多，因為Tomcat中有很多不同組件，每個組件要相互通信，但是又不能將自己的內部數據過多的暴露給其他組件。用門面模式隔離數據是很好的方法。

Tomcat 中 Request 除了實現了 ServletRequest 接口外，還會有額外的一些函數，而這些函數需要被其他類調用，但這些方法不應該暴露給上層，因為上層應該專注于 ServletRequest 的實現。于是在 Tomcat 中會使用 Facade 模式了。

未使用 Facade 模式前如下：

未使用 Facade 模式前的 process 處理請求是這樣的

public class ServletProcess { 
    public void process(Request request, Response response){ 
        //.... 
        servlet = (Servlet) myClass.newInstance(); 
        servlet.service((ServletRequest) request, (ServletResponse) response); 
    } 
} 

而使用 Facade 模式之后如下：

而使用 Facade 后的 process 處理請求是這樣的

public class ServletProcess { 
    public void process(Request request, Response response){ 
        //.... 
        RequestFacade requestFacade = new RequestFacade(request); 
        ResponseFacade responseFacade = new ResponseFacade(response); 
        servlet = (Servlet) myClass.newInstance(); 
        servlet.service((ServletRequest) requestFacade, (ServletResponse) responseFacade); 
    } 
} 

為了達到這種效果，RequestFacade 使用了類似代理模式的實現方式。

public class RequestFacade implements HttpServletRequest { 
 
   private ServletRequest request; 
 
    public RequestFacade(ServletRequest request) { 
        this.request = request; 
    } 
 
    @Override 
    public String getAuthType() { 
        return request.getAuthType(); 
    } 
} 

對象里有個 ServletRequest 對象，而 RequestFacade 的所有方法都會委托給 ServletRequest 調用。

Configuration源碼分析

由上面的類圖可以看出，client只需要調用Configuration的newMetaObject(Object object)方法就可以得到一個MetaObject對象，而具體的對象是怎么生成與client無關，下面我們可以看一下Configuration的部分源碼分析。

Configuration部分源碼

//Configuration 類： 
public class Configuration { 
 protected ReflectorFactory reflectorFactory = new DefaultReflectorFactory(); 
 protected ObjectFactory objectFactory = new DefaultObjectFactory(); 
   protected ObjectWrapperFactory objectWrapperFactory = new DefaultObjectWrapperFactory(); 
 
  public MetaObject newMetaObject(Object object) { 
     return MetaObject.forObject(object, objectFactory, objectWrapperFactory, reflectorFactory); 
    } 
} 
 
//MetaObject類 
public class MetaObject { 
 private Object originalObject; 
 private ObjectWrapper objectWrapper; 
 private ObjectFactory objectFactory; 
 private ObjectWrapperFactory objectWrapperFactory; 
 private ReflectorFactory reflectorFactory; 
 
 public static MetaObject forObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) { 
     if (object == null) { 
      return SystemMetaObject.NULL_META_OBJECT; 
     } else { 
        return new MetaObject(object, objectFactory, objectWrapperFactory, reflectorFactory); 
     } 
  } 
 
 private MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory, ReflectorFactory reflectorFactory) { 
     this.originalObject = object; 
     this.objectFactory = objectFactory; 
     this.objectWrapperFactory = objectWrapperFactory; 
     this.reflectorFactory = reflectorFactory; 
 
     if (object instanceof ObjectWrapper) { 
        this.objectWrapper = (ObjectWrapper) object; 
     } else if (objectWrapperFactory.hasWrapperFor(object)) { 
        this.objectWrapper = objectWrapperFactory.getWrapperFor(this, object); 
     } else if (object instanceof Map) { 
        this.objectWrapper = new MapWrapper(this, (Map) object); 
     } else if (object instanceof Collection) { 
       this.objectWrapper = new CollectionWrapper(this, (Collection) object); 
     } else { 
        this.objectWrapper = new BeanWrapper(this, object); 
    } 
 } 
} 

由上面的部分源碼可以看出，客戶端只需要調用Configuration的newMetaObject(Object object)方法，并傳遞一個Object參數，就可以獲取對應的MetaObject，至于具體的產生什么樣的MetaObject，則有MetaObject的類的forObject(object, objectFactory, objectWrapperFactory, reflectorFactory)方法實現。

PS：以上代碼提交在 Github ：

https://github.com/Niuh-Study/niuh-designpatterns.git