设计模式-装饰器模式（Decrator Model）

文 / vincentzh

原文连接：http://www.cnblogs.com/vincentzh/p/6057666.html

目录

1. 1、概述
2. 2、目的
3. 3、结构组成
4. 4、实现
5. 5、总结

1、概述

　　装饰器模式在不改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。通常给一个对象添加功能，要么在类中直接进行修改，要么通过子类继承来扩展对象的功能，又或者使用装饰模式将相应的功能进行任意的组合，使功能的扩展变的具有灵活性和动态性。装饰模式是通过创建一个包装对象，也就是装饰来包裹真实的对象，给真实对象扩展包装对象所具有的功能。

2、目的

　　装饰器的目的是：通过装饰对象的任意组合，对真实对象进行功能包装，实现对象功能扩展的动态性、简便性、复用性、灵活性。

3、结构组成

　　装饰模式主要涉及到四个角色：抽象主题角色、具体主题角色、抽象装饰角色、具体装饰角色

　　抽象主题角色：抽象主题角色提供具体角色和抽象装饰角色共同实现的功能（基本功能方法），具体主题角色和抽象装饰角色都必须去实现抽象主题角色定义的方法；

　　具体主题角色：具体主题角色就是装饰模式中的真实对象类，实现抽象主题角色的方法（基本功能方法），通过具体装饰角色包装给该角色添加附加功能；

　　抽象装饰角色：所有装饰器的父类，实现了抽象主题角色的功能(主要是为了实现装饰器功能的复用，即具体的装饰器A可以装饰另外一个具体的装饰器B，因为装饰器类也是一个抽象主题角色)，并持有一个抽象主题角色的对象，该对象其实就是被装饰的对象。如果不继承组件接口类，则只能为某个组件添加单一的功能，即装饰器对象不能在装饰其他的装饰器对象。

　　具体装饰角色：具体的装饰器类，实现具体要向被装饰对象添加的功能。用来装饰具体的组件对象或者另外一个具体的装饰器对象。

aaarticlea/png;base64,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" alt="" />

4、实现

　　抽象主题角色

 package com.cnblogs.vincentzh.decoratormodel;
 // 抽象主题角色
 // 只定义基本功能方法
 public interface Component
 {
     public void function();
 }

　　具体主题角色

 package com.cnblogs.vincentzh.decoratormodel;
 // 具体主题角色
 public class ConcreteComponent implements Component
 {
     @Override
     public void function()
     {
         baseFunction();
     }

     public void baseFunction()
     {
         System.out.println("基础功能");
     }
 }

　　抽象装饰角色

 package com.cnblogs.vincentzh.decoratormodel;
 // 抽象装饰角色
 public class Decorator implements Component
 {
     private Component component; // 持有抽象主题的角色

     public Decorator(Component component)
     {
         this.component = component;
     }

     @Override
     public void function()
     {
         component.function();
     }
 }

　　两个具体装饰角色

 package com.cnblogs.vincentzh.decoratormodel;
 // 具体装饰角色A
 public class ConcreteDecoratorA extends Decorator
 {
     public ConcreteDecoratorA(Component component)
     {
         super(component);
     }

     @Override
     public void function()
     {
         super.function();
         functionA();
     }

     public void functionA()
     {
         System.out.println("附加功能A");
     }
 }

package com.cnblogs.vincentzh.decoratormodel;
// 具体装饰角色B
public class ConcreteDecoratorB extends Decorator
{
    public ConcreteDecoratorB(Component component)
    {
        super(component);
    }

    @Override
    public void function()
    {
        super.function();
        functionB();
    }

    public void functionB()
    {
        System.out.println("附加功能B");
    }
}

　　客户端

 package com.cnblogs.vincentzh.decoratormodel;
 // 客户端测试类
 public class Client
 {
     public static void main(String[] args)
     {
         Component component = new ConcreteComponent();
         Component decoratorA = new ConcreteDecoratorA(component);
         Component decoratorB = new ConcreteDecoratorB(decoratorA);

         decoratorB.function();
         // 调用 decoratorB 的 function 方法时，会去先执行父类 Decorator 的 function 方法，而
         // Decorator 中持有 Component 的对象引用（所有的被装饰类和装饰类都实现了Component），
         // 会去调用传入 Component 引用对象的 function 方法，此处 decoratorB 执行时会先执行
         // decoratorA 的方法，而 decoratorA 执行时 又会先去执行 component 的 function 方法，传
         // 入的是哪个装饰器的或真实对象的引用就会去先执行引用对象下的方法，这也就是装饰器能够
         // 随意组合的缘由所在。
     }
 }

　　执行结果

aaarticlea/png;base64,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" alt="" />

5、总结

　　Java 的 I/O 流中就是使用了装饰模式I/O流可以划分为节点流和过滤流。，

　节点流：就是直接与输入/输出设备或者文件系统打交道的基本类，如：FileInputStream、FileOutputStream等；

　过滤流：过滤过滤，就是对已有的输入/输出流进行相应的附加处理，如缓冲读/写（BufferedInputStream、BufferedOutputStream）等；

　　InputStream 和 OutputStream 是所有输入/输出流的父类，它就是装饰模式中所谓的抽象主题角色（Component）；而属于节点流的类自然就是具体主题角色（ConcreteComponent）,它们负责与硬件或文件系统交互，形成最基本的读写操作流；FilterInputStream 和 FilterrOutputStream 则是所有过滤流的父类，同时它也继承自 InputStream 和 OutputStream，对应上去就是抽象装饰角色（Decorator）；剩下具体的过滤流就是具体装饰角色（ConcreteDecorator），它对负责基本功能的节点流进行包装添加功能，如：BufferInputStream 添加缓冲读取功能。

　　在 Hadoop 的编程模型中，MapReduce 用于 HDFS 文件数据读取的两个基本类 FSDataInputStream 和 FSDataOutputStream 也是继承自 Java 的 FilterInputStream 和 FilterOutputStream，那么这样来看，用于 HDFS 文件读/写的原理也是与一般文件读/写的原理并无差别，只是在原有的文件读/写基础上进行了分布式文件读取功能的添加。