JAVA设计模式(9) —<结构型>外观模式(Facade)

1 定义：

外观模式（Façade Pattern）

Provide a unified interface to a set of interfaces in a subsystem. Façade defines a higher-level interface that makes the subsystem easier to use.

(要求一个子系统的外部与其内部的通信必须通过一个统一的对象进行。门面模式提供一个高层次的接口，使得子系统更易于使用。)

简言之，门面对象是外界访问子系统内部的唯一通道，力求“金玉其外，败絮其中”。

1.1 通用类图：

     门面角色(Façade)：客户端可以调用这个角色的方法。它知晓子系统的所有功能和责任。该角色没有实际的业务逻辑，只是一个委托类，将客户端发来的请求委派到相应的子系统去。

     子系统角色(Subsystem)：可以同时有一个或多个子系统。每个子系统都是一个类的集合。子系统不知道门面的存在，门面相对于子系统仅是另外一个客户端而已。

1.2 通用代码：

[java]  view plain copy

1. public class ClassA {  
2.     public void doSomethingA() {  
3.         // 业务逻辑  
4.     }  
5. }  
6.   
7. public class ClassB {  
8.     public void doSomethingB() {  
9.         // 业务逻辑  
10.     }  
11. }  
12.   
13. public class ClassC {  
14.     public void doSomethingC() {  
15.         // 业务逻辑  
16.     }  
17. }  
18.   
19. public class Facade {  
20.     // 被委托的对象  
21.     private ClassA a = new ClassA();  
22.     private ClassB b = new ClassB();  
23.     private ClassC c = new ClassC();  
24.   
25.     // 提供给外部访问的方法  
26.     public void methodA() {  
27.         this.a.doSomethingA();  
28.     }  
29.   
30.     public void methodB() {  
31.         this.b.doSomethingB();  
32.     }  
33.   
34.     public void methodC() {  
35.         this.c.doSomethingC();  
36.     }  
37. }  

2 优点

1. 对客户屏蔽子系统组件，减少了客户处理的对象数目并使得子系统使用起来更加容易。通过引入外观模式，客户代码将变得很简单，与之关联的对象也很少。
2. 实现了子系统与客户之间的松耦合关系，这使得子系统的组件变化不会影响到调用它的客户类，只需要调整外观类即可。
3. 降低了大型软件系统中的编译依赖性，并简化了系统在不同平台之间的移植过程，因为编译一个子系统一般不需要编译所有其他的子系统。一个子系统的修改对其他子系统没有任何影响，而且子系统内部变化也不会影响到外观对象。
4. 只是提供了一个访问子系统的统一入口，并不影响用户直接使用子系统类。

3 缺点

1. 不能很好地限制客户使用子系统类，如果对客户访问子系统类做太多的限制则减少了可变性和灵活性。
2. 在不引入抽象外观类的情况下，增加新的子系统可能需要修改外观类或客户端的源代码，违背了“开闭原则”。

4 应用场景

在遇到以下情况使用facade模式：

• 当你要为一个复杂子系统提供一个简单接口时。子系统往往因为不断演化而变得越来越复杂。大多数模式使用时都会产生更多更小的类。

这使得子系统更具可重用性，也更容易对子系统进行定制，但这也给那些不需要定制子系统的用户带来一些使用上的困难。facade可以提供一个简单的缺省视图，
这一视图对大多数用户来说已经足够，而那些需要更多的可定制性的用户可以越过facade层。

• 客户程序与抽象类的实现部分之间存在着很大的依赖性<客户程序与多个子系统之间存在很大的依赖性>。引入 facade将这个子系统与客户以及其他的子系统分离，可以提高子系统的独立性 和可移植性。
• 当你需要构建一个层次结构的子系统时，使用 facade模式定义子系统中每层的入口点。如果子系统之间是相互依赖的，你可以让它们仅通过facade进行通讯，从而简化了它们之间的依赖关系,同时预防低水平人员开带来的风险扩散（为其限定某一子系统，供其开发），常见的三层架构就是外观模式的体现。

5 注意事项

5.1 一个子系统可以有多个门面

A。门面已经在到不能忍受的程度（比如一个门面对象已经超过了200行代码），虽然都是非常简单的委托操作，也建议拆分成多个门面，否则会给以后的维护和扩展带来不必要的麻烦。如何拆分？可以按功能：如数据库操作的门面可以分为查询门面、删除门面、更新门面等。

B。子系统可以提供不同访问路径：以通用源码为例，ClassA、ClassB、ClassC是一个子系统中的3个对象，现在有两个不同的高层模块来访问该子系统，模块一是子系统的信任模块，可以完整的访问子系统的所有业务逻辑；而模块二属于受限访问对象，只能访问methodB方法。此时，就需要建立两个门面以供不同的高层模块来访问，即在原有代码中增加一个门面即可。代码如下：

[java]  view plain copy

1. public class Facade2 {  
2.     //引用原有的门面  
3.     private Façade façade = new Façade();  
4.     //对外提供唯一的访问子系统的方法  
5.     public void methodB(){  
6.         This.facade.methodB();  
7.     }  
8. }  

