不一样的装饰器模式(设计模式二)
前言
我是一名博客园的博主,目前排名第199675位,虽然排名稍稍落后,但这并不影响我向大家学习然后自己吹水。
在常见的设计模式中,每个项目或者说产品可以说装饰器几乎必用。
装饰器是decorator,别名wrapper,也称为包装器,是创建型、结构型、行为型分类的结构型,具体有什么用呢?
说有什么用,不如直接看下,通过使用装饰器有什么结构变化,是如何演化过来的。
通过演化过程,自然知道为什么装饰器划分为结构型,装饰器解决了什么问题,作用是啥。
上车出发
在流中,有文件流、内存流以及网络流,他们的读取方式都不一样,但是它们都继承steam 这个类。
像这样:
public abstract class Stream
{
protected abstract char Read(int number);
protected abstract void seek(int position = 0);
protected virtual void write(byte data) { }
}
假设让我们来分别设计文件流、内存流与网络流
文件流:
public class FileStream: Stream
{
public virtual void write(byte data) {
// 写入文件
}
public override char Read(int number)
{
throw new NotImplementedException();
}
public override void seek(int position = 0)
{
throw new NotImplementedException();
}
}
内存流:
public class MemoryStream:Stream
{
public virtual void write(byte data)
{
// 写内存流
}
public override char Read(int number)
{
throw new NotImplementedException();
}
public override void seek(int position = 0)
{
throw new NotImplementedException();
}
}
网络流:
public class NetworkStream: Stream
{
public virtual void write(byte data)
{
// 写网络流
}
public override char Read(int number)
{
throw new NotImplementedException();
}
public override void seek(int position = 0)
{
throw new NotImplementedException();
}
}
我们在读取或者写入这些流的时候,可能会进行加密或者说缓存。
第一版设计,假设我们以继承的方式实现。
加密的文件流:
public class CryptoBufferedFileStream: FileStream
{
public override char Read(int number)
{
base.Read(number);
//额外的加密操作
throw new NotImplementedException();
}
public override void seek(int position)
{
//额外的加密操作
base.seek(position);
}
public override void write(byte data)
{
//额外的加密操作...
base.write(data);
}
}
加密的内存流:
public class CryptoMemoryStream : MemoryStream
{
public override char Read(int number)
{
base.Read(number);
//额外的加密操作
throw new NotImplementedException();
}
public override void seek(int position)
{
//额外的加密操作
base.seek(position);
}
public override void write(byte data)
{
//额外的加密操作...
base.write(data);
}
}
加密的网络流
public class CryptoNetworkStream : NetWorkStream
{
public override char Read(int number)
{
base.Read(number);
//额外的加密操作
throw new NotImplementedException();
}
public override void seek(int position)
{
//额外的加密操作
base.seek(position);
}
public override void write(byte data)
{
//额外的加密操作...
base.write(data);
}
}
同样我们还要实现缓存流:
//文件流缓冲
public class BufferedFileStream: FileStream
{
public override char Read(int number)
{
base.Read(number);
//额外的缓冲操作
throw new NotImplementedException();
}
public override void seek(int position)
{
//额外的缓冲操作
base.seek(position);
}
public override void write(byte data)
{
//额外的缓冲操作...
base.write(data);
}
}
//内存流缓冲
public class BufferedMemoryStream : MemoryStream
{
public override char Read(int number)
{
base.Read(number);
//额外的缓冲操作
throw new NotImplementedException();
}
public override void seek(int position)
{
//额外的缓冲操作
base.seek(position);
}
public override void write(byte data)
{
//额外的缓冲操作...
base.write(data);
}
}
//网络流缓冲
public class BufferedNetworkStream : NetWorkStream
{
public override char Read(int number)
{
base.Read(number);
//额外的缓冲操作
throw new NotImplementedException();
}
public override void seek(int position)
{
//额外的缓冲操作
base.seek(position);
}
public override void write(byte data)
{
//额外的缓冲操作...
base.write(data);
}
}
写完之后,会发现几个致命性问题:
1.没有实现我们要加密也要缓存,如果要写下去那么还需要3个类,感觉没有尽头。
假设steam 有n 个继承基础类,如FileSteam,需要实现m个扩展功能,比如说加密缓冲等。
那么计算是n(C(m,1),c(m,2)....,C(m,m))
计算C(m,1),c(m,2)....,C(m,m)=2^m-1
答案是n(2^m-1)
不好意思,我的数学不是很好,如果有错误,望请指正。
2.无论加密还是缓存都是操作byte,而且操作都是read、write与seek,感觉有太多相似性代码了。
根据这两点我们改一下。
加密流:
public class CryptoBufferedStream:Stream
{
Stream stream;
public CryptoBufferedStream(Stream stream)
{
this.stream = stream;
}
public override char Read(int number)
{
stream.Read(number);
//额外的加密操作
throw new NotImplementedException();
}
public override void seek(int position)
{
//额外的加密操作
stream.seek(position);
}
public override void write(byte data)
{
//额外的加密操作...
stream.write(data);
}
}
缓冲流:
public class BufferedMemoryStream : Stream
{
Stream stream;
public BufferedMemoryStream(Stream stream) {
this.stream = stream;
}
public override char Read(int number)
{
stream.Read(number);
//额外的缓冲操作
throw new NotImplementedException();
}
public override void seek(int position)
{
//额外的缓冲操作
stream.seek(position);
}
public override void write(byte data)
{
//额外的缓冲操作...
stream.write(data);
}
}
这样似乎就看起来舒服很多了,这里可能会有一个疑惑性的问题,
为什么还要继承Stream?
装饰器也叫包装器,我们使用CryptoBufferedStream把文件流包装成了加密文件流,包装完也是必须是流啊,打包完别忘了打标签哦。
调用示例:
static void Main(string[] args)
{
FileStream fileStream = new FileStream();
BufferedMemoryStream bufferedMemoryStream = new BufferedMemoryStream(fileStream);
}
这样就把fileStream给包装成了bufferedMemoryStream,后面我们使用的就是BufferedMemoryStream。
这样我们没有失去fileSteam 是流的特性,而且还要另外一个好处,既然还是流,那么我们还可以继续包装啊。
CryptoBufferedStream cryptoBufferedStream = new CryptoBufferedStream(bufferedMemoryStream);
这时候我们即加密了,也缓冲了,实现了我们原来没有写的3个类。
这里发现一个问题,那就是stream这个属性在CryptoBufferedStream 和 BufferedMemoryStream 都存在。
其实提取和不提取都没有关系,但是对我们写代码的人来说,每次都要去写个可以提取出来的字段,是相当不舒服的,而且还不开心。
终版:
将stream属性提取出来,提取到DecoratorStream中。
public abstract class DecoratorStream: Stream
{
protected Stream stream;
public DecoratorStream(Stream stream){
this.stream = stream;
}
}
public class CryptoBufferedStream: DecoratorStream
{
public CryptoBufferedStream(Stream stream):base(stream)
{
}
public override char Read(int number)
{
stream.Read(number);
//额外的加密操作
throw new NotImplementedException();
}
public override void seek(int position)
{
//额外的加密操作
stream.seek(position);
}
public override void write(byte data)
{
//额外的加密操作...
stream.write(data);
}
}
public class BufferedMemoryStream : DecoratorStream
{
public BufferedMemoryStream(Stream stream):base(stream) {
}
public override char Read(int number)
{
stream.Read(number);
//额外的缓冲操作
throw new NotImplementedException();
}
public override void seek(int position)
{
//额外的缓冲操作
stream.seek(position);
}
public override void write(byte data)
{
//额外的缓冲操作...
stream.write(data);
}
}
看起来就舒服很多了。
为什么看起来会舒服,一张图解释出来。
假设steam 有n 个继承基础类,如FileSteam,需要实现m个扩展功能,比如说加密缓冲等。按照装饰器的计算方式是:m+1
n(2^m-1)与m+1 两者的方式对比显而易见啊,现在可以证明为什么装饰器是一个结构模式了吧。
至于作用,可以看出,可以解决继承导致的子类膨胀问题。
uml图
后面补上,画图累啊。
总结
因为n(2m-1)在n>1或者m大于1的情况下,n(2m-1)=>m+1,且仅当m=2时候两者相等,所以作用为:可以解决继承导致的子类膨胀问题,膨胀问题属于结构问题,解决的是结构问题,所以归属为结构型。