一、外观模式简介
外观模式（Facade Pattern） 隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性。
这种模式涉及到一个单一的类，该类提供了客户端请求的简化方法和对现有系统类方法的委托调用。
意图： 为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
主要解决： 降低访问复杂系统的内部子系统时的复杂度，简化客户端与之的接口。
何时使用：
- 1、客户端不需要知道系统内部的复杂联系，整个系统只需提供一个"接待员"即可。
- 2、定义系统的入口。
如何解决： 客户端不与系统耦合，外观类与系统耦合。
关键代码： 在客户端和复杂系统之间再加一层，这一层将调用顺序、依赖关系等处理好。
应用实例：
- 1、去医院看病，可能要去挂号、门诊、划价、取药，让患者或患者家属觉得很复杂，如果有提供接待人员，只让接待人员来处理，就很方便。
- 2、JAVA 的三层开发模式。
优点：
- 1、减少系统相互依赖。
- 2、提高灵活性。
- 3、提高了安全性。
缺点： 不符合开闭原则，如果要改东西很麻烦，继承重写都不合适。
使用场景：
- 1、为复杂的模块或子系统提供外界访问的模块。
- 2、子系统相对独立。
- 3、预防低水平人员带来的风险。
注意事项： 在层次化结构中，可以使用外观模式定义系统中每一层的入口。
二、外观模式场景展示（1）
我们将创建一个 Shape 接口和实现了 Shape 接口的实体类。下一步是定义一个外观类 ShapeMaker。
ShapeMaker 类使用实体类来代表用户对这些类的调用。FacadePatternDemo，我们的演示类使用 ShapeMaker 类来显示结果。
类图如下：
第一步： 创建一个接口
public interface Shape {
void draw();
}
第二步： 创建实现接口的实体类
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Rectangle::draw()");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Square::draw()");
}
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Circle::draw()");
}
}
第三步： 创建外观类
public class ShapeFacade {
private Shape circle;
private Shape rectangle;
private Shape square;
public ShapeFacade () {
circle = new Circle();
rectangle = new Rectangle();
square = new Square();
}
public void drawCircle(){
circle.draw();
}
public void drawRectangle(){
rectangle.draw();
}
public void drawSquare(){
square.draw();
}
}
第四步： 使用该外观类画出各种类型的形状。
public class FacadePatternDemo {
public static void main(String[] args) {
ShapeFacade shapeFacade = new ShapeFacade ();
shapeFacade .drawCircle();
shapeFacade .drawRectangle();
shapeFacade .drawSquare();
}
}
第五步： 执行效果
Circle::draw()
Rectangle::draw()
Square::draw()
三、外观模式场景展示（2）
场景描述： 给一个文件加密 ，三个步骤 ，读源文件，保存文件，加密文件。类图如下：
首先来子系统对象，需要做的就是它需要满足单一职责原则。其次，主要就是子系统的操作了 。
FileReader： 文件读取类，用来读取源文件，使用StringBuffer来完成因为字符串的不变性，所以需要用StringBuffer来解决。
package com.ssy.wlj.facade;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* 文件读取类，充当子系统
* @author Administrator
* @since 2019/05/22
*
*/
public class FileReader {
public String read(String fileName) {
System.out.println("读取文件，获取明文");
StringBuffer sb = new StringBuffer();
//读取文件
try {
FileInputStream inFS = new FileInputStream(fileName);
int data;
while((data=inFS.read())!=-1) {
sb=sb.append((char)data);
}
inFS.close();
System.out.println(sb.toString());
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return sb.toString();
}
}
CipherMachine： 加密类，就是将字符都取模7。模拟一下。
package com.ssy.wlj.facade;
/**
* 加密系统，模仿一下哦 。将对应的字符取模
* @author Administrator
* @since 2019/05/22
*
*/
public class CipherMachine {
public String encrypt(String plainText) {
System.out.println("数据加密，将明文转换为密文");
String es = "";
for(int i=0;i<plainText.length();i++) {
String c = String.valueOf(plainText.charAt(i)%7);
es+=c;
}
System.out.println(es);
return es;
}
}
FileWrite： 文件写入类，用来保存密文。
package com.ssy.wlj.facade;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 文件写入类，用来保存密文
* @author Administrator
* @since 2019/05/22
*
*/
public class FileWrite {
public void write(String encryptStr,String fileName) {
System.out.println("保存密文，写入文件");
try {
FileOutputStream outFs= new FileOutputStream(fileName);
outFs.write(encryptStr.getBytes());
outFs.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
EncryptFacade： 外观类，核心类。进行调用。省去自己调用的麻烦事。
package com.ssy.wlj.facade;
/**
* 外观者类
* @author Administrator
* @since 2019/05/22
*
*/
public class EncryptFacade {
//对子系统的引用
private FileReader fileReader;
private CipherMachine cipherMachine;
private FileWrite fileWrite;
public EncryptFacade() {
fileReader = new FileReader();
cipherMachine = new CipherMachine();
fileWrite = new FileWrite();
}
//调用子系统对象的业务方法》
public void fileEncrypt(String fileName,String fileNameDes) {
String plainStr = fileReader.read(fileName);
String encryptStr = cipherMachine.encrypt(plainStr);
fileWrite.write(encryptStr, fileNameDes);
}
}
Client: 客户类，通过外观类，得到我需要的。我就是要将一个没有加密的文件，读取以后进行加密然后保存
package com.ssy.wlj.facade;
/**
* 客户类
* @author Administrator
* @since 2019/05/22
*
*/
public class Client {
public static void main(String[] args) {
EncryptFacade ef = new EncryptFacade();
ef.fileEncrypt("src//facedePattern//test.txt","src//facedePattern//test_facade.txt" );
}
}
运行得到如下效果：
外观模式的优缺点及使用场景
优点：
它对客户端屏蔽了子系统的组件（可以直接调用外观模式），减少了系统的耦合度，使客户端所需要调用的所处理的类的数目减少，全让外观模式，小二去解决。简化客户端代码！
它实现了系统与客户端之间的松耦合关系，子系统的修改不会影响客户端代码，只要修改外观模式就好。
一个子系统的修改该对其它子系统没有任何影响，而且子系统内部变化也不会影响到外观模式。
缺点：
并不能限制客户端直接调用子系统，如果客户端对子系统类作太多限制则减少了可变形和灵活性。
如果设计不当，增加新的子系统就可能修改外观类的源代码，不符合开闭原则。
使用场景：
- 1、当客户端需要调用一系列复杂子系统时候，可以提供一个简单入口的时候使用外观模式。
- 2、客户端与子系统有很大的耦合性，使用外观模式可以充分解耦。
- 3、再层次化结构中可以使用外观模式的定义系统中每一层的入口，层与层之间不直接产生联系，而通过外观类建立联系，减低层与层之间的耦合。
