外观模式(Facade pattern)

简介

外观模式（Facade pattern），是软件工程中常用的一种软件设计模式，它为子系统中的一组接口提供一个统一的高层接口，使得子系统更容易使用。

模式实现

某软件公司欲开发一个可应用于多个软件的文件加密模块，该模块可以对文件中的数据进行加密并将加密之后的数据存储在一个新文件中，具体的流程包括三个部分，分别是读取源文件、加密、保存加密之后的文件，其中，读取文件和保存文件使用流来实现，加密操作通过求模运算实现。这三个操作相对独立，为了实现代码的独立重用，让设计更符合单一职责原则，这三个操作的业务代码封装在三个不同的类中。
现使用外观模式设计该文件加密模块。

(1) FileReader：文件读取类，充当子系统类。

  1. //FileReader.cs  
  2. using System;  
  3. using System.Text;  
  4. using System.IO;  
  6. namespace FacadeSample  
  7. {  
  8.     class FileReader  
  9.     {  
  10.         public string Read(string fileNameSrc)
  11.         {  
  12.        Console.Write("读取文件，获取明文：");  
  13.             FileStream fs = null;  
  14.             StringBuilder sb = new StringBuilder();  
  15.        try  
  16.             {  
  17.                 fs = new FileStream(fileNameSrc, FileMode.Open);  
  18.                 int data;  
  19.                while((data = fs.ReadByte())!= -1)
  20.                 {  
  21.             sb = sb.Append((char)data);  
  22.                }  
  23.                fs.Close();  
  24.                Console.WriteLine(sb.ToString());  
  25.        }  
  26.        catch(FileNotFoundException e)
  27.             {  
  28.            Console.WriteLine("文件不存在！");  
  29.        }  
  30.        catch(IOException e)
  31.             {  
  32.            Console.WriteLine("文件操作错误！");  
  33.        }  
  34.        return sb.ToString();  
  35.         }  
  36.     }  
  37. }

(2) CipherMachine：数据加密类，充当子系统类。

  1. //CipherMachine.cs  
  2. using System;  
  3. using System.Text;  
  5. namespace FacadeSample  
  6. {  
  7.     class CipherMachine  
  8.     {  
  9.        public string Encrypt(string plainText)
  10.        {  
  11.        Console.Write("数据加密，将明文转换为密文：");  
  12.        string es = "";  
  13.             char[] chars = plainText.ToCharArray();  
  14.        foreach(char ch in chars)
  15.             {  
  16.                 string c = (ch % 7).ToString();  
  17.            es += c;  
  18.        }  
  19.             Console.WriteLine(es);  
  20.        return es;  
  21.     }  
  22.     }  
  23. }

(3) FileWriter：文件保存类，充当子系统类。

  1. //FileWriter.cs  
  2. using System;  
  3. using System.IO;  
  4. using System.Text;  
  6. namespace FacadeSample  
  7. {  
  8.     class FileWriter  
  9.     {  
  10.         public void Write(string encryptStr,string fileNameDes)
  11.         {  
  12.        Console.WriteLine("保存密文，写入文件。");  
  13.             FileStream fs = null;  
  14.        try  
  15.             {  
  16.                fs = new FileStream(fileNameDes, FileMode.Create);  
  17.                 byte[] str = Encoding.Default.GetBytes(encryptStr);  
  18.                 fs.Write(str,0,str.Length);  
  19.                 fs.Flush();  
  20.                fs.Close();  
  21.        }
  22.        catch(FileNotFoundException e)
  23.             {  
  24.         Console.WriteLine("文件不存在！");  
  25.        }  
  26.        catch(IOException e)
  27.             {  
  28.                 Console.WriteLine(e.Message);  
  29.            Console.WriteLine("文件操作错误！");  
  30.        }
  31.         }  
  32.     }  
  33. }

(4) EncryptFacade：加密外观类，充当外观类。

  1. // EncryptFacade.cs  
  2. namespace FacadeSample  
  3. {  
  4.     class EncryptFacade  
  5.     {  
  6.         //维持对其他对象的引用  
  7.          private FileReader reader;  
  8.         private CipherMachine cipher;  
  9.         private FileWriter writer;  
  11.         public EncryptFacade()  
  12.         {  
  13.             reader = new FileReader();  
  14.             cipher = new CipherMachine();  
  15.             writer = new FileWriter();  
  16.         }  
  18.         //调用其他对象的业务方法  
  19.          public void FileEncrypt(string fileNameSrc, string fileNameDes)  
  20.         {  
  21.             string plainStr = reader.Read(fileNameSrc);  
  22.             string encryptStr = cipher.Encrypt(plainStr);  
  23.             writer.Write(encryptStr, fileNameDes);  
  24.         }  
  25.     }  
  26. }

(5) Program：客户端测试类

  1. //Program.cs  
  2. using System;  
  4. namespace FacadeSample  
  5. {  
  6.     class Program  
  7.     {  
  8.         static void Main(string[] args)  
  9.         {  
  10.             EncryptFacade ef = new EncryptFacade();  
  11.             ef.FileEncrypt("src.txt", "des.txt");  
  12.             Console.Read();  
  13.         }  
  14.     }  
  15. }

结果及分析

  1. 读取文件，获取明文：Hello world!
  2. 数据加密，将明文转换为密文：233364062325
  3. 保存密文，写入文件。

抽象外观类

