1、需求
假设让我们去设计FCL中的Stream类,该类具有流类的基本功能,除了有各种不同类型的流外(如内存流、文件流、网络流等等),但是在不同的业务场景下,如处理银行业务,需要给相关的内存流进行加密操作,给相关的银行视频业务,进行视频流加密操作.
2、通常性的做法
/// <summary> /// 流抽象 /// </summary> public abstract class Stream { /// <summary> /// 读取流的方法 /// </summary> public abstract void Read(); /// <summary> /// 流的长度 /// </summary> public abstract long Length { get; } } /// <summary> /// 内存流 /// </summary> public class MemoryStream : Stream { public override long Length => 1000000000000000; public override void Read() { } /// <summary> /// 定义自己的实现 /// </summary> public virtual void Write() { } } /// <summary> /// 文件流 /// </summary> public class FileStream : Stream { public override long Length => 1000000000000000; public override void Read() { } /// <summary> /// 定义自己的实现 /// </summary> public virtual void Write() { } } /// <summary> /// 加密约束接口 /// </summary> public interface ICryto { /// <summary> /// 机密方法 /// </summary> void Cryto(); } /// <summary> /// 缓冲约束接口 /// </summary> public interface IBuffered { /// <summary> /// 缓冲方法 /// </summary> void Buffered(); } /// <summary> /// 加密内存流 /// </summary> public class CryptoMemoryStream : MemoryStream, ICryto { public override long Length => 1000000000000000; public void Cryto() { } public override void Read() { } } /// <summary> /// 加密缓冲内存流 /// </summary> public class CryptBufferedMemoryStream : MemoryStream, ICryto, IBuffered { public override long Length => 100000000000; public void Buffered() { } public void Cryto() { } public override void Read() { } } /// <summary> /// 加密文件流 /// </summary> public class CryptoFileStream : FileStream, ICryto { public override long Length => 1000000000000000; public void Cryto() { } public override void Read() { } } /// <summary> /// 加密缓冲文件流 /// </summary> public class CryptBufferedFileStream : FileStream, ICryto, IBuffered { public override long Length => 100000000000; public void Buffered() { } public void Cryto() { } public override void Read() { } }
ok,上面的设计符合我们的需求,但是如果这个时候多了一个网络流NetStream,而且这个类也需要加密和加密缓冲的功能,这个时候,就需要在写3个子类,如何流的扩展功能增多,有需要额外编写更多的子类来满足需求,这样下去,子类会以指数级增长,所以,显然这种设计是不可取的.
3、问题
由于上面的设计过多的使用了继承来扩展对象的功能,由于继承本身的缺陷,使得这种扩展方式缺乏灵活性,并且随着子类的增多(扩展功能的增多),各种子类的组合(扩展功能的组合)会导致更多子类的膨胀(多继承,至继承一个类,但是实现了多个接口).
那么如何使"对象功能的扩展"能够根据需要动态的实现,同时避免功能扩展的同时,子类的膨胀?
4、Decorator装饰者模式
/// <summary> /// 流抽象 /// </summary> public abstract class Stream { /// <summary> /// 读取流的方法 /// </summary> public abstract void Read(); /// <summary> /// 流的长度 /// </summary> public abstract long Length { get; } } /// <summary> /// 内存流 /// </summary> public class MemoryStream : Stream { public override long Length => 1000000000000000; public override void Read() { } /// <summary> /// 定义自己的实现 /// </summary> public virtual void Write() { } } /// <summary> /// 文件流 /// </summary> public class FileStream : Stream { public override long Length => 1000000000000000; public override void Read() { } /// <summary> /// 定义自己的实现 /// </summary> public virtual void Write() { } } public abstract class StreamDecorator : Stream//接口继承 { private Stream _stream; public StreamDecorator(Stream stream) { _stream = stream; } public override long Length => 1000000000000; public override void Read() { } } /// <summary> /// 加密功能装饰器 /// </summary> public class CrytoDecorator : StreamDecorator { public CrytoDecorator(Stream stream) : base(stream) { } public override long Length => base.Length; public override void Read() { //这里做加密功能的扩展或者不做,直接调用父类的Read操作 base.Read(); } } /// <summary> /// 缓冲功能装饰器 /// </summary> public class CrytoBufferedDecorator : StreamDecorator { public CrytoBufferedDecorator(Stream stream) : base(stream) { } public override long Length => base.Length; public override void Read() { //这里做缓冲功能的扩展或者不做,直接调用父类的Read操作 base.Read(); } }
客户端调用代码如下:
public class ThirdSystem { public void Run() { var fs = new FileStream(); var crytoStream = new CrytoDecorator(fs);//加密文件流 var crytoBufferedDecorator = new CrytoBufferedDecorator(crytoStream);//加密缓冲文件流 var ms = new MemoryStream(); var crytoMsStream = new CrytoDecorator(ms);//加密内存流 var MsCrytoBufferedDecorator = new CrytoBufferedDecorator(crytoMsStream);//加密缓冲内存流 } }
5、装饰者模式的作用
(1)、主要解决主体类在多个方向上的扩展问题,并非解决多继承产生的"子类泛滥"的问题.
(2)、通过采用组合而非继承的方式,实现了在运行时动态的扩展对象功能的能力,可以更具需要扩展多个功能,避免了使用继承带来的"灵活性差"和"子类泛滥"的问题.
(3)、Stream类在Decorator模式中充当抽象接口的角色,不应该去实现具体的行为,Stream类无需知道Decorator类,Decorator类是从外部来扩展Stream类的功能.
(4)、Decorator类在代码表现上是is a Stream的继承关系,即Decorator继承了Stream类所具有的所有的接口,但是实现上有表现为Has a的关系,即装饰着拥有一个Stream类,可以使用一个或者多个装饰者来包装Stream类,但最终还是只有一个Stream类.
6、实际上微软在设计流系统时,就是使用了这种方式，具体看如下代码:
MemoryStream ms = new MemoryStream(new byte[] {1,2,3,4 });//内存流 BufferedStream bf = new BufferedStream(ms);//缓冲的内存流 CryptoStream cs = new CryptoStream(bf, null,CryptoStreamMode.Read);//缓冲、机密的流