定义
动态地给一个对象添加一些额外的职责,就增加功能来说,装饰模式比生成子类更为灵活。装饰模式属于结构型模式,它是作为现有的类的一个包装。
案例
我们有一系列的流式读写操作,如文件流、网络流、内存流等等。
class Stream {
public:
virtual ~Stream() {}
virtual char read(int num) = 0;
virtual void write(char data) = 0;
};
class FileStream : public Stream {
public:
virtual ~FileStream() {}
virtual char read(int num)
{
// FileStream read operation
}
virtual void write(char data)
{
// FileStream write operation
}
};
class NetStream : public Stream {
public:
virtual ~NetStream () {}
virtual char read(int num)
{
// NetStream read operation
}
virtual void write(char data)
{
// NetStream write operation
}
};
class MemoryStream : public Stream {
public:
virtual ~MemoryStream () {}
virtual char read(int num)
{
// MemoryStream read operation
}
virtual void write(char data)
{
// MemoryStream write operation
}
};
上述各子类对应不同的流操作,我们可以按照需求直接使用这些子类生成对象:
void main()
{
Stream *s = new FileStream;
s->write('x');
delete s;
}
如果我们还需要别的功能,比如对数据流进行加密、缓存等操作,我们可能会写出如下代码:
class CryptoFileStream : public FileStream {
public:
char read(int num) {
char c = FileStream::read(num);
// 执行一些加密操作
return c;
}
void write(char data) {
// 执行一些加密操作
FileStream::write(data);
}
};
class CryptoNetStream : public NetStream{
public:
char read(int num) {
char c = NetStream::read(num);
// 执行一些加密操作
return c;
}
void write(char data) {
// 执行一些加密操作
NetStream::write(data);
}
};
class CryptoMemoryStream : public MemoryStream {
public:
char read(int num) {
char c = MemoryStream::read(num);
// 执行一些加密操作
return c;
}
void write(char data) {
// 执行一些加密操作
MemoryStream::write(data);
}
};
事实上,上述这些加密过程是完全一样的,但是却为此创建了三个子类。有没有办法减少子类的创建呢?请看如下方式:
// 装饰基类
class DecoratorStream {
protected:
Stream* _stream;
DecoratorStream(Stream* stream) : _stream(stream) {}
};
// 带加密功能的装饰器
class CryptoStream : public DecoratorStream {
public:
CryptoStream(Stream* stream) : DecoratorStream(stream) {}
char read(int num) {
char c = _stream->read(num);
// 执行一些加密操作
return c;
}
void write(char data) {
// 执行一些加密操作
_stream->write(data);
}
};
可以看到,在使用装饰模式后,子类的个数减少到了一个(不包括装饰器基类)。其原理就是利用多态特性,将read、write操作的具体行为延迟到了运行期。而在这之前,我们是在编译期就确定了。使用方式如下:
void main()
{
Stream *s1 = new FileStream;
s1->write('x');
CryptoStream* cs1 = new CryptoStream(s1); // 此时就拥有了具有加密功能的文件流对象
char c = cs1->read(0);
Stream *s2 = new NetStream;
CryptoStream* cs2 = new CryptoStream(s2); // 此时就拥有了具有加密功能的网络流对象
cs2->write('y');
delete cs2;
delete s2;
delete cs1;
delete s1;
}
事实上,在不使用装饰模式的时候,我们的主体功能(文件流、网络流、内存流等)在扩展其他功能的时候(加密、解密、缓存等),其扩展的方式如下:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LBqEGAbH-1721228204488)(https://i-blog.csdnimg.cn/direct/387432e0ac9744f3a01d670a082761b5.png)]
这里的1+n+n*m!/2代表的是类的个数,n代表主体功能,m代表扩展功能。可见在只使用继承的方式时,衍生出大量的子类。而使用装饰模式之后,其扩展方式如下:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OUhSfMFS-1721228204491)(https://i-blog.csdnimg.cn/direct/38b721e2ecd84abcb9498028846a723b.png)]
其中,扩展功能(装饰类)直接继承Stream类,因此扩展功能和主体功能的扩展是两个不同的方向,新增扩展功能时,只需要添加一个子类即可。
类图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O0m0n9qQ-1721228204492)(https://i-blog.csdnimg.cn/direct/8158715851b248a3a323da68b1b53fd7.png)]
对比类图,Componet就是Stream基类,ConcretComponet是一些基础的流操作类(文件流、网络流等),Decorator就是装饰器基类,ConcretDecorator就是具体功能的装饰类(如加密、解密、缓存等)。
总结
- 通过使用组合而非继承的方式,实现了运行时动态扩展对象功能的能力,并且根据需要可以扩展多个功能,避免继承带来的灵活性差和多子类衍生的问题。
- 装饰类在接口上表现为is-a Component的继承关系,继承了Component的所有接口。但是在实现上,又表现为has-a的组合关系,即装饰类又使用了另一个Componet类。
- 装饰模式并非单纯为了解决多子类衍生的问题,而是解决主体在多个方向上扩展功能的问题。