设计模式 -- Decorator（装饰模式）
装饰模式(Decorator)
在某些情况下，我们可能会“过度的使用继承来扩展对象的功能”，由于继承为类型引入静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增多（扩展功能的在增多），各种子类的组合（扩展功能的组合）会导致子类的膨胀。
如何使对象功能的扩展能够根据需要来动态地实现、同时避免扩展功能的增多带来的子类膨胀问题、从而使得任何功能扩展变化所导致的影响降为最低
原先
在下面有一组伪代码，这组伪代码主要描述一些流的操作，比如文件流、网络流、内存流
此时、当我需要通过继承扩展一些功能时、例如扩展加密和缓存操作时
// 一个流的基类
interface Stream {
char Read(int number);
void Seek(int position);
void Write(char data);
};
// 文件流
class FileStream implements Stream {
public char Read(int number){
//读文件流
char read = 0;
// ...
return read;
}
public void Seek(int position){
//定位文件流
// ...
}
public void Write(char data){
//写文件流
// ...
}
};
// 网络流
class NetworkStream implements Stream {
public char Read(int number){
//读网络流
char read = 0;
// ...
return read;
}
public void Seek(int position){
//定位网络流
// ...
}
public void Write(char data){
//写网络流
// ...
}
};
class MemoryStream implements Stream {
public char Read(int number){
//读内存流
char read = 0;
// ...
return read;
}
public void Seek(int position){
//定位内存流
// ...
}
public void Write(char data){
//写内存流
// ...
}
};
// 扩展文件流加密类
class CryptoFileStream extends FileStream{
public char Read(int number){
//额外的加密操作...
//读文件流
return super.Read(number);
}
public void Seek(int position){
//额外的加密操作...
super.Seek(position); // 定位文件流
//额外的加密操作...
}
public void Write(char data){
//额外的加密操作...
super.Write(data); // 写文件流
//额外的加密操作...
}
};
// 扩展网络流加密类
class CryptoNetworkStream extends NetworkStream {
public char Read(int number){
//额外的加密操作...
return super.Read(number); //读网络流
}
public void Seek(int position){
//额外的加密操作...
super.Seek(position); //定位网络流
//额外的加密操作...
}
public void Write(char data){
//额外的加密操作...
super.Write(data);//写网络流
//额外的加密操作...
}
};
// 扩展内存流加密类
class CryptoMemoryStream extends MemoryStream {
public char Read(int number){
//额外的加密操作...
return super.Read(number); // 读内存流
}
public void Seek(int position){
//额外的加密操作...
super.Seek(position); //定位内存流
//额外的加密操作...
}
public void Write(char data){
//额外的加密操作...
super.Write(data);//写内存流
//额外的加密操作...
}
};
// 扩展文件流缓存类
class BufferedFileStream extends FileStream{
//...
};
// 扩展网络流缓存类
class BufferedNetworkStream extends NetworkStream{
//...
};
// 扩展内存流缓存类
class BufferedMemoryStream extends MemoryStream{
//...
}
class CryptoBufferedFileStream extends FileStream{
public char Read(int number){
//额外的加密操作...
//额外的缓冲操作...
return super.Read(number);//读文件流
}
public void Seek(int position){
//额外的加密操作...
//额外的缓冲操作...
super.Seek(position);//定位文件流
//额外的加密操作...
//额外的缓冲操作...
}
public void Write(char data){
//额外的加密操作...
//额外的缓冲操作...
super.Write(data);//写文件流
//额外的加密操作...
//额外的缓冲操作...
}
};
此时我们可以看到、当我们需要通过继承扩展时、都需要重新实现一遍操作、其实、文件流、网络流、内存流都继承了Stream流、只需写一个扩展类操作Stream流这个接口即可、不通过继承的方式、而是通过对象组合的方式。
重构
// 一个流的基类
interface Stream {
char Read(int number);
void Seek(int position);
void Write(char data);
};
// 文件流
class FileStream implements Stream {
public char Read(int number){
//读文件流
char read = 0;
// ...
return read;
}
public void Seek(int position){
//定位文件流
// ...
}
public void Write(char data){
//写文件流
// ...
}
};
// 网络流
class NetworkStream implements Stream {
public char Read(int number){
//读网络流
char read = 0;
// ...
return read;
}
public void Seek(int position){
//定位网络流
// ...
}
public void Write(char data){
//写网络流
// ...
}
};
class MemoryStream implements Stream {
public char Read(int number){
//读内存流
char read = 0;
// ...
return read;
}
public void Seek(int position){
//定位内存流
// ...
}
public void Write(char data){
//写内存流
// ...
}
};
// 扩展加密
class CryptoStream implements Stream {
private Stream stream; //...
CryptoStream(Stream stream) {
this.stream = stream;
}
public char Read(int number){
//额外的加密操作...
return stream.Read(number);//读文件流
}
public void Seek(int position){
//额外的加密操作...
stream.Seek(position);//定位文件流
//额外的加密操作...
}
public void Write(char data){
//额外的加密操作...
stream.Write(data);//写文件流
//额外的加密操作...
}
};
class BufferedStream implements Stream{
private Stream stream;//...
BufferedStream(Stream stream) {
this.stream = stream;
}
public char Read(int number) {
// 缓存操作 ...
return stream.Read(number);
}
public void Seek(int position) {
// 缓存操作 ...
stream.Seek(position);
}
public void Write(char data) {
// 缓存操作 ...
stream.Write(data);
}
};
重构后扩展只需要写一个类传入Stream接口多态操作即可、现在每个扩展类都需要写构造函数传入Stream、可以写一个父类继承如下：
// 一个流的基类
interface Stream {
char Read(int number);
void Seek(int position);
void Write(char data);
};
// 文件流
class FileStream implements Stream {
public char Read(int number){
//读文件流
char read = 0;
// ...
return read;
}
public void Seek(int position){
//定位文件流
// ...
}
public void Write(char data){
//写文件流
// ...
}
};
// 网络流
class NetworkStream implements Stream {
public char Read(int number){
//读网络流
char read = 0;
// ...
return read;
}
public void Seek(int position){
//定位网络流
// ...
}
public void Write(char data){
//写网络流
// ...
}
};
class MemoryStream implements Stream {
public char Read(int number){
//读内存流
char read = 0;
// ...
return read;
}
public void Seek(int position){
//定位内存流
// ...
}
public void Write(char data){
//写内存流
// ...
}
};
// 装饰模式
abstract class DecoratorStream implements Stream {
protected Stream stream;
DecoratorStream(Stream stream) {
this.stream = stream;
}
}
// 扩展加密
class CryptoStream extends DecoratorStream {
CryptoStream(Stream stream) {
super(stream);
}
public char Read(int number){
//额外的加密操作...
return stream.Read(number);//读文件流
}
public void Seek(int position){
//额外的加密操作...
stream.Seek(position);//定位文件流
//额外的加密操作...
}
public void Write(char data){
//额外的加密操作...
stream.Write(data);//写文件流
//额外的加密操作...
}
};
// 扩展缓存
class BufferedStream extends DecoratorStream{
BufferedStream(Stream stream) {
super(stream);
}
public char Read(int number) {
// 缓存操作 ...
return stream.Read(number);
}
public void Seek(int position) {
// 缓存操作 ...
stream.Seek(position);
}
public void Write(char data) {
// 缓存操作 ...
stream.Write(data);
}
};
// 使用
public class Main {
@Test
public void T1() {
// 文件流
FileStream fileStream = new FileStream();
// 扩展加密流
CryptoStream cryptoStream = new CryptoStream(fileStream);
// 此时、缓存流又拥有了加密流的功能
BufferedStream bufferedStream = new BufferedStream(cryptoStream);
}
}
动态（组合）地给一个对象增加一些额外的指责。就增加功能而言，Decorator模式比生成子类（继承）更为灵活（消除重复代码、减少子类个数）。
要点总结
- 通过采用组合而非继承的手法，Decorator模式实现了在运动时动态扩展对象功能的能力，而且可以根据需要扩展多个功能。避免了使用集成带来的“灵活性差”和“多子类衍生的问题”
- Decorator类在接口上变现为is-a Component的继承关系，即Decorator类集成了Component类所具有的接口。但在实现上又表现为has-a Component的组合关系，即Decorator类又使用了另外一个Component类。
- Decorator模式的目的并非解决“多子类衍生的多继承”问题，Decorator模式应用的重要点在于解决“主体类在多个方向上的扩展功能”——是为“装饰”的含义。
- 当我们看到一个类的字段类型和父类相同时、那么大概率这个类是应用了装饰模式的
