外观模式-Facade Pattern

外观模式-Facade Pattern

外观模式是一种使用频率非常高的结构型设计模式，它通过引入一个外观角色来简化客户端与子系统之间的交互，为复杂的子系统调用提供一个统一的入口，降低子系统与客户端的耦合度，且客户端调用非常方便。

不知道大家有没有比较过自己泡茶和去茶馆喝茶的区别，如果是自己泡茶需要自行准备茶叶、茶具和
开水，如图(A)所示，而去茶馆喝茶，最简单的方式就是跟茶馆服务员说想要一杯什么样的茶，是铁
观音、碧螺春还是西湖龙井？正因为茶馆有服务员，顾客无须直接和茶叶、茶具、开水等交互，整个
泡茶过程由服务员来完成，顾客只需与服务员交互即可，整个过程非常简单省事，如图(B)所示。

在软件开发中，有时候为了完成一项较为复杂的功能，一个客户类需要和多个业务类交互，而这些需要交互的业务类经常会作为一个整体出现，由于涉及到的类比较多，导致使用时代码较为复杂，此时，特别需要一个类似服务员一样的角色，由它来负责和多个业务类进行交互，而客户类只需与该类交互。外观模式通过引入一个新的外观类(Facade)来实现该功能，外观类充当了软件系统中的“服务员”，它为多个业务类的调用提供了一个统一的入口，简化了类与类之间的交互。在外观模式中，那些需要交互的业务类被称为子系统(Subsystem)。如果没有外观类，那么每个客户类需要和多个子系统之间进行复杂的交互，系统的耦合度将很大，如图下(A)所示；而引入外观类之后，客户类只需要直接与外观类交互，客户类与子系统之间原有的复杂引用关系由外观类来实现，从而降低了系统的耦合度，如下(B)所示。

外观模式：为子系统中的一组接口提供一个统一的入口。外观模式定义了一个高层接口，这个接口使
得这一子系统更加容易使用

外观模式的结构图：

由图可知，外观模式包含如下两个角色：

(1) Facade（外观角色）：在客户端可以调用它的方法，在外观角色中可以知道相关的（一个或者多个）子系统的功能和责任；在正常情况下，它将所有从客户端发来的请求委派到相应的子系统去，传递给相应的子系统对象处理。

(2) SubSystem（子系统角色）：在软件系统中可以有一个或者多个子系统角色，每一个子系统可以不是一个单独的类，而是一个类的集合，它实现子系统的功能；每一个子系统都可以被客户端直接调用，或者被外观角色调用，它处理由外观类传过来的请求；子系统并不知道外观的存在，对于子系统而言，外观角色仅仅是另外一个客户端而已。

外观模式中所指的子系统是一个广义的概念，它可以是一个类、一个功能模块、系统的一个组成部分或者一个完整的系统。子系统类通常是一些业务类，实现了一些具体的、独立的业务功能，其典型代码如下：

class SubSystemA
   {
   public void MethodA()
   {
   //业务实现代码
   }
   }
  
   class SubSystemB
    {
    public void MethodB()
    {
    //业务实现代码
    }
    }
   
    class SubSystemC
    {
    public void MethodC()
    {
    //业务实现代码
    }
    }

在引入外观类之后，与子系统业务类之间的交互统一由外观类来完成，在外观类中通常存在如下代码：

class Facade
   {
   private SubSystemA obj1 = new SubSystemA();
   private SubSystemB obj2 = new SubSystemB();
   private SubSystemC obj3 = new SubSystemC();
  
   public void Method()
   {
   obj1.MethodA();
    obj2.MethodB();
    obj3.MethodC();
    }
    }

由于在外观类中维持了对子系统对象的引用，客户端可以通过外观类来间接调用子系统对象的业务方法，而无须与子系统对象直接交互。引入外观类后，客户端代码变得非常简单，典型代码如下：

class Program
   {
   static void Main(string[] args)
   {
   Facade facade = new Facade();
   facade.Method();
   }
   }

外观模式应用实例

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

通过分析，本实例结构图如图所示：

在图中，EncryptFacade充当外观类，FileReader、CipherMachine和FileWriter充当子系
统类。

实现代码如下：

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

//FileReader.cs
   using System;
   using System.Text;
   using System.IO;
  
   namespace FacadeSample
   {
   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();
    }
    }
   }

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

//CipherMachine.cs
    using System;
    using System.Text;
   namespace FacadeSample
    {
    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;
    }
    }
    } 

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

