结构型模式 - 装饰模式

0x01 前言

  装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

  这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

0x02 简介

意图：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。

主要解决：一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。

何时使用：在不想增加很多子类的情况下扩展类。

如何解决：将具体功能职责划分，同时继承装饰者模式。

关键代码： 1、Component 类充当抽象角色，不应该具体实现。 2、修饰类引用和继承 Component 类，具体扩展类重写父类方法。

应用实例： 1、孙悟空有 72 变，当他变成“庙宇”后，他的根本还是一只猴子，但是他又有了庙宇的功能。 2、不论一幅画有没有画框都可以挂在墙上，但是通常都是有画框的，并且实际上是画框被挂在墙上。在挂在墙上之前，画可以被蒙上玻璃，装到框子里；这时画、玻璃和画框形成了一个物体。

优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

缺点：多层装饰比较复杂。

使用场景： 1、扩展一个类的功能。 2、动态增加功能，动态撤销。

注意事项：可代替继承。

0x03 设计概述

  咖啡是一种饮料，咖啡的本质是咖啡豆 + 水磨出来的。咖啡店现在要卖各种口味的咖啡，如果不使用装饰模式，那么在销售系统中，各种不一样的咖啡都要产生一个类，如果有 4 种咖啡豆， 5 种口味，那么将要产生至少 20 个类（不包括混合口味），非常麻烦。使用了装饰模式，只需要 11 个类即可生产任意口味咖啡（包括混合口味）。

角色组成

  抽象构件（Component）角色：给出一个抽象接口，以规范准备接收附加责任的对象。

  具体构件（Concrete Component）角色：定义一个将要接收附加责任的类。

  装饰角色（Decorator）：持有一个构件（Component）对象的实例，并定义一个与抽象构件接口一致的接口。

  具体装饰角色（Concrete Decorator）：负责给构件对象“贴上”附加的责任。

0x04 具体实现

项目结构图

图片

抽象构件（Component）

  创建一个饮料接口，以规范准备接收附加责任的对象。

// decorator_pattern.IBeverage

package decorator_pattern;

public interface IBeverage {

    String getDescription(); // 定义添加物料描述

    double getPrice(); // 获取返回金额数

}

具体构件（Concrete Component）

  创建实现接口的实体类，即是被装饰的类型。

// decorator_pattern.concrete_component.CoffeeBean1

package decorator_pattern.concrete_component;

import decorator_pattern.IBeverage;

public class CoffeeBean1 implements IBeverage {

    private String description = "选择第 1 种咖啡豆";

    @Override
    public String getDescription() {
        return description;
    }

    @Override
    public double getPrice() {
        return 50;
    }

}

// decorator_pattern.concrete_component.CoffeeBean2

package decorator_pattern.concrete_component;

import decorator_pattern.IBeverage;

public class CoffeeBean2 implements IBeverage {

    private String description = "选了第 2 种咖啡豆";

    @Override
    public String getDescription() {
        return description;
    }

    @Override
    public double getPrice() {
        return 100;
    }

}

装饰角色（Decorator）

  拓展 Decorator 形成抽象装饰类，创建一个构件（Component）对象的实例，并定义一个与抽象构件接口一致的接口，由此接口拓展具体的装饰类。

// decorator_pattern.decorator.Decorator

package decorator_pattern.decorator;

import decorator_pattern.IBeverage;

public abstract class Decorator implements IBeverage {

    private String descriptor = "我只是装饰器，不做具体的描述";

    @Override
    public String getDescription() {
        return descriptor;
    }

    @Override
    public double getPrice() {
        return 0;
    }

}

具体装饰角色（Concrete Decorator）

  拓展 Decorator 形成具体的装饰类，负责给构件对象“贴上”附加的责任。

// decorator_pattern.decorator.concrete_decorator.Milk

package decorator_pattern.decorator.concrete_decorator;

import decorator_pattern.IBeverage;
import decorator_pattern.decorator.Decorator;

public class Milk extends Decorator {

    private String description = "加了牛奶";
    private IBeverage beverage = null;

    public Milk(IBeverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + "\n" + description;
    }

    @Override
    public double getPrice() {
        return beverage.getPrice() + 30;
    }

}

