设计模式(10) 外观模式(FACADE)

最新推荐文章于 2024-06-03 15:45:54 发布

_suzhou

最新推荐文章于 2024-06-03 15:45:54 发布

阅读量1.3k

点赞数

分类专栏：设计模式文章标签：设计模式外观模式

本文链接：https://blog.csdn.net/zs634134578/article/details/18967567

版权

设计模式专栏收录该内容

14 篇文章 1 订阅

订阅专栏

问题聚焦：

设计一个系统时，比较常见的做法是将它划分为若干个小的系统，互相协作，组成一个大的系统。

那么，在设计这些小系统时，需要注意一些什么呢？

外观模式为什么可以让子系统更加容易的使用呢？（最小化子系统之间的通信和相互依赖关系，即降低耦合度）

意图：

为子系统中的一组接口提供一个一致的界面。Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

动机：

将一个系统划分为若干个子系统有利于降低系统的复杂性。

一个常见的设计目标是使子系统间的通信和相互依赖关系达到最小。

达到该目标的途径之一就是引入一个外观对象，它为子系统中较一般的设施提供了一个单一而简单的界面。

其思想如下图所示：

Demo：以编译器子系统的设计为例，说明外观模式的思想：

子系统类划分：Scanner, Parser, ProgramNode, BytecodeStream, ProgramNodeBuilder

要求：对普通用户提供一个高层的，单一而简单的编译子系统接口

对高级专业的用户提供底层功能，可以直接访问具体的子系统类。

设计：

Compiler类（关键），其职责为两点：

1）为用户屏蔽子系统，提供一个高层的简单的使用接口；

2）不完全隐藏实现编译功能的那些子系统类，使得少数懂的如何使用底层功能的人可以调用这些功能。

适用性：

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

为一个复杂子系统提供一个简单接口。
客户程序与抽象类的实现部分之间存在很大的依赖性。
当你需要构件一个层次结构的子系统时，使用facade模式定义子系统中每层的入口点。如果子系统之间是相互依赖的，可以让它们仅通过facade进行通讯，从而简化了它们之间的依赖关系。

结构：

参与者：

Facade（Compiler）：
- 知道哪些子系统类负责处理请求；
- 将客户的请求代理给适当的子系统对象。
Subsystem classes（Scanner, Parser, ProgramNode）：
- 实现子系统的功能；
- 处理由Facade对象指派的任务；
- 没有Facade的任何相关信息。

协作：

客户程序通过发送请求给Facade与子系统通讯，Facade将这些消息转发给适当的子系统对象。
使用Facade的客户程序不需要直接访问子系统对象

效果（优点）：

对客户屏蔽子系统组件，减少了客户处理的对象的数目，并使得子系统使用起来更加方便
实现了子系统与客户之间的耦合关系，而子系统内部的功能组件往往是紧耦合的。松耦合关系使得子系统的组件变化不会影响到它的客户。具体如下：
- Facade模式有助于建立层次结构系统
- 有助于对对象之间的依赖关系分层
- 消除复杂的循环依赖关系
- 降低编译依赖性，限制重要系统中较小的变化所需要的重编译工作
有利于简化系统在不同平台之间的移植过程
如果应用需要，它并不限制它们使用子系统类。因此你可以在系统易用性和通用性之间加以选择。

实现：

降低客户-子系统之间的耦合度：两种方式
- 用抽象类实现Facade而它的具体子类对应不同的子系统实现，这可以进一步降低客户与子系统的耦合度
- 用不同的子系统对象配置Facade，仅需要对它的子系统对象进行替换即可
公共子系统类与私有子系统类：
- 用类的思想思考子系统：一个子系统与一个类的相似之处是，它们都有接口并且它们都封装了一些东西——类封装了状态和操作，而子系统封装了一些类。
- 子系统的公共接口包含所有的客户程序可以访问的类
- 子系统的私有接口仅用于对子系统进行扩充和维护
- Facade类是公共接口的一部分，但它不是唯一的部分，子系统的其他部分通常也是公共的

代码示例：

以上面所提到的编译器子系统为例。

类设定：

BytecodeStream类，实现了一个Bytecode对象流。

Bytecode对象封装了一个字节码，这个字节码可用于指定机器指令。

Token类，封装了编程语言中的标识符

Scanner类，接收字符流并产生一个标识符流，一次产生一个标识符（token）。

class Scanner 
{
public:
    Scanner(istream&);
    virtual ~Scanner();

    virtual Token& Scan();

private:
    istream& _inputStream;
};

Parser：Parser类由Scanner生成的标识符构件一棵语法分析树。

class Parser
{
public:
    Parser();
    virtual ~Parser();

    virtual void Parse(Scanner&, ProgramNodeBuilder&);
};

ProgramNodeBuilder：建立语法树，遵循 Builder模式的交互式操作。

class ProgramNodeBuilder
{
public:
    ProgramNodeBuilder();

    virtual ProgramNode* NewVariable (
         const char* variableName
     ) const;

    virtual ProgramNode* NewAssignment (
        ProgramNode* variable, ProgramNode* expression
    ) const;

    virtual ProgramNode* NewRetrurnStatement (
        ProgramNode* value
    ) const;

    virtual ProgramNode* NewCondition (
        ProgramNode* condition, 
        ProgramNode* truePart, 
        ProgramNode* falsePart
    ) const;

    ProgramNode* _node;

private:
    ProgramNode* _node;
};

ProgramNode：语法树由ProgramNode子类（StatementNode和ExpressionNode）的实例构成，定义了一个接口用于操作程序节点和它的子节点。ProgramNode层次结构是组合模式（Composite）的一个应用实例。

class ProgramNode {
public:
    virtual void GetSourcePositon(int& line, int& index);

    virtual void Add(ProgramNode*);
    virtual void Remove(ProgramNode*);
    
    virtual void Traverse(CodeGenerator&);
protected:
    ProgramNode();
};

Traverse：以一个CodeGenerator对象为参数，ProgramNode子类使用这个对象产生机器代码，机器代码格式为BytecodeStream中的ByteCode对象。
CodeGenerator：一个访问者（访问者模式），有两个子类StackMachineCodeGenerator和RISCCodeGenerator，分别为不同的硬件体系结构生成机器代码。

class CodeGenerator {
public:
    virtual void Visit(StatementNode*);
    virtual void Visit(ExpressionNode*);

protected:
    CodeGenerator(BytecodeStream&);
protected:
    BytecodeStream& _output;
};

ExpressionNode：ProgramNode的每个子类在实现Traverse时，对它的ProgramNode子对象调用Traverse。每个子类一次对它的子节点做同样的动作。这样递归下去。

void ExpressionNode::Traverse (CodeGenerator& cg)
 {
    cg.Visit(this);
    ListIterator<ProgramNode*> i(_children);

    for (i.First(); !i.IsDone(); i.Next()) 
    {
        i.CurrentItem()->Traverse(cg);
    }
}

上面这些类构成了编译子系统。

引用Compiler类，将所有的部件集成在一起。Compiler提供了一个简单的接口为特定的机器编译源代码并生成可执行代码。

class Compiler
{
public:
    Compiler();
    virtual void Compile(istream&, BytecodeStream);
};

void Compiler::Compile(istream& input, BytecodeStream& output)
{
    Scanner scanner(input);
    ProgramNodeBuilder builder;
    Parser parser;

    parser.Parse(scanner, builder);
    RISCCodeGenerator generator(builder);
    ProgramNode* parseTree = builder.GetRootNode();
    parserTree->Traverse(generator);
}