1. “单一职责”模式
- 在软件组件的设计中,如果责任划分的不清晰,使用继承得到的结果往往是随着需求的变化,子类急剧膨胀,同时充斥着重复代码,这时候的关键是划清责任。
- 典型模式
- Decorator
- Bridge
2. Decorator 装饰模式
2.1 动机(Motivation)
- 在某些情况下我们可能会 “过度地使用继承来扩展对象的功能”,由于继承为类型引入的静态特质,使得这种扩展方式缺乏灵活性;并且随着子类的增多(扩展功能的增多),各种子类的组合(扩展功能的组合)会导致更多子类的膨胀。
- 如何使 “对象功能的扩展” 能够根据需要来动态地实现?同时避免 “扩展功能的增多” 带来的子类膨胀问题?从而使得任何 “功能扩展变化” 所导致的影响降为最低?
2.2 模式定义
动态(组合)地给一个对象增加一些额外的职责。就增加功能而言,Decorator 模式比生成子类(继承)更为灵活(消除重复代码&减少子类个数)。
——《设计模式》GoF
2.3 实例代码
2.3.1 decorator1
// 流基类
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); // 读文件流,调用父类函数}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); // 读网络流,调用父类函数}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();}
2.3.2 decorator2
// 流基类
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 CryptoStream : public Stream {Stream* stream; // ... 组合形式,Stream是个抽象类,不是一个具体的类public:// 构造函数CryptoStream(Stream* stm) : stream(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 Stream {Stream* stream; // ... 组合形式public:BufferedStream(Stream* stm) : stream(stm) {}//...
};void Process() {// 运行时装配,在运行时才确认具体类型FileStream* s1 = new FileStream();CryptoStream* s2 = new CryptoStream(s1); // s2中的stream绑定FileStream类型BufferedStream* s3 = new BufferedStream(s1); // s3中的stream绑定FileStream类型BufferedStream* s4 = new BufferedStream(s2); // s4中的stream绑定CryptoStream类型
}
2.3.3 decorator3
// 流基类
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) {// 写内存流}
};/******************** 扩展操作 ********************/
// 装饰器流类
DecoratorStream : public Stream {
protected:Stream* 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);
}
2.4 结构(Structure)
2.5 要点总结
- 通过采用
组合
而非继承的手法,Decorator 模式实现了在运行时动态扩展对象功能的能力,而且可以根据需要扩展多个功能。避免了使用继承带来的 “灵活性差” 和 “多子类衍生问题”。 - Decorator 类在接口上表现为
is-a
Component 的继承关系,即 Decorator 类继承了 Component 类所具有的接口。但在实现上又表现为has-a
Component 的组合关系,即 Decorator 类又使用了另外一个 Component 类。 - Decorator 模式的目的并非解决 “多子类衍生的多继承” 问题,Decorator 模式应用的要点在于解决 “主体类在多个方向上的扩展功能” —— 是为 “装饰” 的含义。