单一职责_Decorator

作者出版于 design_patterns

2023-07-15 约 1060 字预计阅读 3 分钟

组件协作模式

在软件组件的设计中，如果责任划分的不清晰，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任。典型模式: Decorator, Bridge

1 Decorator 装饰模式

1.1 模式动机

在某些情况下我们可能会“过度地使用继承来扩展对象的功能”，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性：并旦随着子类的增多(扩展功能的增多)，各种子类的组合 (扩展功能的组合)会导致更多子类的膨胀。

如何使“对象功能的扩展”能够根据需要来动态地实现？同时避免扩展功能的增多“带来的子类膨胀问题？从而使得任何“功能扩展变化”所导致的影响将为最低？

1.2 模式定义

动态（组合）地给一个对象增加一些额外的职责。就增加功能而言，Decorator 模式比生成子类（继承）更为灵活（消除重复代码＆减少子类个数）。

1.3 模式示例代码

# include <iostream>
# include <string>

// 定义抽象基类，表示流操作
class Stream {
public:
    virtual void read() = 0;
    virtual void write() = 0;
};

// 具体流类：文件流
class FileStream : public Stream {
public:
    void read() {
        std::cout << "从文件中读取数据" << std::endl;
    }

    void write() {
        std::cout << "向文件中写入数据" << std::endl;
    }
};

// 具体流类：网络流
class NetworkStream : public Stream {
public:
    void read() {
        std::cout << "从网络中读取数据" << std::endl;
    }

    void write() {
        std::cout << "向网络中写入数据" << std::endl;
    }
};

// 具体流类：内存流
class MemoryStream : public Stream {
public:
    void read() {
        std::cout << "从内存中读取数据" << std::endl;
    }

    void write() {
        std::cout << "向内存中写入数据" << std::endl;
    }
};

// 装饰器抽象基类
class StreamDecorator : public Stream {
protected:
    Stream* stream;

public:
    StreamDecorator(Stream* stream) : stream(stream) {}

    void read() {
        stream->read();
    }

    void write() {
        stream->write();
    }
};

// 具体装饰器类：加密装饰器
class EncryptionDecorator : public StreamDecorator {
public:
    EncryptionDecorator(Stream* stream) : StreamDecorator(stream) {}

    void read() {
        std::cout << "进行加密解密操作" << std::endl;
        stream->read();
    }

    void write() {
        std::cout << "进行加密操作" << std::endl;
        stream->write();
    }
};

int main() {
    // 创建文件流对象
    Stream* fileStream = new FileStream();
    fileStream->read();
    fileStream->write();
    std::cout << std::endl;

    // 创建网络流对象
    Stream* networkStream = new NetworkStream();
    networkStream->read();
    networkStream->write();
    std::cout << std::endl;

    // 创建内存流对象
    Stream* memoryStream = new MemoryStream();
    memoryStream->read();
    memoryStream->write();
    std::cout << std::endl;

    // 创建加密文件流对象
    Stream* encryptedFileStream = new EncryptionDecorator(new FileStream());
    encryptedFileStream->read();
    encryptedFileStream->write();
    std::cout << std::endl;

    // 创建加密网络流对象
    Stream* encryptedNetworkStream = new EncryptionDecorator(new NetworkStream());
    encryptedNetworkStream->read();
    encryptedNetworkStream->write();
    std::cout << std::endl;

    // 创建加密内存流对象
    Stream* encryptedMemoryStream = new EncryptionDecorator(new MemoryStream());
    encryptedMemoryStream->read();
    encryptedMemoryStream->write();

    // 释放内存
    delete fileStream;
    delete networkStream;
    delete memoryStream;
    delete encryptedFileStream;
    delete encryptedNetworkStream;
    delete encryptedMemoryStream;

    return 0;
}

2 要点总结

通过采用组合而非继承的手法，Decorator 模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承带来的“灵活性差”和“多子类衍生问题”。

Decorator 类在接口上表现为 is-a Component 的继承关系，即 Decorator 类继承了 Component 类所具有的接口。但在实现上又表现为 has-a Component 的组合关系，即 Decorator 类又使用了另外 —个 Component 类。

Decorator 模式的目的并非解决“多子类行生的多继承”问题， Decorator 模式应用的要点在于解决“主体类在多个方向上的扩展功能”——是为“装饰”的含义。

目录