探索设计模式的魅力：为什么你应该了解装饰器模式-代码优化与重构的秘诀

---

设计模式专栏：http://t.csdnimg.cn/nolNS

---

开篇

一、背景

二、装饰器模式概述

2.1 简介

2.2 适合场景

三、深入装饰器模式的结构

3.1 核心组件解析

  这个模式的核心在于允许功能的层层叠加，这是通过持有Component实例的引用，并将对其的调用委托给这个实例来实现的，从而不会影响其他对象。实际上，对象可以通过一个或多个ConcreteDecorator来增加任意数量的责任。

3.2 模式原理阐述

  装饰器模式的原理可以用以下几个要点来概括：

四、装饰器模式的超能力

  首先，我们建立一个饮料的抽象类，并让所有的咖啡和调料装饰器继承这个类：

// 抽象组件，定义饮料
public abstract class Beverage {
    String description = "Unknown Beverage";
    public String getDescription() {
        return description;
    }
    public abstract double cost();
}
1
2
3
4
5
6
7
8

  现在，我们添加我们的基础组件，黑咖啡：

// 具体组件，实现抽象组件
public class BlackCoffee extends Beverage {
    public BlackCoffee() {
        description = "Black Coffee";
    }
    public double cost() {
        return 1.00;
    }
}
1
2
3
4
5
6
7
8
9

  接下来，我们定义装饰器的抽象类，所有的调料装饰器都应该继承它：

// 装饰器抽象类，扩展自Beverage
public abstract class CondimentDecorator extends Beverage {
    public abstract String getDescription();
}
1
2
3
4

  然后我们为每种调料创建具体的装饰器实现类：

// 牛奶装饰器
public class Milk extends CondimentDecorator {
    Beverage beverage;

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

    public String getDescription() {
        return beverage.getDescription() + ", Milk";
    }

    public double cost() {
        return beverage.cost() + 0.20;
    }
}

// 糖装饰器
public class Sugar extends CondimentDecorator {
    Beverage beverage;

    public Sugar(Beverage beverage) {
        this.beverage = beverage;
    }

    public String getDescription() {
        return beverage.getDescription() + ", Sugar";
    }

    public double cost() {
        return beverage.cost() + 0.10;
    }
}

// 摩卡装饰器
public class Mocha extends CondimentDecorator {
    Beverage beverage;

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

    public String getDescription() {
        return beverage.getDescription() + ", Mocha";
    }

    public double cost() {
        return beverage.cost() + 0.50;
    }
}

// 奶泡装饰器
public class Whip extends CondimentDecorator {
    Beverage beverage;

    public Whip(Beverage beverage) {
        this.beverage = beverage;
    }

    public String getDescription() {
        return beverage.getDescription() + ", Whip";
    }

