理解设计模式之：装饰者模式

1. 装饰模式（Decorator Pattern）：又可以称之为包装模式（Wrapper Pattern），结构型设计模式之一，使用一种对客户端透明的方式来动态地扩展对象的功能。

2. 模式角色分析：

• 抽象构件角色（Component）：给出一个抽象接口，以规范准备接收附加责任的对象
• 具体构件角色（Concrete Component）：定义将要接收附加责任的类
• 装饰角色（Decorator）：持有一个构件（Component）对象的引用，并定义一个与抽象构件接口一致的接口
• 具体装饰角色（Concrete Decorator）：负责给构件对象“贴上”附加的责任

3. 看了这么多的角色描述，实际上和没看差不多，我们直接看实例代码：

    /**
     * 抽象的构件角色
     */
    public interface Component {

        void doSomething();
    }



    /**
     * 具体的构件角色
     */
    public class ConcreteComponent implements Component {

        @Override
        public void doSomething() {
            System.out.println("功能A");
        }
    }


    /**
     * 抽象的装饰角色
     */
    public abstract class Decorator implements Component {

        private Component component;

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

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

    /**
     * 具体的装饰角色
     */
    public class ConcreteDecorator1 extends Decorator {

        public ConcreteDecorator1(Component component) {
            super(component);
        }

        @Override
        public void doSomething() {
            super.doSomething();
            System.out.println("功能B");
        }
    }

    /**
     * 具体的装饰角色
     */
    public class ConcreteDecorator2 extends Decorator {

        public ConcreteDecorator2(Component component) {
            super(component);
        }

        @Override
        public void doSomething() {
            super.doSomething();
            System.out.println("功能C");
        }
    }

    /**
    * 测试类
    */
    public class Client {

        public static void main(String[] args) {

            Component concreteComponent = new ConcreteComponent();
            ConcreteDecorator2 decorator2 = new ConcreteDecorator2(new ConcreteDecorator1(concreteComponent));
            decorator2.doSomething();
        }
    }

    输出结果：
    功能A
    功能B
    功能C

4. 现在我们单纯的来看这几个类构成的程序，或者说这个输出结果是怎么来的：

• decorator2.doSomething() -> super.doSomething()（Decorator.doSomething()）-> component.doSomething()
• 到这里，我们的流程就是来找到这个Decorator2中的component此时指向的是谁？ -> component在什么时候初始化：构造器 -> 构建decorator2指向的对象时我们传入的是ConcreteDecorator1

• 也就是说，component此时指向ConcreteDecorator1： component.doSomething(） -> ConcreteDecotor1.doSomething(） -> super.doSomething(）(Decorator.doSomething(）) -> component.doSomething()，按照前面同样的思考方式，ConcreteDecorator1的component指向的是ConcreteComponent，即会调用ConcreteComponent.doSomething() -> 输出字符串“功能A”

  以上这个过程有点类似递归中的“回溯”，但是程序流程还没有分析结束，接下来的过程就有点类似递归中的“递推”，ConcreteComponent.doSomething(） -> System.out.println("功能B") -> System.out.println("功能C")

  那么这样，上面三条输出结果也就出来了。现在我们再在脑海中想象这整个的调用过程，我画张图帮助大家理解：

之所以花了很大的篇幅来介绍程序的执行流程，是因为我觉得众多设计模式中，单单从代码层面去理解，都很简单，只有这个装饰者模式例外，稍微有点绕。

5. 看到上main方法的调用，是不是觉得有点熟悉，是不是像极了我们执行Java IO操作的时候：new DataOutputStream(new BufferedOutputStream(new FileOutputStream()))， 没错，Java I/O中就是用到装饰者模式。