为什么要使用委托而不再编写一个委托到子系统的方法呢？那是因为在面向对象的编程中，尽量保持相同的代码只编写一遍，避免以后到处修改相似代码的悲剧。

5.2 门面不参与子系统内的业务逻辑

以通用代码为例：如果methodC中必须先调用ClassA的doSomethingA，然后再调用 ClassC 的doSomethingC方法呢？如何改。但千万别这么做：

[java]  view plain copy

1. public void methodC( ) {  
2.     this.a.doSomethingA();  
3.     this.c.doSomethingC();  
4. }  

为什么不要这么做呢？因为你已经让门面对象参与了业务逻辑，而门面对象只提供了个访问子系统的一个路径而已。否则就会产生一个倒依赖的问题：子系统必须依赖门面才能被访问，这是设计上的一个严重错误，不仅违反了单一职责原则，同时也破坏了系统的封装性。

解决之道：建立一个封装类，封装完毕后提供给门面对象。

最终修改如下：

[java]  view plain copy

1. public class Context {  
2.     // 委托处理  
3.     private ClassA a = new ClassA();  
4.     private ClassC c = new ClassC();  
5.   
6.     // 复杂的计算  
7.     public void complexMethod() {  
8.         this.a.doSomethingA();  
9.         this.c.doSomethingC();  
10.     }  
11. }  
12.   
13. public class Facade {  
14.     // 被委托的对象  
15.     private ClassA a = new ClassA();  
16.     private ClassB b = new ClassB();  
17.     private Context context = new Context();  
18.   
19.     // 提供给外部访问的方法  
20.     public void methodA() {  
21.         this.a.doSomethingA();  
22.     }  
23.   
24.     public void methodB() {  
25.         this.b.doSomethingB();  
26.     }  
27.   
28.     public void methodC() {  
29.         this.context.complexMethod();  
30.     }  
31. }  

5.3外观模式与迪米特法则：

   外观模式创造出一个外观对象，将客户端所涉及的属于一个子系统的协作伙伴的数量减到最少，使得客户端与子系统内部的对象的相互作用被外观对象所取代。外观类充当了客户类与子系统类之间的“第三者”，降低了客户类与子系统类之间的耦合度，外观模式就是实现代码重构以便达到“迪米特法则”要求的一个强有力的武器。

5.4 抽象外观类的引入：

  外观模式最大的缺点在于违背了“开闭原则”，而抽象外观类可一定程度上解决该问题：
  当增加新的子系统或者移除子系统时需要修改外观类，可以通过引入抽象外观类在一定程度上解决该问题，客户端针对抽象外观类进行编程。对于新的业务需求，不修改原有外观类，而对应增加一个新的具体外观类，由新的具体外观类来关联新的子系统对象，同时通过修改配置文件来达到不修改源代码并更换外观类的目的。 

 

6 扩展

暂无

7 范例

7.1睡觉看电视外观类应用

  晚上睡觉之前，你总是喜欢看电视，在你进入卧室的时候你需要完成以下几个步骤：打开电灯、打开空调、放

心银幕(假如你家有)、打开电视通过这么些繁琐的步骤后你终于可以看电视了，但是你要睡觉了呢？又要去进行繁琐

的关闭动作。这里你就需要一个外观模式了，通过实现一个更加合理的接口外观类将这些动作都包装起来，实现一

键“看电视”、一键“关电视”。这就是外观模式的动机

实例的UML图

首先是四个组件（电视、电灯、空调、银幕）

[java]  view plain copy print ?

1. public class Television {  
2.     public void on(){  
3.         System.out.println("打开了电视....");  
4.     }  
5.       
6.     public void off(){  
7.         System.out.println("关闭了电视....");  
8.     }  
9. }  

[java]  view plain copy print ?

1. public class Light {  
2.     public void on(){  
3.         System.out.println("打开了电灯....");  
4.     }  
5.       
6.     public void off(){  
7.         System.out.println("关闭了电灯....");  
8.     }  
9. }  

[java]  view plain copy print ?

1. public class AirCondition {  
2.     public void on(){  
3.         System.out.println("打开了空调....");  
4.     }  
5.       
6.     public void off(){  
7.         System.out.println("关闭了空调....");  
8.     }  
9. }  

[java]  view plain copy print ?

1. public class Screen {  
2.     public void up(){  
3.         System.out.println("升起银幕....");  
4.     }  
5.       
6.     public void down(){  
7.         System.out.println("下降银幕....");       
8.     }  
9. }  

然后是比较强大、干净、美观的外观

[java]  view plain copy print ?

