设计模式--装饰者模式
考虑程序要对一类 流 (网络流,IO流等等)进行操作。进行什么操作呢?可能在读(Read)这个流的时候对这个流进行加密,也可能对这个流进行缓存。
那么很自然的能设计出以下这些类
class Stream { public: void Read(); }; class IOStream : public Stream {}; // 输入输出流 class NetStream: public Stream {}; // 网络流 class BufferedIOStream : public IOStream { public: void Read() { // 实现了缓存功能的读操作 Buffer(); IOStream::Read(); } void Buffer() {} }; class EncryptIOStream : public IOStream { public: void Read() { // 实现了加密功能的读操作 Encrypt(); IOStream::Read(); } void Encrypt(); } // 实现加密和缓存功能的输入输出流 class BufferedEncryptIOStream : public EncryptIOStream, public BufferedIOStream { public: void Read() { EncryptIOStream::Encrypt(); BufferedIOStream::Read(); } }; // 网络流同理 class BufferedNetStream : public NetStream ......
那么这样做的缺点有什么呢?试想一下,如果我现在要对流增加新的操作,比如说要将流输出。你可能会有如下设计
class PrintIOStream : public IOStream { public: void Read() { Print(); IOStream::Read(); } void Print(); } class BufferedPrintIOStream : public BufferedIOStream, public PrintIOStream { // 既可以加密有可以缓存的流 public: void Read() { PrintIOStream::Print(); BufferedIOStream::Read(); } }; class EncryptPrintIOStream : public EncryptIOStream, public PrintIOStream {}; // 既可以加密有可以打印的IO流 class BufferedEncryptPrintIOStream : public BufferedPrintIOStream, public EncryptPrintIOStream {};
哇靠,有没有搞错!只不过是要求增加了一个新的打印的功能,结果多出了这么多的类。如果继续增加新功能的话,类的数量之多可想而知。这种现象被称作类爆炸。
当然了,你也可以说只设计一个BufferedEncryptPrintIOStream。但是假如你某个时刻不需要打印功能的话,那么打印功能就是累赘,这显然违背了接口隔离原则
这时候就需要一种更好的设计方法----装饰者模式
试想一下,如果我们通过组合的方式来设计类会不会有上述问题呢?答案是不会。
// 装饰者模式一瞥 class BufferedStream : public Stream { public: BufferedStream(Stream* stm) : stream(stm) {} void Read() {
Buffer();
myStream->Read();
}
void Buffer(); private: Stream* myStream; };
嗯?这个类怎么这么奇怪,又是继承了Stream,里面又包含了一个Stream。这其实就是装饰者模式的精髓。之所以继承是因为BufferedStream首先是个流,它可能有一些Stream通用的性质。而为什么它的成员函数也包含个Stream对象?请注意,这里的Stream是一个指针,对c++敏感的朋友可能已经意识到了指针意味着可以动态绑定。那么我们看看如何使用这个BufferedStream以实现上述的各种功能
// 如果我们想要一个缓冲的IO流 IOStream* stm = new IOStream(); BufferedStream* bufferedStm = new BufferedStream(stm); bufferedStm->Read(); // 如果我们要一个缓冲的加密的IO流 EncryptStream* encryptStream = new EncryptStram(new IOStream); BufferedStream* bufEncStream = new BufferedStream(encryptStream); bufEncStream->Read();
是不是觉得很神奇?关键点在于对流的层层包装,比如说先把流包装成可打印的流,那么它就能实现打印的功能了。在这个基础上把它包装成缓存流,那么它既有缓存功能有有打印功能。如果需要更多的功能怎么办?继续包装就是了。这样子就无需为新的功能拓展类,从而避免了类爆炸的问题
以上就是装饰者模式,接下来给出装饰者模式的完整设计代码
class Stream { public: void Read(); }; class IOStream : public Stream {}; class PrintStream : Stream { public: PrintStream(Stream* stm) : myStream(stm) {} void Read() { Print(); myStream->Read(); } void Print() {} private: Stream* myStream; }; class BufferedStream : Stream { public: BufferedStream(Stream* stm) : myStream(stm) {} void Read() { Buffer(); myStream->Read(); } void Buffer(); private: Stream* myStream; }; class EncryptStream : Stream { public: EncryptStream(Stream* stm) : myStream(stm) {} void Read() { Encrypt(); myStream->Read(); } void Encrypt(); private: Stream* myStream; } // 只需这几个类就能完成所有需要的功能,接下来看看使用方法 IOStream* iostm = new IOStream(); BufferedStream* bufferedPrintEncryptStream = new BufferedStream(new PrintStream(new EncryptStream(iostm)));
更近一步。细心的朋友可能已经发现了三个类中都有一个myStream成员,那么能优化的是将myStream放在一个新的类中,然后让这三个类继承这个新的类
class MyStream : Stream {
public:
MyStream(Stream* stm) : myStream(stm) {}
private:
Stream* myStream;
}
以上就是装饰者模式的所有内容