第13章外观模式

13.1 外观模式概述

外观模式（Facade Pattern）：为子系统中的一组接口提供一个统一的入口。外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

门面模式
对象结构型模式

13.2 外观模式结构与实现

13.2.1 外观模式结构

Facade（外观角色）：在客户端可以调用它的方法，在外观角色中可以知道相关的（一个或者多个）子系统的功能和责任；在正常情况下，它将所有从客户端发来的请求委派到相应的子系统，传递给相应的子系统对象处理。
SubSystem（子系统角色）：在软件系统中可以有一个或者多个子系统角色，每一个子系统可以不是一个单独的类，而是一个类的集合，它实现子系统的功能；每一个子系统都可以被客户端直接调用，或者被外观角色调用，它处理由外观类传过来的请求；子系统并不知道外观的存在，对于子系统而言，外观角色仅仅是另外一个客户端而已。

13.2.2 外观模式实现

子系统可以是一个类，一个功能模块，系统组成部分或者一个完整的系统。
SubSystem（子系统角色）：

public class SubSystemA {
    public void methodA() {
        //业务实现代码
    }
}

public class SubSystemB {
    public void methodB() {
        //业务实现代码
    }
}

public class SubSystemC {
    public void methodC() {
        //业务实现代码
    }
}

Facade（外观角色）

public class Facade {
    private SubSystemA obj1 = new SubSystemA();
    private SubSystemB obj2 = new SubSystemB();
    private SubSystemC obj3 = new SubSystemC();

    public void method() {
        obj1.methodA();
        obj2.methodB();
        obj3.methodC();
    }
}

public class Client {
    public static void main(String args[]) {
        Facade facade = new Facade();
        facade.method();
    }
}

13.3 外观模式应用实例

实例说明

某软件公司要开发一个可应用于多个软件的文件加密模块，该模块可以对文件中的数据进行加密并将加密之后的数据存储在一个新文件中，具体的流程包括3个部分，分别是读取源文件、加密、保存加密之后的文件，其中读取文件和保存文件使用流来实现，加密操作通过求模运算实现。这3个操作相对独立，为了实现代码的独立重用，让设计更符合单一职责原则，这3个操作的业务代码封装在3个不同的类中。
现使用外观模式设计该文件加密模块。

实例类图

外观类
- EncryptFacade
子系统类
- FileReader
- CipherMachine
- FileWriter

实例代码

FileReader：文件读取类，充当子系统类。

package designpatterns.facade;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileReader {
    public String read(String fileNameSrc) {
        System.out.print("读取文件,获取明文:");
        StringBuffer sb = new StringBuffer();
        try {
            FileInputStream inFS = new FileInputStream(fileNameSrc);
            int data;
            while ((data = inFS.read()) != -1) {
                sb = sb.append((char) data);
            }
            inFS.close();
            System.out.println(sb.toString());
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在!");
        } catch (IOException e) {
            System.out.println("文件操作错误!");
        }
        return sb.toString();
    }
}

CipherMachine：数据加密类，充当子系统类。

package designpatterns.facade;

public class CipherMachine {
    public String encrypt(String plainText) {
        System.out.print("数据加密,将明文转换为密文:");
        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;
    }
}

FileWriter：文件保存类，充当子系统类。

package designpatterns.facade;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileWriter {
    public void write(String encryptStr, String fileNameDes) {
        System.out.print("保存密文,写入文件.");
        try {
            FileOutputStream outFS = new FileOutputStream(fileNameDes);
            outFS.write(encryptStr.getBytes());
            outFS.close();
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在!");
        } catch (IOException e) {
            System.out.println("文件操作错误!");
        }
    }
}

EncryptFacade：加密外观类，充当外观类。

package designpatterns.facade;

public class EncryptFacade {
    //维持对子系统对象的引用
    private FileReader reader;
    private CipherMachine cipher;
    private FileWriter writer;

    public EncryptFacade() {
        reader = new FileReader();
        cipher = new CipherMachine();
        writer = new FileWriter();
    }

    //调用子系统对象的业务方法
    public void fileEncrypt(String fileNameSrc, String fileNameDes) {
        String plainStr = reader.read(fileNameSrc);
        String encryptStr = cipher.encrypt(plainStr);
        writer.write(encryptStr, fileNameDes);
    }
}

Client：客户端测试类。

package designpatterns.facade;

public class Client {
    public static void main(String[] args) {
        EncryptFacade ef = new EncryptFacade();
        ef.fileEncrypt("src//designpatterns//facade//src.txt",
                "src//designpatterns//facade//des.txt");
    }
}

结果及分析

13.4 抽象外观类

在标准的外观模式结构图中，如果需要增加、删除或更换与外观类交互的子系统类，必须修改外观类或客户端的源代码，这将违背开闭原则，因此可以通过引入抽象外观类对系统进行改进，这在一定程度上可以解决该问题。在引人抽象外观类之后,客户端可以针对抽象外观类进行编程，对于新的业务需求，不需要修改原有外观类，而对应增加一个新的具体外观类，由新的具体外观类来关联新的子系统对象，同时通过修改配置文件来达到不修改任何源代码并更换外观类的目的。