在标准的外观模式结构图中，如果需要增加、删除或更换与外观类交互的子系统类，必须修改外观类或客户端的源代码，这将违背开闭原则，因此可以通过引入抽象外观类来对系统进行改进，在一定程度上可以解决该问题。在引入抽象外观类之后，客户端可以针对抽象外观类进行编程，对于新的业务需求，不需要修改原有外观类，而对应增加一个新的具体外观类，由新的具体外观类来关联新的子系统对象，同时通过修改配置文件来达到不修改任何源代码并更换外观类的目的。

下面通过一个具体实例来学习如何使用抽象外观类：

如果在应用实例“文件加密模块”中需要更换一个加密类，不再使用原有的基于求模运算的加密类CipherMachine，而改为基于移位运算的新加密类NewCipherMachine，其代码如下：

  1. using System;  
  3. namespace FacadeSample  
  4. {  
  5.     class NewCipherMachine  
  6.     {  
  7.         public string Encrypt(string plainText)
  8.         {  
  9.             Console.Write("数据加密，将明文转换为密文：");  
  10.             string es = "";  
  11.             int key = 10;//设置密钥，移位数为10  
  12.             char[] chars = plainText.ToCharArray();  
  13.             foreach(char ch in chars)
  14.             {  
  15.                 int temp = Convert.ToInt32(ch);  
  16.                 //小写字母移位  
  17.                 if (ch >= 'a' && ch <= 'z') {  
  18.                     temp += key % 26;  
  19.                     if (temp > 122) temp -= 26;  
  20.                     if (temp < 97) temp += 26;  
  21.                 }  
  22.                 //大写字母移位  
  23.                 if (ch >= 'A' && ch <= 'Z') {  
  24.                     temp += key % 26;  
  25.                     if (temp > 90) temp -= 26;  
  26.                     if (temp < 65) temp += 26;  
  27.                 }  
  28.                 es += ((char)temp).ToString();  
  29.             }  
  30.             Console.WriteLine(es);  
  31.             return es;  
  32.         }  
  33.     }  
  34. }

如果不增加新的外观类，只能通过修改原有外观类EncryptFacade的源代码来实现加密类的更换，将原有的对CipherMachine类型对象的引用改为对NewCipherMachine类型对象的引用，这违背了开闭原则，因此需要通过增加新的外观类来实现对子系统对象引用的改变。

如果增加一个新的外观类NewEncryptFacade来与FileReader类、FileWriter类以及新增加的NewCipherMachine类进行交互，虽然原有系统类库无须做任何修改，但是因为客户端代码中原来针对EncryptFacade类进行编程，现在需要改为NewEncryptFacade类，因此需要修改客户端源代码。

如何在不修改客户端代码的前提下使用新的外观类呢？解决方法之一是：引入一个抽象外观类，客户端针对抽象外观类编程，而在运行时再确定具体外观类，引入抽象外观类之后的文件加密模块结构图如图5所示：

客户类Client针对抽象外观类AbstractEncryptFacade进行编程，AbstractEncryptFacade代码如下：

  1. namespace FacadeSample  
  2. {  
  3.     abstract class AbstractEncryptFacade  
  4.     {  
  5.         public abstract void FileEncrypt(string fileNameSrc, string fileNameDes);  
  6.     }  
  7. }

新增具体加密外观类NewEncryptFacade代码如下：

  1. namespace FacadeSample  
  2. {  
  3.     class NewEncryptFacade : AbstractEncryptFacade  
  4.     {  
  5.         private FileReader reader;  
  6.         private NewCipherMachine cipher;  
  7.         private FileWriter writer;  
  9.         public NewEncryptFacade()  
  10.         {  
  11.             reader = new FileReader();  
  12.             cipher = new NewCipherMachine();  
  13.             writer = new FileWriter();  
  14.         }  
  16.         public override void FileEncrypt(string fileNameSrc, string fileNameDes)  
  17.         {  
  18.             string plainStr = reader.Read(fileNameSrc);  
  19.             string encryptStr = cipher.Encrypt(plainStr);  
  20.             writer.Write(encryptStr, fileNameDes);  
  21.         }  
  22.     }  
  23. }
  1. 配置文件App.config中存储了具体外观类的类名，代码如下：
  2. <?xml version="1.0" encoding="utf-8" ?>  
  3. <configuration>  
  4.   <appSettings>  
  5.     <add key="facade" value="FacadeSample.NewEncryptFacade"/>  
  6.   </appSettings>  
  7. </configuration>

客户端测试代码修改如下：

  1. using System;  
  2. using System.Configuration;  
  3. using System.Reflection;  
  5. namespace FacadeSample  
  6. {  
  7.     class Program  
  8.     {  
  9.         static void Main(string[] args)  
  10.         {  
  11.             AbstractEncryptFacade ef; //针对抽象外观类编程  
  12.             //读取配置文件  
  13.             string facadeString = ConfigurationManager.AppSettings["facade"];  
  14.             //反射生成对象  
  15.             ef = (AbstractEncryptFacade)Assembly.Load("FacadeSample"). CreateInstance (facadeString);  
  16.             ef.FileEncrypt("src.txt", "des.txt");  
  17.             Console.Read();  
  18.         }  
  19.     }  
  20. }

模式适用场景

在以下情况下可以考虑使用外观模式：

  1. 当要为访问一系列复杂的子系统提供一个简单入口时可以使用外观模式。
  2. 客户端程序与多个子系统之间存在很大的依赖性。引入外观类可以将子系统与客户端解耦，从而提高子系统的独立性和可移植性。
  3. 在层次化结构中，可以使用外观模式定义系统中每一层的入口，层与层之间不直接产生联系，而通过外观类建立联系，降低层之间的耦合度。