装饰器模式-Decerator

一、定义

装饰器模式又叫做包装模式(Wrapper)。装饰器模式以对客户端透明的方式扩展对象的功能,是继承关系的一个替代方案。

在以下情况下应该使用装饰器模式:

1.需要扩展一个类的功能,或给一个类增加附加责任

2.需要动态的给一个对象增加功能,这些功能可以再动态的撤销

3.需要增加由一些基本功能的排列组合而产生的非常大量的功能,从而使其继承关系变的不现实。

二、类图

装饰器模式中的角色有:

  • 抽象组件角色:给出一个抽象接口,一规范准备接收附加责任的对象
  • 具体组件角色:定义一个将要接收附加责任的类
  • 装饰角色:持有一个组件对象的实例,并定义一个一个与抽象组件接口一致的接口。
  • 具体装饰角色:负责给组件对象"贴上去"附加的责任。

将类图转换为代码,如下所示。

/**
 * 装饰者通过对被装饰者进行装饰,从而使得自己拥有的加强的行为
 * 
 * @author lp
 *
 */
public class Client {

    public static void main(String[] args) {
        // 被装饰者
        Component component = new ConcreteComponent();
        // 装饰者
        Decorator decorator = new ConcreteDecorator(component);

        // 被装饰者的行为
        component.operation();
        // 装饰者既具有被装饰者的行为,也有增加的行为。即对被装饰者进行了装饰。
        decorator.operation();
        decorator.addedBehavior();
    }

}

/**
 * 抽象的被装饰者
 */
interface Component {
    void operation();
}

/**
 * 具体的被装饰者
 */
class ConcreteComponent implements Component{

    @Override
    public void operation() {
        System.out.println("被装饰者的操作");
    }

}

/**
 * 抽象的装饰者
 */
interface Decorator extends Component{
    /**
     * 增加的方法
     */
    void addedBehavior();
}

/**
 * 具体的装饰者
 */
public class ConcreteDecorator implements Decorator {

    // 持有被装饰者的引用
    private Component decoratedComponent;

    // 通过构造器将被装饰者传进来
    public ConcreteDecorator(Component decoratedComponent) {
        this.decoratedComponent = decoratedComponent;
    }

    @Override
    public void operation() {
        System.out.println("decorated operation!");
        decoratedComponent.operation();
    }
    
    /**
     * 添加的功能
     */
    @Override
    public void addedBehavior() {
        System.out.println("addedBehaviour!");
    }

}

应该指出:

  • 装饰类中,有一个私有的属性component,其数据类型是组件(Component)
  • 该装饰器类实现了Component接口
  • 接口的实现方法也值得注意,每一个实现的方法都委派给父类,但并不单纯的委派,而是有功能的增强。

三、JDK中的装饰器模式

JDK中的部分流的实现就使用了装饰器模式,比如BufferedInputStream对InputStream进行了装饰,BufferedReader对Reader进行了装饰,对应的OutputStream和Write也分别被BufferedOutputStream和BufferedWriter装饰了。

 

下面以BufferedInputStream为例,来分析一下装饰者模式。

/*抽象组件角色*/
public abstract class InputStream implements Closeable {
    public abstract int read() throws IOException;
}

/*具体组件角色*/
public class FileInputStream extends InputStream{
    public int read() throws IOException {
        Object traceContext = IoTrace.fileReadBegin(path);
        int b = 0;
        try {
            b = read0();
        } finally {
            IoTrace.fileReadEnd(traceContext, b == -1 ? 0 : 1);
        }
        return b;
    }
}

/*抽象装饰器角色*/
public class FilterInputStream extends InputStream {
    
    protected volatile InputStream in;

    protected FilterInputStream(InputStream in) {
        this.in = in;
    }

    public int read() throws IOException {
        return in.read();
    }

    public int read(byte b[], int off, int len) throws IOException {
        return in.read(b, off, len);
    }

}

/*具体装饰器角色*/
public class BufferedInputStream extends FilterInputStream {
    
    protected volatile byte buf[];
    
    public BufferedInputStream(InputStream in){
        this(in, defaultBufferSize);
    }

    public synchronized int read() throws IOException {
        if (pos >= count) {
            fill();
            if (pos >= count)
                return -1;
        }
        return getBufIfOpen()[pos++] & 0xff;
    }    
    
}

BufferedInputStream是继承自FilterInputStream的具体的装饰器类,该类提供一个内存的缓冲区来保存输入流中的数据。这样就带有缓冲功能,提高文件读入的效率。

所以,我们通常以这样的形式来使用它们

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));

 

 ……更多设计模式的内容,可以访问Refactoring.Guru
posted @ 2017-06-14 22:54  静水楼台/Java部落阁  阅读(277)  评论(0编辑  收藏  举报