設計模式詳解——外觀模式

本篇文章介紹一種設計模式——外觀模式。本篇文章內容參考《JAVA與模式》之門面模式，外觀模式，深入淺出外觀模式（二）。

一、外觀模式概述

1.定義

外觀模式(Facade Pattern)：外部與一個子系統的通信必須通過一個統一的外觀對象進行，爲子系統中的一組接口提供一個一致的界面，外觀模式定義了一個高層接口，這個接口使得這一子系統更加容易使用。外觀模式又稱爲門面模式，它是一種對象結構型模式。

2.定義闡述

醫院的例子

現代的軟件系統都是比較複雜的，設計師處理複雜系統的一個常見方法便是將其“分而治之”，把一個系統劃分爲幾個較小的子系統。如果把醫院作爲一個子系統，按照部門職能，這個系統可以劃分爲掛號、門診、劃價、化驗、收費、取藥等。看病的病人要與這些部門打交道，就如同一個子系統的客戶端與一個子系統的各個類打交道一樣，不是一件容易的事情。

首先病人必須先掛號，然後門診。如果醫生要求化驗，病人必須首先劃價，然後繳費，纔可以到化驗部門做化驗。化驗後再回到門診室。

上圖描述的是病人在醫院裏的體驗，圖中的方框代表醫院。

解決這種不便的方法便是引進外觀模式，醫院可以設置一個接待員的位置，由接待員負責代爲掛號、劃價、繳費、取藥等。這個接待員就是外觀模式的體現，病人只接觸接待員，由接待員與各個部門打交道。

二、外觀模式結構

外觀模式沒有一個一般化的類圖描述，最好的描述方法實際上就是以一個例子說明。

由於門面模式的結構圖過於抽象，因此把它稍稍具體點。假設子系統內有三個模塊，分別是ModuleA、ModuleB和ModuleC，它們分別有一個示例方法，那麼此時示例的整體結構圖如下：
　　
在這個對象圖中，出現了兩個角色：
●　　外觀(Facade)角色 ：客戶端可以調用這個角色的方法。此角色知曉相關的（一個或者多個）子系統的功能和責任。在正常情況下，本角色會將所有從客戶端發來的請求委派到相應的子系統去。

●　　子系統(SubSystem)角色 ：可以同時有一個或者多個子系統。每個子系統都不是一個單獨的類，而是一個類的集合（如上面的子系統就是由ModuleA、ModuleB、ModuleC三個類組合而成）。每個子系統都可以被客戶端直接調用，或者被門面角色調用。子系統並不知道門面的存在，對於子系統而言，門面僅僅是另外一個客戶端而已。

時序圖

子系統角色中的類：

public class ModuleA {
    //示意方法
    public void testA(){
        System.out.println("調用ModuleA中的testA方法");
    }
}

public class ModuleB {
    //示意方法
    public void testB(){
        System.out.println("調用ModuleB中的testB方法");
    }
}

public class ModuleC {
    //示意方法
    public void testC(){
        System.out.println("調用ModuleC中的testC方法");
    }
}

外觀角色類:

public class Facade {
    //示意方法，滿足客戶端需要的功能
    public void test(){
        ModuleA a = new ModuleA();
        a.testA();
        ModuleB b = new ModuleB();
        b.testB();
        ModuleC c = new ModuleC();
        c.testC();
    }
}

客戶端角色類：

public class Client {

    public static void main(String[] args) {

        Facade facade = new Facade();
        facade.test();
    }

}

Facade類其實相當於A、B、C模塊的外觀界面，有了這個Facade類，那麼客戶端就不需要親自調用子系統中的A、B、C模塊了，也不需要知道系統內部的實現細節，甚至都不需要知道A、B、C模塊的存在，客戶端只需要跟Facade類交互就好了，從而更好地實現了客戶端和子系統中A、B、C模塊的解耦，讓客戶端更容易地使用系統。

三、外觀模式的擴展

使用外觀模式還有一個附帶的好處，就是能夠有選擇性地暴露方法。一個模塊中定義的方法可以分成兩部分，一部分是給子系統外部使用的，一部分是子系統內部模塊之間相互調用時使用的。有了Facade類，那麼用於子系統內部模塊之間相互調用的方法就不用暴露給子系統外部了。

比如，定義如下A、B、C模塊。

public class Module {
    /**
     * 提供給子系統外部使用的方法
     */
    public void a1(){};

    /**
     * 子系統內部模塊之間相互調用時使用的方法
     */
    public void a2(){};
    public void a3(){};
}

public class ModuleB {
    /**
     * 提供給子系統外部使用的方法
     */
    public void b1(){};

    /**
     * 子系統內部模塊之間相互調用時使用的方法
     */
    public void b2(){};
    public void b3(){};
}

public class ModuleC {
    /**
     * 提供給子系統外部使用的方法
     */
    public void c1(){};

    /**
     * 子系統內部模塊之間相互調用時使用的方法
     */
    public void c2(){};
    public void c3(){};
}

public class ModuleFacade {

    ModuleA a = new ModuleA();
    ModuleB b = new ModuleB();
    ModuleC c = new ModuleC();
    /**
     * 下面這些是A、B、C模塊對子系統外部提供的方法
     */
    public void a1(){
        a.a1();
    }
    public void b1(){
        b.b1();
    }
    public void c1(){
        c.c1();
    }
}

