文章目录
- 一、介绍
- 二、一个形象的比喻
- 三、外观模式中的角色
- 四、案例引用
- 五、不使用外观模式
-
- [1. 子系统A](#1. 子系统A)
- [2. 子系统B](#2. 子系统B)
- [3. 子系统C](#3. 子系统C)
- [4. 客户端类](#4. 客户端类)
- 六、使用外观模式
-
- [1. 外观类](#1. 外观类)
- [2. 客户端类](#2. 客户端类)
- 七、优缺点
一、介绍
外观模式(Facade Pattern)，又称为门面模式 ，属于结构型设计模式 。外观模式为一组子系统 的逻辑调用提供一个独立的接口调用。
在不使用外观模式的情况下，实现一个功能时需要按照一定的顺序对多个方法调用，因此我们需要关注对哪些方法进行调用，以及按照什么样的顺序。
而在外观模式中，我们通过调用外观类(Facade)的一个方法就可以实现该功能，该外观类(Facade)内部按照对应的顺序对这些方法进行调用，而具体按照什么样的顺序调用哪些方法我们无需关注，交给外观类(Facade)就可以了。
为子系统中的一组接口提供一个一致的界面。Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
外观模式将我们的关注点从对子系统的调用转移到外观类(Facade)上。
外观模式可以隐藏某个功能的内部逻辑细节，而提供给我们最简单的方式实现该功能，
二、一个形象的比喻
我是房地产开发商，我想盖一栋大楼，但是盖大楼需要各种各样的建筑商(搞地基的，砌墙的，搞水泥的，等等)，我是高贵的开发商，我不想亲力亲为地联系这么多建筑商，怎么办呢？哎~，我找个包工头，我只和包工头对接大楼的进展，至于找哪家建筑商怎么找，这是包工头的事，I don't care，我只关注这栋大楼能盖好就行。
三、外观模式中的角色
在外观模式中，包含以下三个角色：
-
子系统(System)
功能的实际提供者，多个子系统共同实现一个功能。
-
外观类(Facade)
将多个子系统的功能进行整合，并向客户端提供实现整合后功能的唯一接口。用于隐藏功能的内部细节。
-
调用方(Client)
外观类的调用方，只需要关注外观类提供的功能，无需关注内部细节。
下面是外观模式的UML类图
四、案例引用
我本人从上小学至今特别喜欢吃西红柿炒鸡蛋面条，记得是小学四年级的时候，我一顿午饭吃了一大海碗，吃得干干净净一点不浪费，那就以制作一顿西红柿炒鸡蛋面条为例吧。
制作一碗西红柿炒鸡蛋面条挺简单的，我们假设现在有三个角色：
-
负责备菜的小绿
你负责买菜 ，回来还要洗菜 ，并切好西红柿 、打好鸡蛋。
-
负责西红柿炒鸡蛋的小红
小绿备菜完成后，该小红上场表演了，很简单，炒鸡蛋 、炒西红柿 、加入调味料 、加入鸡蛋 、搅拌 、关火。
-
负责煮面条的小白
小白再拿出一个汤锅，盛满水，将水烧开 后加入面条 ，煮沸两次后捞出面条盛入碗中。
最后舀一些西红柿炒鸡蛋搅拌到面条中，一碗美味的西红柿炒鸡蛋面条就ok了。
在享用完这一顿美食后，还需要有人擦桌子 ，有人刷锅洗碗。现在我们把这两个工作继续分配
- 负责备菜的小绿被分配擦桌子
- 负责煮面条的小白被分配刷锅洗碗
下面我们用代码模拟这个过程。
五、不使用外观模式
在不使用外观模式的情况下，我们客户端通常会在一个方法中先获取小绿、小红、小白这三个角色的实例，然后依次调用这三个角色的方法完成响应的步骤。
1. 子系统A
在前面的介绍中，小绿负责的工作不仅有备菜 ，还有擦桌子。下面我们对小绿这个角色进行实现
java
public class XiaoLv {
/** 买菜 */
public void maiCai() {
System.out.println("小绿：买菜");
}
/** 洗菜 */
public void xiCai() {
System.out.println("小绿：洗菜");
}
/** 切西红柿 */
public void qieXiHongShi() {
System.out.println("小绿：切西红柿");
}
/** 打鸡蛋 */
public void daJiDan() {
System.out.println("小绿：打鸡蛋");
}
/** 擦桌子 */
public void caZhuoZi() {
System.out.println("小绿：擦桌子");
}
}2. 子系统B
小绿负责的工作：炒鸡蛋 、炒西红柿 、加入调味料 、加入鸡蛋 、搅拌 、关火。下面我们对小红这个角色进行实现
java
public class XiaoHong {
/** 炒鸡蛋 */
public void chaoJiDan() {
System.out.println("小红：炒鸡蛋");
}
/** 炒西红柿 */
public void chaoXiHongShi() {
System.out.println("小红：炒西红柿");
}
/** 添加调味料 */
public void addTiaoWeiLiao() {
System.out.println("小红：添加调味料");
}
/** 加入鸡蛋 */
public void addJiDan() {
System.out.println("小红：加入鸡蛋");
}
/** 搅拌 */
public void jiaoBan() {
System.out.println("小红：搅拌");
}
/** 关火 */
public void closeFire() {
System.out.println("小红：关火");
}
}3. 子系统C
小白负责的工作不仅有煮面条 ，还有刷锅洗碗。下面我们对小白这个角色进行实现
java
public class XiaoBai {
/** 烧开水 */
public void shaoKaiShui() {
System.out.println("小白：烧开水");
}
/** 加入面条 */
public void addMianTiao() {
System.out.println("小白：加入面条");
}
/** 捞出面条 */
public void takeMianTiao() {
System.out.println("小白：捞出面条");
}
/** 洗碗 */
public void xiWan() {
System.out.println("小白：洗碗");
}
}完成上面三个角色后，我们新建一个客户端类FacadeClient来完成这一整个步骤逻辑
4. 客户端类
在客户端Client中，要想制作一碗面条是相当麻烦的，不仅要对三个角色进行实例化，还得时刻关注每一个角色干嘛干嘛，缺少任何一个步骤都可能导致吃不上这顿饭。
java
public class Client {
public static void main(String[] args) {
// 获取小绿、小红、小白三个角色的实例
XiaoLv xiaoLv = new XiaoLv();
XiaoHong xiaoHong = new XiaoHong();
XiaoBai xiaoBai = new XiaoBai();
// 开始做饭
System.out.println("开始.......");
System.out.println();
xiaoLv.maiCai(); // 小绿：买菜
xiaoLv.xiCai(); // 小绿：洗菜
xiaoLv.qieXiHongShi(); // 小绿：切西红柿
xiaoLv.daJiDan(); // 小绿：打鸡蛋
System.out.println();
xiaoHong.chaoJiDan(); // 小红：炒鸡蛋
xiaoHong.chaoXiHongShi(); // 小红：炒西红柿
xiaoHong.addTiaoWeiLiao(); // 小红：加入调味料
xiaoHong.addJiDan(); // 小红：加入鸡蛋
xiaoHong.jiaoBan(); // 小红：搅拌
xiaoHong.closeFire(); // 小红：关火
System.out.println();
xiaoBai.shaoKaiShui(); // 小白：烧开水
xiaoBai.addMianTiao(); // 小白：加入面条
xiaoBai.takeMianTiao(); // 小白：捞出面条
System.out.println();
System.out.println("开始享用美食：西红柿炒鸡蛋捞面条......");
System.out.println();
xiaoLv.caZhuoZi(); // 小白：小绿：擦桌子
xiaoBai.xiWan(); // 小白：刷锅洗碗
}
}运行客户端代码后输出如下
从结果上来看 ，我的功能需求实现了，做好了饭，吃饱了面，擦好了桌子。
从过程上来看，明明我不负责炒菜、煮面等操作，但我却还要花费精力在这上面，其实我根本不关心面是怎么做的，我只在乎我能不能吃到这碗面。
该示例代码的UML图如下所示
六、使用外观模式
使用外观模式时，需要新建一个外观类，将做面条这些过程细节都放在外观类里面，外观类只需要给客户端提供一个能返回结果的方法即可。现在比如我去一家河南面馆吃饭，点了一大碗西红柿炒鸡蛋面条，然后坐下等着上饭就行了，饭店可以帮我做好一切事情。
现在我们对上面不使用外观模式的代码进行改进。
1. 外观类
下面新建一个外观类河南面馆(HenanNoodlesFacade)
java
public class HenanNoodlesFacade {
private final XiaoLv xiaoLv = new XiaoLv();
private final XiaoHong xiaoHong = new XiaoHong();
private final XiaoBai xiaoBai = new XiaoBai();
/** 做面条 */
public void makeNoodles() {
xiaoLv.maiCai(); // 小绿：买菜
xiaoLv.xiCai(); // 小绿：洗菜
xiaoLv.qieXiHongShi(); // 小绿：切西红柿
xiaoLv.daJiDan(); // 小绿：打鸡蛋
System.out.println();
xiaoHong.chaoJiDan(); // 小红：炒鸡蛋
xiaoHong.chaoXiHongShi(); // 小红：炒西红柿
xiaoHong.addTiaoWeiLiao(); // 小红：加入调味料
xiaoHong.addJiDan(); // 小红：加入鸡蛋
xiaoHong.jiaoBan(); // 小红：搅拌
xiaoHong.closeFire(); // 小红：关火
System.out.println();
xiaoBai.shaoKaiShui(); // 小白：烧开水
xiaoBai.addMianTiao(); // 小白：加入面条
xiaoBai.takeMianTiao(); // 小白：捞出面条
}
/** 善后工作 */
public void clean() {
xiaoLv.caZhuoZi(); // 小白：小绿：擦桌子
xiaoBai.xiWan(); // 小白：刷锅洗碗
}
}然后我们想吃面条的时候，只需要和面馆外观类打交道就可以了
2. 客户端类
下面是我们的客户端类FacadeClient
java
public class FacadeClient {
public static void main(String[] args) {
HenanNoodlesFacade facade = new HenanNoodlesFacade();
System.out.println("开始.......");
System.out.println();
// 做面条
facade.makeNoodles();
System.out.println();
System.out.println("开始享用美食：西红柿炒鸡蛋捞面条......");
System.out.println();
// 善后清理工作
facade.clean();
}
}输出结果如下所示
该示例代码的UML图如下所示
以上就是对外观模式的介绍与讲解，下面我们对外观模式的优缺点进行阐述。
七、优缺点
优点：
- 隐藏了功能细节，关注功能本身
缺点：
- 引入了多余的外观类。因为没有外观类，同样可以实现一样的结果。
纸上得来终觉浅，绝知此事要躬行。
------------------------我是万万岁，我们下期再见------------------------