// decorator_pattern.decorator.concrete_decorator.Mocha

package decorator_pattern.decorator.concrete_decorator;

import decorator_pattern.IBeverage;
import decorator_pattern.decorator.Decorator;

public class Mocha extends Decorator {

    private String description = "加了摩卡";
    private IBeverage beverage = null;

    public Mocha(IBeverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + "\n" + description;
    }

    @Override
    public double getPrice() {
        return beverage.getPrice() + 50;
    }

}

// decorator_pattern.decorator.concrete_decorator.Soy

package decorator_pattern.decorator.concrete_decorator;

import decorator_pattern.IBeverage;
import decorator_pattern.decorator.Decorator;

public class Soy extends Decorator {

    private String description = "加了豆浆";
    private IBeverage beverage = null;

    public Soy(IBeverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription() + "\n" + description;
    }

    @Override
    public double getPrice() {
        return beverage.getPrice() + 30;
    }

}

测试类

  进行测试举例，饮料 1 ：咖啡豆 1 ，加入牛奶，摩卡。饮料 2 ：咖啡豆 2 ， 加入豆浆。

// decorator_pattern.BeverageTest

package decorator_pattern;

import org.junit.Test;

import decorator_pattern.concrete_component.CoffeeBean1;
import decorator_pattern.concrete_component.CoffeeBean2;
import decorator_pattern.decorator.concrete_decorator.Frozen;
import decorator_pattern.decorator.concrete_decorator.Heat;
import decorator_pattern.decorator.concrete_decorator.Milk;
import decorator_pattern.decorator.concrete_decorator.Mocha;
import decorator_pattern.decorator.concrete_decorator.Soy;

public class BeverageTest {

    @Test
    public void testBeverage1() {
        IBeverage beverage = new CoffeeBean1();
        beverage = new Milk(beverage);
        beverage = new Mocha(beverage);
        Heat heatBeverage = new Heat(beverage);
        System.out.println(heatBeverage.getDescription() + "\n" + heatBeverage.getPrice() + "\n" + heatBeverage.getOperator());
    }

    @Test
    public void testBeverage2() {
        IBeverage beverage = new CoffeeBean2();
        beverage = new Soy(beverage);
        Frozen frozenBeverage = new Frozen(beverage);
        System.out.println(frozenBeverage.getDescription() + "\n" + frozenBeverage.getPrice() + "\n" + frozenBeverage.getOperator());
    }

}

测试结果

  testBeverage1

选择第 1 种咖啡豆
加了牛奶
加了摩卡
130.0

  testBeverage2

选了第 2 种咖啡豆
加了豆浆
130.0

0x05 装饰模式和适配器模式的关系

  装饰模式和适配器模式都是“包装模式（Wrapper Pattern）”，它们都是通过封装其他对象达到设计的目的的，但是它们的形态有很大区别。

  理想的装饰模式在对被装饰对象进行功能增强的同时，要求具体构件角色、装饰角色的接口与抽象构件角色的接口完全一致。而适配器模式则不然，一般而言，适配器模式并不要求对源对象的功能进行增强，但是会改变源对象的接口，以便和目标接口相符合。

  装饰模式有透明和半透明两种，这两种的区别就在于装饰角色的接口与抽象构件角色的接口是否完全一致。透明的装饰模式也就是理想的装饰模式，要求具体构件角色、装饰角色的接口与抽象构件角色的接口完全一致。相反，如果装饰角色的接口与抽象构件角色接口不一致，也就是说装饰角色的接口比抽象构件角色的接口宽的话，装饰角色实际上已经成了一个适配器角色，这种装饰模式也是可以接受的，称为“半透明”的装饰模式，如下图所示。

图片

  在适配器模式里面，适配器类的接口通常会与目标类的接口重叠，但往往并不完全相同。换言之，适配器类的接口会比被装饰的目标类接口宽。

  显然，半透明的装饰模式实际上就是处于适配器模式与装饰模式之间的灰色地带。如果将装饰模式与适配器模式合并成为一个“包装模式”的话，那么半透明的装饰模式倒可以成为这种合并后的“包装模式”的代表。