举例：增加一个新加密类

NewCipherMachine

package designpatterns.facade;

public class NewCipherMachine {
    public String encrypt(String plainText) {
        System.out.print("数据加密,将明文转换为密文:");
        String es = "";
        int key = 10;//设置密钥，移位数是10
        for (int i = 0; i < plainText.length(); i++) {
            char c = plainText.charAt(i);
            //小写字母移位
            if (c >= 'a' && c <= 'z') {
                c += key % 26;
                if (c > 'z') c -= 26;
                if (c < 'a') c += 26;
            }
            //大写字母移位
            if (c >= 'A' && c <= 'Z') {
                c += key % 26;
                if (c > 'Z') c -= 26;
                if (c < 'A') c += 26;
            }
            es += c;
        }
        System.out.println(es);
        return es;
    }
}

三种解决方法：

修改原有外观类 EncryptFacade；
增加一个新的外观类 NewEncryptFacade 与 FileReader 类、FileWriter 类以及新增NewCipherMachine交互；
引起抽象外观类。

原本的具体加密外观类 EncryptFacade：

package designpatterns.facade;

public class EncryptFacade extends AbstractEncryptFacade{
    //维持对子系统对象的引用
    private FileReader reader;
    private CipherMachine cipher;
    private FileWriter writer;

    public EncryptFacade() {
        reader = new FileReader();
        cipher = new CipherMachine();
        writer = new FileWriter();
    }

    //调用子系统对象的业务方法
    public void fileEncrypt(String fileNameSrc, String fileNameDes) {
        String plainStr = reader.read(fileNameSrc);
        String encryptStr = cipher.encrypt(plainStr);
        writer.write(encryptStr, fileNameDes);
    }
}

新增具体加密外观类 NewEncryptFacade：

package designpatterns.facade;

public class NewEncryptFacade extends AbstractEncryptFacade{
    //维持对子系统对象的引用
    private FileReader reader;
    private NewCipherMachine cipher;
    private FileWriter writer;

    public NewEncryptFacade() {
        reader = new FileReader();
        cipher = new NewCipherMachine();
        writer = new FileWriter();
    }

    //调用子系统对象的业务方法
    public void fileEncrypt(String fileNameSrc, String fileNameDes) {
        String plainStr = reader.read(fileNameSrc);
        String encryptStr = cipher.encrypt(plainStr);
        writer.write(encryptStr, fileNameDes);
    }
}

配置文件config.xml中存储了具体外观类的类名：

<?xml version="1.0"?>
<config>
    <className>designpatterns.facade.NewEncryptFacade</className>
</config>

通过工具类XMLUtil读取配置文件config. xml并反射生成对象：

package designpatterns.facade;

public class NewEncryptFacade {
    //维持对子系统对象的引用
    private FileReader reader;
    private NewCipherMachine cipher;
    private FileWriter writer;

    public NewEncryptFacade() {
        reader = new FileReader();
        cipher = new NewCipherMachine();
        writer = new FileWriter();
    }

    //调用子系统对象的业务方法
    public void fileEncrypt(String fileNameSrc, String fileNameDes) {
        String plainStr = reader.read(fileNameSrc);
        String encryptStr = cipher.encrypt(plainStr);
        writer.write(encryptStr, fileNameDes);
    }
}

客户端测试：

package designpatterns.facade;

public class Client {
    public static void main(String[] args) {
        AbstractEncryptFacade ef;//针对抽象外观类编程
        //读取配置文件，反射生成对象
        ef = (AbstractEncryptFacade) XMLUtil.getBean();
        ef.fileEncrypt("src//designpatterns//facade//src.txt",
                "src//designpatterns//facade//newdes.txt");
    }
}

13.5 外观模式优/缺点与适用环境

13.5.1 外观模式优点

它对客户端屏蔽了子系统组件，减少了客户端所需处理的对象数目，并使子系统使用起来更加容易。通过引入外观模式，客户端代码将变得很简单，与之关联的对象也很少。
它实现了子系统与客户端之间的松耦合关系，这使得子系统的变化不会影响到调用它的客户端，只需要调整外观类即可。
一个子系统的修改对其他子系统没有任何影响，而且子系统内部变化也不会影响到外观对象。

13.5.2 外观模式缺点

不能很好地限制客户端直接使用子系统类，如果对客户端访问子系统类做太多的限制则减少了可变性和灵活性。
如果设计不当，增加新的子系统可能需要修改外观类的源代码，违背了开闭原则。

13.5.3 外观模式适用环境

当要为访问一系列复杂的子系统提供一个简单人口时可以使用外观模式。
客户端程序与多个子系统之间存在很大的依赖性。引人外观类可以将子系统与客户端解耦，从而提高子系统的独立性和可移植性。
在层次化结构中可以使用外观模式定义系统中每一层的入口，层与层之间不直接产生联系，而通过外观类建立联系，降低层之间的耦合度。

posted @ 2022-04-13 20:49 手持六脉神剑的外星人阅读(42) 评论(0) 编辑收藏举报

刷新页面返回顶部

手持六脉神剑的外星人

第13章 外观模式