Java设计模式（三） 之结构型模式（外观模式）

一、外观模式简介

外观模式（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、再层次化结构中可以使用外观模式的定义系统中每一层的入口，层与层之间不直接产生联系，而通过外观类建立联系，减低层与层之间的耦合。