0x06 透明性要求

  装饰模式对客户端的透明性要求程序不要声明一个 Concrete Component 类型的变量，而应当声明一个 Component 类型的变量。

  用上面的例子来说，必须永远把所有的饮料当成饮料来对待，而如果把饮料变成的加摩卡的饮料当成摩卡，而不是饮料，这是不应当发生的。

  下面的做法是对的：

IBeverage beverage = new CoffeeBean1();
IBeverage mochaBeverage = new Mocha(beverage);

  下面的做法是错的：

IBeverage beverage = new CoffeeBean1();
Mocha mochaBeverage = new Mocha(beverage);

0x07 半透明模式

  然而，纯粹的装饰模式很难找到。装饰模式的用意是在不改变接口的前提下，增强所考虑的类的性能。在增强性能的时候，往往需要建立新的公开的方法。上述例子中，我们需要对咖啡进行加热和冰冻，就需要在原先的接口上添加新的方法。因此，在 Concrete Decorator 类模块中，添加新的具体装饰类 Heat ，在类 Heat 中增加方法 getOperator() 对咖啡进行进一步操作。

项目结构图

图片

具体实现

具体装饰角色（Concrete Decorator）

  拓展 Decorator 形成具体的装饰类 Heat，对咖啡进行加热。

// decorator_pattern.decorator.concrete_decorator.Heat

package decorator_pattern.decorator.concrete_decorator;

import decorator_pattern.IBeverage;
import decorator_pattern.decorator.Decorator;

public class Heat extends Decorator {

    private IBeverage beverage = null;

    public Heat(IBeverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription();
    }

    @Override
    public double getPrice() {
        return beverage.getPrice();
    }

    public String getOperator() {
        return "加热";
    }

}

  拓展 Decorator 形成具体的装饰类 Frozen，对咖啡进行冰冻。

// decorator_pattern.decorator.concrete_decorator.Frozen

package decorator_pattern.decorator.concrete_decorator;

import decorator_pattern.IBeverage;
import decorator_pattern.decorator.Decorator;

public class Frozen extends Decorator {

    private IBeverage beverage = null;

    public Frozen(IBeverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        return beverage.getDescription();
    }

    @Override
    public double getPrice() {
        return beverage.getPrice();
    }

    public String getOperator() {
        return "冰冻";
    }

}

  这就导致了大多数的装饰模式的实现都是“半透明”的，而不是完全透明的。换言之，允许装饰模式改变接口，增加新的方法。这意味着客户端可以声明 Concrete Decorator 类型的变量，从而可以调用 Concrete Decorator 类中才有的方法：

测试类

package decorator_pattern;

import org.junit.Test;

import decorator_pattern.concrete_component.CoffeeBean1;
import decorator_pattern.concrete_component.CoffeeBean2;
import decorator_pattern.decorator.concrete_decorator.Frozen;
import decorator_pattern.decorator.concrete_decorator.Heat;
import decorator_pattern.decorator.concrete_decorator.Milk;
import decorator_pattern.decorator.concrete_decorator.Mocha;
import decorator_pattern.decorator.concrete_decorator.Soy;

public class BeverageTest {

    @Test
    public void testBeverage1() {
        IBeverage beverage = new CoffeeBean1();
        beverage = new Milk(beverage);
        beverage = new Mocha(beverage);
        Heat heatBeverage = new Heat(beverage);
        System.out.println(heatBeverage.getDescription() + "\n" + heatBeverage.getPrice() + "\n" + heatBeverage.getOperator());
    }

    @Test
    public void testBeverage2() {
        IBeverage beverage = new CoffeeBean2();
        beverage = new Soy(beverage);
        Frozen frozenBeverage = new Frozen(beverage);
        System.out.println(frozenBeverage.getDescription() + "\n" + frozenBeverage.getPrice() + "\n" + frozenBeverage.getOperator());
    }

}

  半透明的装饰模式是介于装饰模式和适配器模式之间的。适配器模式的用意是改变所考虑的类的接口，也可以通过改写一个或几个方法，或增加新的方法来增强或改变所考虑的类的功能。大多数的装饰模式实际上是半透明的装饰模式，这样的装饰模式也称做半装饰、半适配器模式。