前言
一、“单一职责” 模式
在软件组件的设计中，如果责任划分的不清晰，使用继承得到的结果往往是随着需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任。
典型模式
Decorator
Bridge
二、Decorator 装饰模式
1、动机
在某些情况下我们可能会“过度地使用继承来扩展对象的功能”，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增多（扩展功能的增多），各种子类的组合（扩展功能的组合）会导致更多子类的膨胀。
如何使“对象功能的扩展”能够根据需要来动态地实现？同时避免“扩展功能的增多”带来的子类膨胀问题？从而使得任何“功能扩展变化”所导致的影响将为最低？
2、模式定义
动态（组合） 地给一个对象增加一些额外的职责。就增加功能而言，Decorator 模式比生成子类（继承）更为灵活（消除重复代码 & 减少子类个数）。
3、伪代码示例
有这样一种设计场景，需要设计一个 IO 库流操作，针对流操作我们有很多的需求，比如说文件流、网络流以及内存流，我们也有需要对流进行加密，对流进行缓存等等各种各样的操作。
①、第一种写法
decorator1.cpp
//decorator1.cpp //业务操作 class Stream{ public： virtual char Read(int number)=0; virtual void Seek(int position)=0; virtual void Write(char data)=0; virtual ~Stream(){} }; //文件流主体类 class FileStream: public Stream{ public: virtual char Read(int number){ //读文件流 } virtual void Seek(int position){ //定位文件流 } virtual void Write(char data){ //写文件流 } }; //网络流主体类 class NetworkStream :public Stream{ public: virtual char Read(int number){ //读网络流 } virtual void Seek(int position){ //定位网络流 } virtual void Write(char data){ //写网络流 } }; //内存流主体类 class MemoryStream :public Stream{ public: virtual char Read(int number){ //读内存流 } virtual void Seek(int position){ //定位内存流 } virtual void Write(char data){ //写内存流 } }; //扩展操作---加密操作 class CryptoFileStream :public FileStream{ public: virtual char Read(int number){ //额外的加密操作... FileStream::Read(number);//读文件流 静态特质，确定了只能调FileStream } virtual void Seek(int position){ //额外的加密操作... FileStream::Seek(position);//定位文件流 //额外的加密操作... } virtual void Write(byte data){ //额外的加密操作... FileStream::Write(data);//写文件流 //额外的加密操作... } }; class CryptoNetworkStream : :public NetworkStream{ public: virtual char Read(int number){ //额外的加密操作... NetworkStream::Read(number);//读网络流 静态特质，确定了只能调NetworkStream } virtual void Seek(int position){ //额外的加密操作... NetworkStream::Seek(position);//定位网络流 //额外的加密操作... } virtual void Write(byte data){ //额外的加密操作... NetworkStream::Write(data);//写网络流 //额外的加密操作... } }; class CryptoMemoryStream : public MemoryStream{ public: virtual char Read(int number){ //额外的加密操作... MemoryStream::Read(number);//读内存流 } virtual void Seek(int position){ //额外的加密操作... MemoryStream::Seek(position);//定位内存流 //额外的加密操作... } virtual void Write(byte data){ //额外的加密操作... MemoryStream::Write(data);//写内存流 //额外的加密操作... } }; class BufferedFileStream : public FileStream{ //... }; class BufferedNetworkStream : public NetworkStream{ //... }; class BufferedMemoryStream : public MemoryStream{ //... } // 加密缓冲操作 class CryptoBufferedFileStream :public FileStream{ public: virtual char Read(int number){ //额外的加密操作... //额外的缓冲操作... FileStream::Read(number);//读文件流 } virtual void Seek(int position){ //额外的加密操作... //额外的缓冲操作... FileStream::Seek(position);//定位文件流 //额外的加密操作... //额外的缓冲操作... } virtual void Write(byte data){ //额外的加密操作... //额外的缓冲操作... FileStream::Write(data);//写文件流 //额外的加密操作... //额外的缓冲操作... } }; void Process(){ //编译时装配 CryptoFileStream *fs1 = new CryptoFileStream(); BufferedFileStream *fs2 = new BufferedFileStream(); CryptoBufferedFileStream *fs3 = new CryptoBufferedFileStream(); }
涉及到的结构：
类的规模为：1 + n + n × m ! / 2
这份代码存在冗余，加密操作都是相同的，代码大量的重复。
②、第二种写法
重构
decorator2.cpp
//decorator2.cpp //业务操作 class Stream{ public： virtual char Read(int number)=0; virtual void Seek(int position)=0; virtual void Write(char data)=0; virtual ~Stream(){} }; //主体类 class FileStream: public Stream{ public: virtual char Read(int number){ //读文件流 } virtual void Seek(int position){ //定位文件流 } virtual void Write(char data){ //写文件流 } }; class NetworkStream :public Stream{ public: virtual char Read(int number){ //读网络流 } virtual void Seek(int position){ //定位网络流 } virtual void Write(char data){ //写网络流 } }; class MemoryStream :public Stream{ public: virtual char Read(int number){ //读内存流 } virtual void Seek(int position){ //定位内存流 } virtual void Write(char data){ //写内存流 } }; //扩展操作，继承自Stream，是为了符合虚函数的接口规范 class CryptoStream: public Stream { Stream* stream;//...new FileStream() / new NetworkStream() /... public: CryptoStream(Stream* stm) : stream(stm){ } virtual char Read(int number){ //额外的加密操作... stream->Read(number);//读文件流 动态特质，在运行时确定stream的具体类型 } virtual void Seek(int position){ //额外的加密操作... stream->Seek(position);//定位文件流 //额外的加密操作... } virtual void Write(byte data){ //额外的加密操作... stream->Write(data);//写文件流 //额外的加密操作... } }; class BufferedStream : public Stream{ Stream* stream;//... public: BufferedStream(Stream* stm) : stream(stm){ } //... }; void Process(){ //运行时装配 FileStream* s1=new FileStream(); CryptoStream* s2=new CryptoStream(s1); BufferedStream* s3=new BufferedStream(s1); BufferedStream* s4=new BufferedStream(s2); }
修改后的优点：将“继承”改成“对象组合"，使用多态，在运行时确定具体类型，“编译时装配"变成了"运行时装配”。
③、第三种写法
进一步优化：将相同字段提到一个新的基类 DecoratorStream 中：
//decorator3.cpp //业务操作 class Stream{ public： virtual char Read(int number)=0; virtual void Seek(int position)=0; virtual void Write(char data)=0; virtual ~Stream(){} }; //主体类 class FileStream: public Stream{ public: virtual char Read(int number){ //读文件流 } virtual void Seek(int position){ //定位文件流 } virtual void Write(char data){ //写文件流 } }; class NetworkStream :public Stream{ public: virtual char Read(int number){ //读网络流 } virtual void Seek(int position){ //定位网络流 } virtual void Write(char data){ //写网络流 } }; class MemoryStream :public Stream{ public: virtual char Read(int number){ //读内存流 } virtual void Seek(int position){ //定位内存流 } virtual void Write(char data){ //写内存流 } }; //扩展操作 class DecoratorStream: public Stream{ protected: Stream* stream;//... DecoratorStream(Stream* stm) : stream(stm){ } }; class CryptoStream: public DecoratorStream { public: CryptoStream(Stream* stm): DecoratorStream(stm) { } virtual char Read(int number){ //额外的加密操作... stream->Read(number);//读文件流 } virtual void Seek(int position){ //额外的加密操作... stream->Seek(position);//定位文件流 //额外的加密操作... } virtual void Write(byte data){ //额外的加密操作... stream->Write(data);//写文件流 //额外的加密操作... } }; class BufferedStream : public DecoratorStream{ public: BufferedStream(Stream* stm):DecoratorStream(stm){ } //... }; void Process(){ //运行时装配 FileStream* s1=new FileStream(); CryptoStream* s2=new CryptoStream(s1); // 加密操作 BufferedStream* s3=new BufferedStream(s1); // 缓冲操作 BufferedStream* s4=new BufferedStream(s2); // 加密缓冲操作 }
此时类关系：
类的规模：1 + n + 1 + m
4、结构
【注】：
Component -> Stream (稳定)
Decorator -> DecoratorStream （稳定）
ConcreteComponent -> FileStream/NetworkStream/… （变化）
ConcreteDecoratorX-> CryptoStream / BufferedStream (变化)
总结
通过采用组合而非继承的手法，Decorator 模式实现了在运行时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用继承带来的“灵活性差”和“多子类衍生问题”。
Decorator 类在接口上表现为 is-a Component 的继承关系，即 Decorator 类继承了 Component 类所具有的接口。但在实现上又表现为 has-a Component 的组合关系，即 Decorator 类又使用了另外一个 Component 类。【注：DecoratorStream 类继承自 Stream，同时又有一个 Stream 类型的字段，一般这种既继承又组合的方式通常都是装饰模式。例子中的继承是为了完善接口的规范，组合是为了支持实现具体的类】
Decorator 模式的目的并非解决“多子类衍生的多继承”问题，Decorator 模式应用的要点在于解决“主体类在多个方向上的扩展功能”——是为“装饰”的含义。
————————————————
版权声明：本文为CSDN博主「p-明天，你好！」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_41839588/article/details/130642133
