装饰者模式

“单一职责类”模式

• 在软件组件的设计中,如果责任划分的不清晰,使用继承得到的结果往往是随着需求的变化,子类急剧膨胀,同时充斥着重复代码,这时候的关键是划清职责
• 典型的模式
  • 装饰者模式(Decorator)
  • 桥接模式(Bridge)

    装饰者模式

• 动机: 在某些情况下可能会 “过度地使用继承来扩展对象的功能”,由于 继承为类型引入的静态特质,使得这种扩展方式缺乏灵活性;并且随着子类的增多(扩展功能的增多),各种子类的组合(扩展功能的组合)会导致更多子类的膨胀
• Decorator类特征: 既继承业务基类又组合业务基类

代码例子

常规做法1

//业务操作
abstract class Stream {
    public abstract char read(int number);
    public abstract void seek(int position);
    public abstract void write(char data);
}

//主体类

//文件流
class FileStream extends Stream {
    //读文件流
    @Override
    public char read(int number){
        //....
    }

    //定位文件流
    @Override
    public void seek(int position){
        //...
    }

    //写文件流
    @Override
    public void write(char data){
        //....
    }

}

//网络流
class FileStream extends Stream {
    //读网络流
    @Override
    public char read(int number){
        //....
    }

    //定位网络流
    @Override
    public void seek(int position){
        //...
    }

    //写网络流
    @Override
    public void write(char data){
        //....
    }

}

//内存流
class MemoryStream extends Stream {
    //读内存流
    @Override
    public char read(int number){
        //....
    }

    //定位内存流
    @Override
    public void seek(int position){
        //...
    }

    //写内存流
    @Override
    public void write(char data){
        //....
    }

}

//扩展操作类

//扩展文件流
class CryptoFileStream extends FileStream {
    //读文件流
    @Override
    public char read(int number){
        //....额外的加密扩展操作(加密算法稳定不变)

        super.read(number);
    }

    //定位内存流
    @Override
    public void seek(int position){
        //....额外的加密扩展操作(加密算法稳定不变)
        super.seek(position);
    }

    //写内存流
    @Override
    public void write(char data){
        //....额外的加密扩展操作(加密算法稳定不变)

        super.write(data);
    }

}

//扩展网络流
class CryptoNetworkStream extends NetworkStream {
    //读网络流
    @Override
    public char read(int number){
        //....额外的加密扩展操作(加密算法稳定不变)

        super.read(number);
    }

    //定位网络流
    @Override
    public void seek(int position){
        //....额外的加密扩展操作(加密算法稳定不变)
        super.seek(position);
    }

    //写网络流
    @Override
    public void write(char data){
        //....额外的加密扩展操作(加密算法稳定不变)

        super.write(data);
    }

}

//扩展内存流
class CryptoMemoryStream extends MemoryStream {
    //读内存流
    @Override
    public char read(int number){
        //....额外的加密扩展操作(加密算法稳定不变)

        super.read(number);
    }

    //定位内存流
    @Override
    public void seek(int position){
        //....额外的加密扩展操作(加密算法稳定不变)
        super.seek(position);
    }

    //写内存流
    @Override
    public void write(char data){
        //....额外的加密扩展操作(加密算法稳定不变)

        super.write(data);
    }

}

class BufferedFileStream extends FileStream {
  //....
}

class BufferedNetworkStream extends NetworkStream {
  //....
}

class BufferedMemoryStream extends MemoryStream {
  //....
}

class CryptoBufferedFileStream extends FileStream {
  //....
}

class CryptoBufferedNetworkStream extends NetworkStream {
  //....
}

class CryptoBufferedMemoryStream extends MemoryStream {
  //....
}

class client {
    public void run{
        //编译时装配
        CryptoFileStream fst1 = new CryptoFileStream();
        BufferedFileStream  fst2 = new BufferedFileStream();
    }
}

常见做法2-(做法1的改良:继承转组合)

class CryptoStream extends Stream{
    Stream s;//组合: 复用实现

    public CryptoStream(Stream stream){
        s = stream
    }

    //读...流
    @Override
    public char read(int number){
        //....额外的加密扩展操作(加密算法稳定不变)

        s.read(number);
    }

    //定位...流
    @Override
    public void seek(int position){
        //....额外的加密扩展操作(加密算法稳定不变)
        s.seek(position);
    }

    //写...流
    @Override
    public void write(char data){
        //....额外的加密扩展操作(加密算法稳定不变)

        s.write(data);
    }
}

class BuffterStream extends Stream{
    Stream s;

    public CryptoStream(Stream stream){
        s = stream
    }

    //读...流
    @Override
    public char read(int number){
        //....额外的加密扩展操作(加密算法稳定不变)

        s.read(number);
    }

    //定位...流
    @Override
    public void seek(int position){
        //....额外的加密扩展操作(加密算法稳定不变)
        s.seek(position);
    }

    //写...流
    @Override
    public void write(char data){
        //....额外的加密扩展操作(加密算法稳定不变)

        s.write(data);
    }
}

class client {
    public void run{
        //运行时装配
        Stream s1 = new CryptoStream(new FileStream);
        Stream s2 = new BuffterStream(new FileStream);
    }
}

装饰者模式修改版本

//抽象出装饰者抽象类
abstract class DecoratorStream {
    protected Stream s; //组合:复用实现
    protected DecoratorStream(Stream s){
        this.s = s;
    }
}

class CryptoStream extends DecoratorStream{

    public CryptoStream(Stream stream){
        super(stream)
    }

    //读...流
    @Override
    public char read(int number){
        //....额外的加密扩展操作(加密算法稳定不变)

        s.read(number);
    }

    //定位...流
    @Override
    public void seek(int position){
        //....额外的加密扩展操作(加密算法稳定不变)
        s.seek(position);
    }

    //写...流
    @Override
    public void write(char data){
        //....额外的加密扩展操作(加密算法稳定不变)

        s.write(data);
    }
}

class BuffterStream extends DecoratorStream{

    public CryptoStream(Stream stream){
        super(stream)
    }

    //读...流
    @Override
    public char read(int number){
        //....额外的加密扩展操作(加密算法稳定不变)

        s.read(number);
    }

    //定位...流
    @Override
    public void seek(int position){
        //....额外的加密扩展操作(加密算法稳定不变)
        s.seek(position);
    }

    //写...流
    @Override
    public void write(char data){
        //....额外的加密扩展操作(加密算法稳定不变)

        s.write(data);
    }
}