這樣定義一個ModuleFacade類可以有效地屏蔽內部的細節，免得客戶端去調用Module類時，發現一些不需要它知道的方法。比如a2()和a3()方法就不需要讓客戶端知道，否則既暴露了內部的細節，又讓客戶端迷惑。

一個系統可以有幾個外觀類

在外觀模式中，通常只需要一個外觀類，並且此外觀類只有一個實例，換言之它是一個單例類。當然這並不意味着在整個系統裏只有一個外觀類，而僅僅是說對每一個子系統只有一個外觀類。或者說，如果一個系統有好幾個子系統的話，每一個子系統都有一個外觀類，整個系統可以有數個外觀類。

爲子系統增加新行爲

初學者往往以爲通過繼承一個外觀類便可在子系統中加入新的行爲，這是錯誤的。外觀模式的用意是爲子系統提供一個集中化和簡化的溝通管道，而不能向子系統加入新的行爲。比如醫院中的接待員並不是醫護人員，接待員並不能爲病人提供醫療服務。

四、外觀模式的實例

1.實例說明

某軟件公司欲開發一個可應用於多個軟件的文件加密模塊，該模塊可以對文件中的數據進行加密並將加密之後的數據存儲在一個新文件中，具體的流程包括三個部分，分別是讀取源文件、加密、保存加密之後的文件，其中，讀取文件和保存文件使用流來實現，加密操作通過求模運算實現。這三個操作相對獨立，爲了實現代碼的獨立重用，讓設計更符合單一職責原則，這三個操作的業務代碼封裝在三個不同的類中。

2.實例類圖

EncryptFacade充當外觀類，FileReader、CipherMachine和FileWriter充當子系統類。

3.實例代碼

FileReader：文件讀取類，充當子系統類。

class FileReader  
    {  
        public string Read(string fileNameSrc)   
        {  
       Console.Write("讀取文件，獲取明文：");  
            FileStream fs = null;  
            StringBuilder sb = new StringBuilder();  
       try  
            {  
                fs = new FileStream(fileNameSrc, FileMode.Open);  
                int data;  
               while((data = fs.ReadByte())!= -1)   
                {  
            sb = sb.Append((char)data);  
               }  
               fs.Close();  
               Console.WriteLine(sb.ToString());  
       }  
       catch(FileNotFoundException e)   
            {  
           Console.WriteLine("文件不存在！");  
       }  
       catch(IOException e)   
            {  
           Console.WriteLine("文件操作錯誤！");  
       }  
       return sb.ToString();  
        }  
    }  

CipherMachine：數據加密類，充當子系統類。

class CipherMachine  
    {  
       public string Encrypt(string plainText)   
       {  
       Console.Write("數據加密，將明文轉換爲密文：");  
       string es = "";  
            char[] chars = plainText.ToCharArray();  
       foreach(char ch in chars)   
            {  
                string c = (ch % 7).ToString();  
           es += c;  
       }  
            Console.WriteLine(es);  
       return es;  
    }  
    }  

FileWriter：文件保存類，充當子系統類。

class FileWriter  
    {  
        public void Write(string encryptStr,string fileNameDes)   
        {  
       Console.WriteLine("保存密文，寫入文件。");  
            FileStream fs = null;  
       try  
            {  
               fs = new FileStream(fileNameDes, FileMode.Create);  
                byte[] str = Encoding.Default.GetBytes(encryptStr);  
                fs.Write(str,0,str.Length);  
                fs.Flush();  
               fs.Close();  
       }      
       catch(FileNotFoundException e)   
            {  
        Console.WriteLine("文件不存在！");  
       }  
       catch(IOException e)   
            {  
                Console.WriteLine(e.Message);  
           Console.WriteLine("文件操作錯誤！");  
       }          
        }  
    }  

EncryptFacade：加密外觀類，充當外觀類。

class EncryptFacade  
    {  
        //維持對其他對象的引用  
         private FileReader reader;  
        private CipherMachine cipher;  
        private FileWriter writer;  

        public EncryptFacade()  
        {  
            reader = new FileReader();  
            cipher = new CipherMachine();  
            writer = new FileWriter();  
        }  

        //調用其他對象的業務方法  
         public void FileEncrypt(string fileNameSrc, string fileNameDes)  
        {  
            string plainStr = reader.Read(fileNameSrc);  
            string encryptStr = cipher.Encrypt(plainStr);  
            writer.Write(encryptStr, fileNameDes);  
        }  
    }  

Program：客戶端測試類

class Program  
    {  
        static void Main(string[] args)  
        {  
            EncryptFacade ef = new EncryptFacade();  
            ef.FileEncrypt("src.txt", "des.txt");  
            Console.Read();  
        }  
    }  

五、外觀模式的優點

●　　鬆散耦合

外觀模式鬆散了客戶端與子系統的耦合關係，讓子系統內部的模塊能更容易擴展和維護。

●　　簡單易用

外觀模式讓子系統更加易用，客戶端不再需要了解子系統內部的實現，也不需要跟衆多子系統內部的模塊進行交互，只需要跟外觀類交互就可以了。

●　　更好的劃分訪問層次

通過合理使用Facade，可以幫助我們更好地劃分訪問的層次。有些方法是對系統外的，有些方法是系統內部使用的。把需要暴露給外部的功能集中到外觀中，這樣既方便客戶端使用，也很好地隱藏了內部的細節。