    public double cost() {
        return beverage.cost() + 0.30;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

  最后，我们可以这样组合它们来创建不同的咖啡：

public class CoffeeShop {
    public static void main(String args[]) {
        // Order a black coffee without any condiments
        Beverage blackCoffee = new BlackCoffee();
        System.out.println(blackCoffee.getDescription() 
                           + " $" + blackCoffee.cost());
        
        // Add milk and sugar to the coffee
        Beverage coffeeWithMilkAndSugar = new BlackCoffee();
        coffeeWithMilkAndSugar = new Milk(coffeeWithMilkAndSugar);
        coffeeWithMilkAndSugar = new Sugar(coffeeWithMilkAndSugar);
        System.out.println(coffeeWithMilkAndSugar.getDescription() 
                           + " $" + coffeeWithMilkAndSugar.cost());
        
        // Make a fancy coffee by adding Milk, Mocha, and Whip to the coffee
        Beverage fancyCoffee = new BlackCoffee();
        fancyCoffee = new Milk(fancyCoffee);
        fancyCoffee = new Mocha(fancyCoffee);
        fancyCoffee = new Whip(fancyCoffee);
        System.out.println(fancyCoffee.getDescription() 
                           + " $" + fancyCoffee.cost());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

  在这个例子中，我们可以看到装饰器模式如何在不更改BlackCoffee类的情况下动态地为咖啡添加额外的调料。我们可以随意添加新的装饰器以实现新的功能，这展示了模式的灵活性。

五、装饰器模式的优缺点分析

5.1 优点

5.2 缺点

六、装饰器模式在现实世界中的应用

6.1 场景

  奖金计算方式:

    上面的业务场景下计算奖金的方式有点复杂，这里主要是讲解设计模式，所以对上面的奖金的计算简化后如下：

6.2 不用装饰模式实现

  一个类中添加计算各种类型奖金的方法，实现代码如下：

/**
 * 计算奖金的对象
 *
 * @author danci_
 * @date 2024/2/4 12:22:03
 */
public class Prize {

    public static Map<String, Double> mapMonthSaleMoney = new HashMap<>();
    // 模拟数据，实际的工作中数据一般来源于数据库中
    static {
        mapMonthSaleMoney.put("张三", 100000D);
        mapMonthSaleMoney.put("李四", 200000D);
        mapMonthSaleMoney.put("王五", 300000D);
    }

    /**
     * 计算某人的奖金
     *
     * @param user 被计算奖金的人员
     * @return 某人的奖金
     */
    public double calcPrice(String user) {
        double prize = 0D;
        // 计算当月业务奖金，所有人都会计算
        prize = monthPrice(user);
        // 计算累计奖金
        prize += sumPrize(user);
        // 如果是经理，则添加团队奖金
        if (isManager(user)) {
            prize += groupPrice(user);
        }
        return prize;
    }

    private double monthPrice(String user) {
        // 计算当月业务奖金，按照人员去获取当月的业务额，然后乘以 3%
        double prize = mapMonthSaleMoney.get(user) * 0.03;
        System.out.println(user + " 当月的业务奖金为：" + prize);
        return prize;
    }

    /**
     * 计算某人的累计奖金
     * @param user 被计算奖金的人员
     * @return 某人的累计奖金
     */
    public double sumPrize(String user) {
        // 计算累计奖金，其实该按照人员去获取累计的业务额，然后再乘以 0。1%
        // 简单演示一下，假定大家的累计业务额都是 1000000 元
        double prize = 1000000 * 0.001;
        System.out.println(user + " 累计奖金为：" + prize);
        return prize;
    }

    private boolean isManager(String user) {
        // 这里假定王五为经理（实际的场景应该是从数据中获取用户的角色信息，判断是否为经理）
        return "王五".equals(user);
    }

    public double groupPrice(String user) {
        // 计算当月团队业务奖金，先计算出团队总的业务额，然后再乘以1%
        double group = 0D;
        for (double d : mapMonthSaleMoney.values()) {
            group += d;
        }
        System.out.println(user + " 当月团队业务奖金为：" + group * 0.01);
        return group * 0.01;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

  客户端代码如下：

/**
 * 计算奖金类 <br/>
 *
 * @author danci_
 * @date 2024/2/4 12:36:28
 */
public class Client {
    public static void main(String[] args) {
        Prize p = new Prize();

        // 计算张三的奖金
        double prize1 = p.calcPrice("张三");
        System.out.println("张三奖金为：" + prize1);
        // 计算李四的奖金
        double price2 = p.calcPrice("李四");
        System.out.println("李四奖金为：" + price2);
        // 计算王五的奖金
        double price3 = p.calcPrice("王五");
        System.out.println("王五奖金为：" + price3);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

  测试运行结果如下：

张三 当月的业务奖金为：3000.0
张三 累计奖金为：1000.0
张三奖金为：4000.0
李四 当月的业务奖金为：6000.0
李四 累计奖金为：1000.0
李四奖金为：7000.0
王五 当月的业务奖金为：9000.0
王五 累计奖金为：1000.0
王五 当月团队业务奖金为：6000.0
王五奖金为：16000.0
1
2
3
4
5
6
7
8
9
10

6.3 问题和痛点

  问题

  痛点

6.4 使用装饰模式实现

  解决上述问题的一个合理的方案是使用装饰模式。

6.4.1 装饰模式定义

6.4.2 解决思路

6.4.3 装饰器模式的结构和说明

注意：Decorator 这个被装饰的对象不一定是最原始的那个对象了，也可能是被其他装饰器装饰过后的对象，反正都是实现的同一个接口，也就是同一类型。
1

6.4.4 示例代码

  组件抽象类

/**
 * 组件对象的抽象类，可以给这些对象动态地添加职责 <br/>
 *
 * @author danci_
 * @date 2024/2/4 16:28:52
 */
public abstract class Component {

    /**
     * 示例方法
     */
    public abstract void operation();
}
1
2
3
4
5
6
7
8
9
10
11
12
13

  组件实现类

/**
 * 具体实现组件对象接口的对象 <br/>
 *
 * @author danci_
 * @date 2024/2/4 16:29:40
 */
public class ConcreteComponent extends Component {

    @Override
    public void operation() {
        // 相应的功能逻辑
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

  装饰器对象

/**
 * 装饰器抽象类，维持一个指向组件对象的接口对象，并定义一个与组件接口一致的接口 <br/>
 *
 * @author danci_
 * @date 2024/2/4 16:30:31
 */
public abstract class Decorator extends Component {

    protected Component component;

    /**
     * 构造方法，传入组件对象
     * @param component 组件对象
     */
    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        // 转发请求给组件对象，可以在转发前后执行 一些附加动作
        component.operation();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

  具体的装饰器实现类A，示意添加状态

/**
 * 装饰器的具体实现对象，向组件对象添加状态 <br/>
 *
 * @author danci_
 * @date 2024/2/4 16:31:48
 */
@Data
public class ConcreteDecoratorA extends Decorator {

    /**
     * 构造方法，传入组件对象
     *
     * @param component 组件对象
     */
    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    private String addeState;

    public void operation() {
        // 调用父类的方法，可以在调用前后执行一些附加动作
        // 在这里进行处理的时候，可以使用添加的状态
        super.operation();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

  具体的装饰器实现类B，示意添加职责

/**
 * 装饰器的具体实现对象，向组件对象添加职责 <br/>
 *
 * @author danci_
 * @date 2024/2/4 16:34:31
 */
public class ConcreteDecoratorB extends Decorator {

    /**
     * 构造方法，传入组件对象
     *
     * @param component 组件对象
     */
    public ConcreteDecoratorB(Component component) {
        super(component);
    }

    public void addedBehavior() {
        // 需要添加的职责实现
    }

    public void operation() {
        // 调用父类的方法，可以在调用前后执行一些附加动作
        super.operation();
        addedBehavior();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

6.4.5 用装饰器模式重写示例

  大致的实现步骤

  实现代码
  组件抽象类

/**
 * 计算奖金的组件抽象类 <br/>
 *
 * @author danci_
 * @date 2024/2/4 16:28:52
 */
public abstract class Component {

    /**
     * 计算某人的奖金
     * @param user 被计算奖金的人员
     */
    public abstract double calcPrize(String user);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

  组件实现类

/**
 * 基本的实现计算奖金的类，也是被装饰器装饰的对象 <br/>
 *
 * @author danci_
 * @date 2024/2/4 16:29:40
 */
public class ConcreteComponent extends Component {

    @Override
    public double calcPrize(String user) {
        // 默认的实现，没有奖金
        return 0;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

  装饰器抽象类
  在进 一步定义装饰器之前，先定义出各个装饰器公共的父类，在这里定义所有装饰器对象需要实现的方法。这个父类应该实现组件的接口，这样才能保证装饰后的对象仍然可以继续被装饰。

/**
 * 装饰器的接口，需要和被装饰的对象实现同样的接口 <br/>
 *
 * @author danci_
 * @date 2024/2/4 16:30:31
 */
public abstract class Decorator extends Component {


    public static Map<String, Double> mapMonthSaleMoney = new HashMap<>();
    // 模拟数据，实际的工作中数据一般来源于数据库中
    static {
        mapMonthSaleMoney.put("张三", 15000D);
        mapMonthSaleMoney.put("李四", 22000D);
        mapMonthSaleMoney.put("王五", 37000D);
    }

    /**
     * 持有被装饰的组件对象
     */
    protected Component component;

    /**
     * 通过构造方法传入被装饰的对象
     * @param component 组件对象
     */
    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public double calcPrize(String user) {
        // 转调组件对象的方法
        return component.calcPrize(user);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

  装饰器具体的实现类
  用一个具体的装饰器对象，来实现一条计算奖金的规则。现在有三条计算奖金的规则，那就对应有三个装饰器对象来实现。下面依次来看看它们的实现。
  装饰器具体的实现类-当月业务奖金

/**
 * 装饰器对象，计算当月业务奖金 <br/>
 *
 * @author danci_
 * @date 2024/2/4 16:50:39
 */
public class MonthPrizeDecorator extends Decorator {
    /**
     * 通过构造方法传入被装饰的对象
     *
     * @param component 组件对象
     */
    public MonthPrizeDecorator(Component component) {
        super(component);
    }

    @Override
    public double calcPrize(String user) {
    	// 先获取前面运算出来的资金
        double money = super.calcPrize(user);
        // 然后计算当月业务资金，按人员去获取，然后再乘以3%
        double prize = mapMonthSaleMoney.get(user);
        System.out.println(user + " 当月资金为：" + prize * 0.03);
        return money + prize * 0.03;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

  装饰器具体的实现类-累计资金

/**
 * 装饰器对象，计算累计奖金 <br/>
 *
 * @author danci_
 * @date 2024/2/4 16:53:06
 */
public class SumPrizeDecorator extends Decorator {
    /**
     * 通过构造方法传入被装饰的对象
     *
     * @param component 组件对象
     */
    public SumPrizeDecorator(Component component) {
        super(component);
    }

    public double calcPrize(String user) {
    	// 先获取前面运算出来的资金
        double money = super.calcPrize(user);
        // 然后计算累计资金，按人员获取累计的业务额，然后再乘以 0.1%
        // 假设大家的累计业务额都是150000
        double prize = 150000 * 0.001;
        System.out.println(user + " 累计奖金为：" + prize);
        return money + prize;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

  装饰器具体的实现类-当月团队业务资金

/**
 * 装饰器对象，计算当月团队业务奖金 <br/>
 *
 * @author danci_
 * @date 2024/2/4 16:54:33
 */
public class GroupPrizeDecorator extends Decorator {
    /**
     * 通过构造方法传入被装饰的对象
     *
     * @param component 组件对象
     */
    public GroupPrizeDecorator(Component component) {
        super(component);
    }

    @Override
    public double calcPrize(String user) {
   	 	// 先获取前面运算出来的资金
        double money = super.calcPrize(user);
        // 然后计算当月团队业务资金，先计算出团队总业务额，然后再乘以 1%
        // 这里假定张三、李四和王五 为一个团队
        double group = 0D;
        for (double d : mapMonthSaleMoney.values()) {
            group += d;
        }
        double prize = group * 0.01;
        System.out.println(user + " 当月团队业务奖金为：" + prize);
        return money + prize;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

  客户端
  1. 首先需要创建被装饰的对象
  2. 然后创建需要的装饰对象
  3. 接下来是组合装饰对象，然后对前面的对象进行装饰

/**
 * 计算奖金类 <br/>
 *
 * @author danci_
 * @date 2024/2/4 12:36:28
 */
public class Client {
    public static void main(String[] args) {
        // 先创建计算基本奖金的类，这也是被装饰的对象
        Component c1 = new ConcreteComponent();
        // 然后对计算的基本奖金进行装饰，这里要组合各个装饰
        // 说明，各个装饰者之间最好是不要有先后顺序的限制
        // 也就是先装饰谁和后装饰谁都应该是一样的

        // 先组合普通业务人员的奖金计划
        Decorator d1 = new MonthPrizeDecorator(c1);
        Decorator d2 = new SumPrizeDecorator(d1);
        // 这里只需使用最后组合好的对象调用业务方法即可，会依次调用回去
        double prize1 = d2.calcPrize("张三");
        System.out.println("------------张三应得奖金为：" + prize1);
        double prize2 = d2.calcPrize("李四");
        System.out.println("------------李四应得奖金为：" + prize2);

        System.out.println("----------------");
        // 业务经理添加团队奖金
        Decorator d3 = new GroupPrizeDecorator(d2);
        double prize4 = d3.calcPrize("王五");
        System.out.println("------王经应得奖金为：" + prize4);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

  运行结果如下

张三 当月资金为：450.0
张三 累计奖金为：150.0
------------张三应得奖金为：600.0
李四 当月资金为：660.0
李四 累计奖金为：150.0
------------李四应得奖金为：810.0
----------------
王五 当月资金为：1110.0
王五 累计奖金为：150.0
王五 当月团队业务奖金为：740.0
------王经应得奖金为：2000.0
1
2
3
4
5
6
7
8
9
10
11

  当测试运行的时候会按照装饰器的组合顺序，依次调用相应的装饰器来执行业务功能，是一个递归的调用方法。以业务经理“王五”为例，王五的资金计算过程如下图

注：这个图很好地揭示了装饰模式的组合和调用过程，请仔细体会一下

6.4.6 用装饰器模式重写示例-结构图

6.5 装饰器模式讲解

6.5.1 装饰器的功能

6.5.2 对象组合

  对象组合

public class Engine {
    public void run() {
        System.out.println("执行引擎的功能.");
    }
}
public class Car {
    private Engine engine = new Engine();
    public void run() {
        // 转调引擎的功能
        // 在转调前后可以做一些功能处理，对于Engine对象来说是透明的。
        engine.run();
    }
    public void oth() {
        System.out.println("其它功能。");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

  用对象组合来实现简单了，也更灵活了。

  何时创建被组合对象的实例

6.5.3 装饰器

  扮演着的重要角色和作用

  装饰器与组合类的关系

    装饰器类和组件类之间的关系可以描述为：

七、从装饰器模式看设计原则

7.1 开闭原则

7.2 合成复用原则

7.3 装饰器模式中的开闭原则

  实践

  步骤

7.4 装饰器模式中的合成复用原则

  实践

  步骤

八、结语