//FileWriter.cs
    using System;
    using System.IO;
    using System.Text;
   
    namespace FacadeSample
    {
    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("文件操作错误！");
    }
    }
    }
    }

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

namespace FacadeSample
    {
    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);
     }
     }
     }

(5) Program：客户端测试类

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

输出结果：

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

抽象外观类

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

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

using System;
  
   namespace FacadeSample
   {
   class NewCipherMachine
   {
   public string Encrypt(string plainText)
   {
   Console.Write("数据加密，将明文转换为密文：");
    string es = "";
    int key = 10;//设置密钥，移位数为10
    char[] chars = plainText.ToCharArray();
    foreach(char ch in chars)
    {
    int temp = Convert.ToInt32(ch);
    //小写字母移位
    if (ch >= 'a' && ch <= 'z') {
    temp += key % 26;
    if (temp > 122) temp -= 26;
    if (temp < 97) temp += 26;
    }
    //大写字母移位
    if (ch >= 'A' && ch <= 'Z') {
    temp += key % 26;
    if (temp > 90) temp -= 26;
    if (temp < 65) temp += 26;
    }
    es += ((char)temp).ToString();
    }
    Console.WriteLine(es);
    return es;
    }
    }
    }
    

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

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

解决方法之一是：引入一个抽象外观类，客户端针对抽象外观类编程，而在运行时再确定具体外观类，引入抽象外观类之后的文件加密模块结构图如图所示：

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

namespace FacadeSample
   {
   abstract class AbstractEncryptFacade
   {
   public abstract void FileEncrypt(string fileNameSrc, string fileNameDes);
   }
   }
   //新增具体加密外观类NewEncryptFacade代码如下：
   [csharp] view plain copy
    namespace FacadeSample
    {
    class NewEncryptFacade : AbstractEncryptFacade
    {
    private FileReader reader;
    private NewCipherMachine cipher;

    private FileWriter writer;
   
    public NewEncryptFacade()
    {
    reader = new FileReader();
    cipher = new NewCipherMachine();
    writer = new FileWriter();
    }
   
    public override void FileEncrypt(string fileNameSrc, string fileNameDes)
    {
    string plainStr = reader.Read(fileNameSrc);
    string encryptStr = cipher.Encrypt(plainStr);
    writer.Write(encryptStr, fileNameDes);
    }
    }
    }

配置文件App.config中存储了具体外观类的类名，代码如下：

<?xml version="1.0" encoding="utf-8" ?>
   <configuration>
   <appSettings>
   <add key="facade" value="FacadeSample.NewEncryptFacade"/>
   </appSettings>
   </configuration>

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

using System;
   using System.Configuration;
   using System.Reflection;
  
   namespace FacadeSample
   {
   class Program
   {
   static void Main(string[] args)
   {
    AbstractEncryptFacade ef; //针对抽象外观类编程
    //读取配置文件
    string facadeString = ConfigurationManager.AppSettings["facade"];
    //反射生成对象
    ef = (AbstractEncryptFacade)Assembly.Load("FacadeSample"). CreateInstance(facadeString);
    ef.FileEncrypt("src.txt", "des.txt");
    Console.Read();
     }
    }
    }

输出结果如下：

读取文件，获取明文：Hello world!
数据加密，将明文转换为密文：Rovvy gybvn!
保存密文，写入文件。

总结

外观模式的主要优点如下：

(1) 它对客户端屏蔽了子系统组件，减少了客户端所需处理的对象数目，并使得子系统使用起来更加容易。通过引入外观模式，客户端代码将变得很简单，与之关联的对象也很少。

(2) 它实现了子系统与客户端之间的松耦合关系，这使得子系统的变化不会影响到调用它的客户端，只需要调整外观类即可。

(3) 一个子系统的修改对其他子系统没有任何影响，而且子系统内部变化也不会影响到外观对象。

外观模式的主要缺点如下：

(1) 不能很好地限制客户端直接使用子系统类，如果对客户端访问子系统类做太多的限制则减少了可变性和灵活性。

(2) 如果设计不当，增加新的子系统可能需要修改外观类的源代码，违背了开闭原则。

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

(1) 当要为访问一系列复杂的子系统提供一个简单入口时可以使用外观模式。

(2) 客户端程序与多个子系统之间存在很大的依赖性。引入外观类可以将子系统与客户端解耦，从而提高子系统的独立性和可移植性。

(3) 在层次化结构中，可以使用外观模式定义系统中每一层的入口，层与层之间不直接产生联系，而通过外观类建立联系，降低层之间的耦合度。