09 结构型模式之装饰者模式（decorator）

1 概述

1.1 引入

我们先来看一个快餐店的例子。

快餐店有炒面、炒饭这些快餐，可以额外附加鸡蛋、火腿、培根这些配菜，当然加配菜需要额外加钱，每个配菜的价钱通常不太一样，那么计算总价就会显得比较麻烦。

如果像上面的类图一样，通过继承的方式实现，最大的弊端就是，会引起类爆炸，比如我们新增炒河粉，就要定义一个炒河粉类继承FastFood，在定义一个鸡蛋炒河粉，培根炒粉；同样如果新增一种配料芝士，就需要在炒面，炒饭分别提供芝士炒面，芝士炒饭。如果是需要鸡蛋培根炒面呢，难道再定义一个鸡蛋培根炒面

使用继承的方式存在的问题：

• 扩展性不好

  如果要再加一种配料（火腿肠），我们就会发现需要给FriedRice和FriedNoodles分别定义一个子类。如果要新增一个快餐品类（炒河粉）的话，就需要定义更多的子类。

• 产生过多的子类

定义：

​ 指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式。

1.2 结构

装饰（Decorator）模式中的角色：

• 抽象构件（Component）角色 ：定义一个抽象接口以规范准备接收附加责任的对象。比如这里的炒饭，炒粉可以抽象出一个基类（上面类图中的FastFood）
• 具体构件（Concrete Component）角色 ：实现抽象构件，通过装饰角色为其添加一些职责。比如上面类图中的炒饭，炒面
• 抽象装饰（Decorator）角色 ： 继承或实现抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。抽象出一个抽象的装饰者，所有的装饰者需要继承该抽象装饰者
• 具体装饰（ConcreteDecorator）角色 ：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。比如上面中的鸡蛋，培根等可添加的配菜。

2 实现

使用装饰者实现上面的案例

1. 定义一个抽象构建角色，这里就是炒饭，炒面我们抽象出一个快餐基类

package study.wyy.design.decorator.after;

import lombok.Getter;
import lombok.Setter;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/12 9:35 下午
 * 快餐基类
 */

public abstract class FastFood {
    @Getter@Setter
    private final String name;

    @Getter@Setter
    private final float price;

    public FastFood(String name, float price) {
        this.name = name;
        this.price = price;
    }

    /****
     * 计算价格，可以交给具体的子类实现
     * 默认就是返回属性中的价格
     * @return
     */
    public  float cost(){
        return getPrice();
    }
}

2. 定义具体构件（Concrete Component）角色 ，就是炒饭，炒面

package study.wyy.design.decorator.after;

/**
 * @author by wyaoyao
 * @Description： 炒饭
 * @Date 2020/12/13 8:26 上午
 */
public class FriedRice extends FastFood{
    public FriedRice(String name, float price) {
        super(name, price);
    }
    public FriedRice() {
        // 普通价格为12 
        super("炒饭",12);
    }
}

package study.wyy.design.decorator.after;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/13 8:29 上午
 */
public class FriedNoodles extends FastFood{

    public FriedNoodles(String name, float price) {
        super(name, price);
    }

    public FriedNoodles() {
        // 普通炒面为10
        super("炒面",10);
    }
}

3. 定义抽象装饰（Decorator）角色 ，对鸡蛋，培根等配料进行抽象，继承快餐类，这样才可以通过装饰者对快餐类的cost方法进行增强（根据加蛋的不同进行计算价格）

package study.wyy.design.decorator.after;

import lombok.Getter;
import lombok.Setter;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/13 8:32 上午
 * 配料
 */
public abstract class Garnish extends FastFood{

    @Setter @Getter
    private FastFood fastFood;

    @Setter @Getter
    /****
     * 配料的数量：比如加蛋的数量，默认一个
     */
    private int num = 1;
    public Garnish(FastFood fastFood,String name,float price) {
        super(name,price);
        this.fastFood = fastFood;
    }
}

4. 具体装饰（ConcreteDecorator）角色

package study.wyy.design.decorator.after;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/13 9:00 上午
 */
public class Egg extends Garnish{


    public Egg(FastFood fastFood,int num) {
        // 加蛋一块
        super(fastFood, "鸡蛋", 1);
        super.setNum(num);
    }

    public Egg(FastFood fastFood) {
        // 加蛋一块
        super(fastFood, "鸡蛋", 1);
    }

    @Override
    public float cost() {
        // 加蛋数量 * 鸡蛋价钱 + 基本价钱
        return getPrice() * getNum()+ super.getFastFood().getPrice();
    }

    @Override
    public String getName() {
        return "加蛋" + super.getFastFood().getName();
    }
}

package study.wyy.design.decorator.after;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/13 9:00 上午
 */
public class Bacon extends Garnish{


    public Bacon(FastFood fastFood, int num) {
        // 培根2元
        super(fastFood, "培根", 2);
        super.setNum(num);
    }

    public Bacon(FastFood fastFood) {
        // 加培2元
        super(fastFood, "培根", 2);
    }

    @Override
    public float cost() {
        // 加培根数量 * 培根价钱 + 基本价钱
        return getPrice() * getNum()+ super.getFastFood().getPrice();
    }

    @Override
    public String getName() {
        return "加培根" + super.getFastFood().getName();
    }
}

5. 测试

package study.wyy.design.decorator.after;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/13 9:05 上午
 */
public class Test {

    public static void main(String[] args) {
        // 炒饭
        FastFood friedRice = new FriedRice();
        System.out.println(friedRice.getName() + "  " + friedRice.cost() + "元");

        // 加两个鸡蛋炒饭
        Egg egg = new Egg(friedRice, 2);
        System.out.println(egg.getName() + "  " + egg.cost() + "元" + "  " + "加蛋"+egg.getNum()+"个");

        // 加3个培根炒饭
        Bacon bacon = new Bacon(friedRice, 3);
        System.out.println(bacon.getName() + "  " + bacon.cost() + "元" + "  " + "加蛋"+bacon.getNum()+"个");

    }
}

炒饭  12.0元
加蛋炒饭  14.0元  加蛋2个
加培根炒饭  18.0元  加蛋3个

类图

• 饰者模式可以带来比继承更加灵活性的扩展功能，使用更加方便，可以通过组合不同的装饰者对象来获取具有不同行为状态的多样化的结果。装饰者模式比继承更具良好的扩展性，完美的遵循开闭原则，继承是静态的附加责任，装饰者则是动态的附加责任。

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

这个时候我们在增加炒河粉的时候，只需要增加一个河粉类即可，实现配料和快餐的隔离，如果加其他的配料也是如此

3 总结

3.1 使用场景

• 当不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展和维护时。

  不能采用继承的情况主要有两类：

  • 第一类是系统中存在大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长；
  • 第二类是因为类定义不能继承（如final类）

• 在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。

• 当对象的功能要求可以动态地添加，也可以再动态地撤销时。

3.2 静态代理和装饰者的区别

静态代理和装饰者模式的区别：

• 相同点：
  • 都要实现与目标类相同的业务接口
  • 在两个类中都要声明目标对象
  • 都可以在不修改目标类的前提下增强目标方法
• 不同点：
  • 目的不同
    装饰者是为了增强目标对象
    静态代理是为了保护和隐藏目标对象
  • 获取目标对象构建的地方不同
    装饰者是由外界传递进来，可以通过构造方法传递
    静态代理是在代理类内部创建，以此来隐藏目标对象