2 结构型模式之 - 外观模式

Posted 2020-09-13

外观模式的介绍：外观模式在开发运用中的频率非常高，尤其是现阶段各种第三方SDK充斥在我们的周边，而这些SDK很大概率会使用外观模式，通过一个外观类使得整个系统的接口只有一个统一的高层接口，这样就能够降低用户使用的复杂度，也对用户屏蔽了很多实现细节，当然 ，在我们的开发过程中，外观模式也是我们封装API的常用手段，例如网络模块，ImageLoader模块等。可能你已经在开发中运用过无数次外观模式，只是没有理论层面上认识它，本章我们就从理论与实践相结合的方式来理解外观模式

外观模式的定义: 要求一个子系统的外部与其内部的通信必须通过一个统一的对象进行。外观模式（Facade模式）提供一个高层次的接口，使得子系统更加的易用。

外观模式的使用场景：

1 为一个或者多个子系统提供一个简单接口。子系统往往不断深化变得越来越复杂，甚至可能被替换，大多数模式使用时都会产生更多，更小的类，在这类子系统更具有重用性的同时也更容易对子系统进行定制，修改，这种易变性使得隐藏子系统的具体实现显得很重要，Facade可以提供一个简单统一的接口，对外隐藏子系统的具体实现，隔离变化 。

2 当你需要构建一个层次结构的子系统时，使用Facade模式定义子系统中每层的入口点。如果子系统之间是相互依赖的，你可以让它们仅通过Facade接口进行通信，从而简化它们之间的依赖关系

 

我们就以一个简单的例子来说明外观模式:

我们先定义3个子系统，这3个子系统必须相互配合才能完成一件事，这3个子系统代码如下：

 1 /**
 2  * 子系统A
 3  */
 4 public class SystemA {
 5 
 6     public void doSomething1(){
 7         System.out.println("SystemA 业务逻辑1");
 8     }
 9 
10     public void doSomething2(){
11         System.out.println("SystemA 业务逻辑2");
12     }
13 
14     public void doSomething3(){
15         System.out.println("SystemA 业务逻辑3");
16     }
17 
18 }

 1 /**
 2  * 子系统B
 3  */
 4 public class SystemB {
 5 
 6     public void doSomething1(){
 7         System.out.println("SystemB 业务逻辑1");
 8     }
 9 
10     public void doSomething2(){
11         System.out.println("SystemB 业务逻辑2");
12     }
13 
14     public void doSomething3(){
15         System.out.println("SystemB 业务逻辑3");
16     }
17 
18 }

 1 /**
 2  * 子系统C
 3  */
 4 public class SystemC {
 5 
 6     public void doSomething1(){
 7         System.out.println("SystemC 业务逻辑1");
 8     }
 9 
10     public void doSomething2(){
11         System.out.println("SystemC 业务逻辑2");
12     }
13 
14     public void doSomething3(){
15         System.out.println("SystemC 业务逻辑3");
16     }
17 
18 }

这三个子系统完成了，我们必须要这几个子系统共同配合才能完成一件事，代码是这样的。如下：

 1     //正常情况下，这3个子系统需要配合才能完成一件事
 2     public static void testNormal(){
 3         SystemA systemA = new SystemA();
 4         SystemB systemB = new SystemB();
 5         SystemC systemC = new SystemC();
 6 
 7         //这些子系统一块才能完成一个功能
 8         systemA.doSomething1();
 9         systemA.doSomething2();
10         systemA.doSomething3();
11 
12         systemB.doSomething1();
13         systemB.doSomething2();
14         systemB.doSomething3();
15 
16         systemC.doSomething1();
17         systemC.doSomething2();
18         systemC.doSomething3();
19     }

如上面的代码所示，这样调用起来很复杂，也很容易出错，如果我们用外观模式，把这些子系统给包装起来，提供一个统一的接口来访问，就简单多了，代码如下 ：

 1 /**
 2  *
 3  * 外观模式是一种使用频率非常高的结构型设计模式，
 4  * 它通过引入一个外观角色来简化客户端与子系统之间的交互，
 5  * 为复杂的子系统调用提供一个统一的入口，降低子系统与客户端的耦合度，且客户端调用非常方便
 6  */
 7 public class Facade {
 8     private SystemA systemA = new SystemA();
 9     private SystemB systemB = new SystemB();
10     private SystemC systemC = new SystemC();
11 
12 
13     public void doSomething(){
14 
15         //这些子系统一块才能完成一个功能
16         systemA.doSomething1();
17         systemA.doSomething2();
18         systemA.doSomething3();
19 
20         systemB.doSomething1();
21         systemB.doSomething2();
22         systemB.doSomething3();
23 
24         systemC.doSomething1();
25         systemC.doSomething2();
26         systemC.doSomething3();
27     }
28 }

如上，这样的话，一个外观类提供一个简单的接口，将各个子系统的逻辑，交互隐藏起来，为用户提供一个统一的高层次的接口，使用起来也简单很多，用户也不会感觉到，因为我们使用的是外观模式，内部的变化对用户来说并不可见的，使得系统更加的灵活。