程序员必知的23种设计模式之装饰者模式

1. 模式引出：星巴克咖啡订单项目

星巴克咖啡订单项目（咖啡馆）：

1. 咖啡种类/单品咖啡：Espresso(意大利浓咖啡)、ShortBlack、LongBlack(美式咖啡)、Decaf(无因咖啡)

2. 调料：Milk、Soy(豆浆)、Chocolate

3. 要求在扩展新的咖啡种类时，具有良好的扩展性、改动方便、维护方便

4. 使用OO的来计算不同种类咖啡的费用: 客户可以点单品咖啡，也可以单品咖啡+调料组合。

1.1 不好的方案

1. 设计一个抽象类Drink，含有计算价格和获取描述的必要方法，让所有单品咖啡继承
2. 穷举每种组合，都记录为一个类，也都继承Drink类

1.2 问题分析

这样设计，会有很多类，当我们增加一个单品咖啡，或者一个新的调料，类的数量就会倍增，就会出现类爆炸，可以考虑使用装饰者 模式

2. 装饰者模式定义

1. 装饰者模式：动态的将新功能附加到对象上。在对象功能扩展方面，它比继承更有弹性，装饰者模式也体现了开闭原则(ocp)

2.1 装饰者模式原理

1. 装饰者模式就像打包一个快递

• 主体：比如：陶瓷、衣服 (Component) // 被装饰者
• 包装：比如：报纸填充、塑料泡沫、纸板、木板(Decorator)

2. Component

• 主体：比如类似前面的Drink

3. ConcreteComponent和Decorator

• ConcreteComponent：具体的主体，

• Decorator: 装饰者，比如各调料.

4. 在Component与ConcreteComponent之间，如果ConcreteComponent类很多,还可以设计一个缓冲层，将共有的部分提取出来，抽象层一个类。
   

2.2 方案修改

将单品咖啡当成主体部分，配料当成装饰者，单品主体部分有一个抽象类Drink，负责定义价格属性和描述属性，获取价格的方法定义为cost，方便递归调用。Decorator继承Drink类，并在类内部聚合一个Drink实例，表示被装饰者，cost方法通过调用自身价格和被装饰者的cost方法，层层获取各个价格，从而获取总价格（ 类似链表的遍历 ）

Drink.java

public abstract class Drink {
	public String des;
	private float price = 0.0f;

	public void setDes(String des) {
		this.des = des;
	}

	public String getDes() {
		return des + " "+price;
	}

	public void setPrice(float price) {
		this.price = price;
	}

	public float getPrice() {
		return price;
	}

	public abstract float cost();

}

Decorator.java

public class Decorator extends Drink{

	private Drink drink;
	
	
	public Decorator(Drink drink) {
		this.drink = drink;
	}
	
	@Override
	public float cost() {
		return getPrice() + drink.cost();
	}
	
	@Override
	public String getDes() {
		return des + " " + getPrice() + " && " + drink.getDes();
	}

}

Chocolate.java

public class Chocolate extends Decorator{

	public Chocolate(Drink drink) {
		super(drink);
		setDes("Chocolate");
		setPrice(3.0f);
	}

}

Milk.java

public class Milk extends Decorator{

	public Milk(Drink drink) {
		super(drink);
		setDes("Milk");
		setPrice(1.0f);
	}

}

Soy.java

public class Soy extends Decorator{

	public Soy(Drink drink) {
		super(drink);
		setDes("Soy");
		setPrice(0.5f);
	}

}

Coffee.java

public class Coffee extends Drink{

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

}

Espresso.java

public class Espresso extends Coffee{
	
	public Espresso() {
		setDes("Espresso");
		setPrice(6.0f);
	}

}

LongBlack.java

public class LongBlack extends Coffee{
	
	public LongBlack() {
		setDes("LongBlack");
		setPrice(5.0f);
	}

}

ShortBlack.java

public class ShortBlack extends Coffee{
	
	public ShortBlack() {
		setDes("ShortBlack");
		setPrice(3.0f);
	}

}

测试Main.java

public class Main {
	public static void main(String[] args) {
        // 模拟牛奶 + 巧克力 + LongBlack咖啡订单
		Drink order = new LongBlack();
		Decorator chocolate = new Chocolate(order);
		Decorator milk = new Milk(chocolate);
		System.out.println(milk.cost());
		System.out.println(milk.getDes());
	}
}

输出结果

3. 装饰者模式在JDK1.8应用的源码分析

Java的IO结构，FilterInputStream就是一个装饰者

说明

1. InputStream 是抽象类, 类似前面的 Drink
2. FileInputStream 是 InputStream 子类，类似前面的 DeCaf, LongBlack
3. FilterInputStream 是 InputStream 子类：类似前面 的 Decorator 修饰者
4. DataInputStream 是 FilterInputStream 子类，具体的修饰者，类似前面的 Milk, Soy 等
5. FilterInputStream 类 有 protected volatile InputStream in; 即含被装饰者
6. 分析得出在jdk 的io体系中，就是使用装饰者模式

FilterInputStream.java

public class FilterInputStream extends InputStream {
    /**
     * The input stream to be filtered.
     */
     // 被装饰对象
    protected volatile InputStream in;
    ...
}