设计模式(八)：结构型之装饰器模式

设计模式系列文章

设计模式(一)：创建型之单例模式

设计模式(二、三)：创建型之工厂方法和抽象工厂模式

设计模式(四)：创建型之原型模式

设计模式(五)：创建型之建造者模式

设计模式(六)：结构型之代理模式

设计模式(七)：结构型之适配器模式

设计模式(八)：结构型之装饰器模式

---

---

一、设计模式分类

• 创建型模式
  • 用于描述“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”
  • 提供了单例、原型、工厂方法、抽象工厂、建造者 5 种创建型模式
• 结构型模式
  • 用于描述如何将类或对象按某种布局组成更大的结构
  • 提供了代理、适配器、桥接、装饰、外观、享元、组合 7 种结构型模式
• 行为型模式
  • 用于描述类或对象之间怎样相互协作共同完成单个对象无法单独完成的任务，以及怎样分配职责
  • 提供了模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器 11 种行为型模式

二、装饰者模式

1、概述

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

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

传统方式：

• FastFood顶层食物父类抽象对象
• FriedRice和FriedNoodles具体是主食及价格
• 最下面的就是加不同配料的主食和总价

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

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

装饰者模式定义

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

2、结构

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

• 抽象构件（Component）角色 ：定义一个抽象接口以规范准备接收附加责任的对象
• 具体构件（Concrete Component）角色 ：实现抽象构件，通过装饰角色为其添加一些职责
• 抽象装饰（Decorator）角色 ： 继承或实现抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能
• 具体装饰（ConcreteDecorator）角色 ：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任

3、实现

• 使用装饰者模式对快餐店案例进行改进
• 类图如下：

代码如下：

• 食品抽象类
• 主食和配料都是它的子类

@Data
@AllArgsConstructor
public abstract class FastFood {
    private float price;//价格
    private String desc; //描述
    public abstract float cost();//获取价格
}

• 炒饭类和炒面类
• 构造方法就是调用父类构造方法，赋值价格和描述

//炒饭
public class FriedRice extends FastFood {
	
    public FriedRice() {
        super(10, "炒饭");
    }

	@Override
    public float cost() {
        return getPrice();
    }
}

//炒面
public class FriedNoodles extends FastFood {

    public FriedNoodles() {
        super(12, "炒面");
    }
    
	@Override
    public float cost() {
        return getPrice();
    }
}

• 配料抽象类
• 将主食聚合进来

@Data
public abstract class Garnish extends FastFood {
    //声明快餐类的变量
    private FastFood fastFood;

    public Garnish(FastFood fastFood,float price, String desc) {
        super(price, desc);
        this.fastFood = fastFood;
    }
}

• 配料类
• 配料的构造方法就把主食添加上了
• 重新总价方法：配料价格 + 聚合进来的主食的价格
• 重新描述方法：主食描述 + 配料描述

//鸡蛋配料
public class Egg extends Garnish {

    public Egg(FastFood fastFood) {
        super(fastFood,1,"鸡蛋");
    }

	@Override
    public float cost() {
        return getPrice() + getFastFood().getPrice();
    }

    @Override
    public String getDesc() {
        return super.getDesc() + getFastFood().getDesc();
    }
}

//培根配料
public class Bacon extends Garnish {

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

    @Override
    public float cost() {
        return getPrice() + getFastFood().getPrice();
    }

    @Override
    public String getDesc() {
        return super.getDesc() + getFastFood().getDesc();
    }
}

• 测试类

public class Client {
    public static void main(String[] args) {
        //点一份炒饭
        FastFood food = new FriedRice();

        System.out.println(food.getDesc() + "  " + food.cost() + "元");

        System.out.println("===============");

        //在上面的炒饭中加一个鸡蛋
        food = new Egg(food);
        System.out.println(food.getDesc() + "  " + food.cost() + "元");

        System.out.println("================");
        //再加一个鸡蛋
        food = new Egg(food);
        System.out.println(food.getDesc() + "  " + food.cost() + "元");

        System.out.println("================");
        food = new Bacon(food);
        System.out.println(food.getDesc() + "  " + food.cost() + "元");
    }
}

• 主要原理就是继承食品抽象类由聚合食品抽象类
  • 配料类的构造方法里需要聚合食品抽象类
  • 然后生成的食品又成了下一个配料类可以聚合进去的食品类

4、JDK源码解析

• IO流中的包装类使用到了装饰者模式
• BufferedInputStream，BufferedOutputStream，BufferedReader，BufferedWriter

以BufferedWriter举例来说明

public class Demo {
    public static void main(String[] args) throws Exception{
        //创建BufferedWriter对象
        //创建FileWriter对象
        FileWriter fw = new FileWriter("C:\\Users\\Think\\Desktop\\a.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        //写数据
        bw.write("hello Buffered");
        bw.close();
    }
}

使用起来感觉确实像是装饰者模式，接下来看它们的结构：

• BufferedWriter类继承Writer，又聚合Writer，构造函数聚合进去
• 上面例子聚合进去的就是FileWriter fw
• BufferedWriter重新了write(char cbuf[], int off, int len)，具体实现又是调用fw.write

小结：

BufferedWriter使用装饰者模式对Writer子实现类进行了增强，添加了缓冲区，提高了写数据的效率

5、代理和装饰者的区别

相同点

• 都要实现与目标类相同的业务接口
• 在两个类中都要声明目标对象
• 都可以在不修改目标类的前提下增强目标方法

不同点

• 目的不同
  • 装饰者是为了增强目标对象
  • 静态代理是为了保护和隐藏目标对象
• 获取目标对象构建的地方不同
  • 装饰者是由外界传递进来，可以通过构造方法传递（聚合目标对象）
  • 静态代理是在代理类内部创建，以此来隐藏目标对象（组合目标对象）