1. public class WatchTvSwtichFacade {  
2.     Light light;  
3.     AirCondition ac;  
4.     Television tv;  
5.     Screen screen;  
6.       
7.     public WatchTvSwtichFacade(Light light,AirCondition ac,Television tv,Screen screen){  
8.         this.light = light;  
9.         this.ac = ac;  
10.         this.tv = tv;  
11.         this.screen = screen;  
12.     }  
13.       
14.     public void on(){  
15.         light.on();       //首先开灯  
16.         ac.on();          //然后是打开空调  
17.         screen.down();    //把银幕降下来  
18.         tv.on();          //最后是打开电视  
19.     }  
20.       
21.     public void off(){  
22.         tv.off();         //首先关闭电视机  
23.         screen.up();      //银幕升上去  
24.         ac.off();         //空调关闭  
25.         light.off();      //最后关灯  
26.     }  
27. }  

客户端

[java]  view plain copy print ?

1. public class Client {  
2.     public static void main(String[] args) {  
3.         //实例化组件  
4.         Light light = new Light();  
5.         Television tv = new Television();  
6.         AirCondition ac = new AirCondition();  
7.         Screen screen = new Screen();  
8.           
9.         WatchTvSwtichFacade watchTv = new WatchTvSwtichFacade(light, ac, tv, screen);  
10.           
11.         watchTv.on();  
12.         System.out.println("--------------可以看电视了.........");  
13.         watchTv.off();  
14.         System.out.println("--------------可以睡觉了...........");  
15.     }  
16. }  

运行结果

从上面的使用通过使用外观模式，客户可以非常方便的实现比较复杂的功能。

7.2 用户登陆验证的门面小例

类图

源代码

[java]  view plain copy

1. package _17_Facade.mixed;  
2. public interface ILoginCheck {  
3.     public boolean login(String user, String password);  
4. }  
5.   
6. public class LoginCheck implements ILoginCheck {  
7.     private Database db;  
8.   
9.     @Override  
10.     public boolean login(String user, String password) {  
11.         db = new Database();//  
12.         // 检查格式  
13.         if (!FormatCheck.isUserNameValid(user))  
14.             return false;  
15.         if (!FormatCheck.isPasswordValid(password))  
16.             return false;  
17.         // 检查是否存在用户  
18.         if (!isUserExist(user))  
19.             return false;  
20.         // 检查密码是否正确  
21.         if (!password.equals(this.getUserPassword(user)))  
22.             return false;  
23.         return true;  
24.     }  
25.   
26.     private boolean isUserExist(String user) {  
27.         return db.isUserExist(user);  
28.     }  
29.   
30.     private String getUserPassword(String user) {  
31.         return db.getUserPassword(user);  
32.     }  
33. }  
34.   
35. public class FormatCheck {  
36.     public static boolean isUserNameValid(String user) {  
37.         return true;  
38.     }  
39.   
40.     public static boolean isPasswordValid(String password) {  
41.         return true;  
42.     }  
43. }  
44.   
45. public class Database {  
46.     public boolean isUserExist(String user) {  
47.         return true;  
48.     }  
49.   
50.     public String getUserPassword(String user) {  
51.         return new String("123456");  
52.     }  
53. }  
54.   
55. public class Login {  
56.     // private LoginCheck check = new LoginCheck();  
57.     private ILoginCheck check = new LogDecorator(new LoginCheck());  
58.   
59.     public boolean login(String user, String password) {  
60.         return check.login(user, password);  
61.     }  
62. }  
63.   
64. public class Client {  
65.     public static void main(String args[]) {  
66.         Login login = new Login();  
67.         boolean result = login.login("Tom", "123456");  
68.         System.out.println("登陆帐号：Tom , 123456 .结果为： " + result);  
69.     }  
70. }  

结果如下：

登陆帐号：Tom , 123456 .结果为 ： true

7.3外观装饰类

承上例，业务变化（为加强系统安全），系统需要记录每次登陆的用户名。（在子系统内扩张，这里因为系统已经投产，就小小地结合使用一下装饰模式吧）

类图如下：

源代码（仅需添加如下两类，其它无需作任何变化）

[java]  view plain copy

1. import java.util.Date;  
2. import java.text.DateFormat;  
3. public class Decorator implements ILoginCheck {  
4.   
5.     protected ILoginCheck check;  
6.   
7.     public Decorator(ILoginCheck check) {  
8.         this.check = check;  
9.     }  
10.   
11.     @Override  
12.     public boolean login(String user, String password) {  
13.         return check.login(user, password);  
14.     }  
15. }  
16.   
17. public class LogDecorator extends Decorator {  
18.     public LogDecorator(ILoginCheck check) {  
19.         super(check);  
20.     }  
21.   
22.     public void writeLog(String user) {  
23.         Date now = new Date();  
24.         DateFormat df = DateFormat.getDateTimeInstance(DateFormat.MEDIUM,  
25.                 DateFormat.MEDIUM);  
26.         // 显示日期，时间（精确到分）  
27.         System.out.println("---------" + user + " login at " + df.format(now)  
28.                 + "----------");  
29.     }  
30.   
31.     @Override  
32.     public boolean login(String user, String password) {  
33.         boolean result = super.login(user, password);  
34.         if (result)  
35.             writeLog(user);  
36.         return result;  
37.     }  
38. }  

结果如下：

---------Tom login at 2012-5-17 17:24:03----------

登陆帐号：Tom , 123456 .结果为 ： true