装饰模式¶

装饰模式是一种结构型设计模式，允许你通过将对象放入包含行为的特殊封装对象中来为原对象绑定新的行为。

../../_images/decorator.png

问题¶

假设你正在开发一个提供通知功能的库，其他程序可使用它向用户发送关于重要事件的通知。

库的最初版本基于 通知器Notifier类，其中只有很少的几个成员变量，一个构造函数和一个 send发送方法。该方法可以接收来自客户端的消息参数，并将该消息发送给一系列的邮箱，邮箱列表则是通过构造函数传递给通知器的。作为客户端的第三方程序仅会创建和配置通知器对象一次，然后在有重要事件发生时对其进行调用。

../../_images/send_problem.png

此后某个时刻，你会发现库的用户希望使用除邮件通知之外的功能。许多用户会希望接收关于紧急事件的手机短信，还有些用户希望在微信上接收消息，而公司用户则希望在 QQ 上接收消息。

../../_images/send_problem2.png

这有什么难的呢？首先扩展 通知器类，然后在新的子类中加入额外的通知方法。现在客户端要对所需通知形式的对应类进行初始化，然后使用该类发送后续所有的通知消息。

但是很快有人会问： “为什么不同时使用多种通知形式呢？如果房子着火了，你大概会想在所有渠道中都收到相同的消息吧。”

你可以尝试创建一个特殊子类来将多种通知方法组合在一起以解决该问题。但这种方式会使得代码量迅速膨胀，不仅仅是程序库代码，客户端代码也会如此。

../../_images/send_problem3.png

你必须找到其他方法来规划通知类的结构，否则它们的数量会在不经意之间打破吉尼斯纪录。

解决方案¶

当你需要更改一个对象的行为时，第一个跳入脑海的想法就是扩展它所属的类。但是，你不能忽视继承可能引发的几个严重问题。

继承是静态的。你无法在运行时更改已有对象的行为，只能使用由不同子类创建的对象来替代当前的整个对象。
子类只能有一个父类。大部分编程语言不允许一个类同时继承多个类的行为。

其中一种方法是用聚合或组合，而不是继承。两者的工作方式几乎一模一样：一个对象包含指向另一个对象的引用，并将部分工作委派给引用对象；继承中的对象则继承了父类的行为，它们自己能够完成这些工作。

你可以使用这个新方法来轻松替换各种连接的 “小帮手” 对象，从而能在运行时改变容器的行为。一个对象可以使用多个类的行为，包含多个指向其他对象的引用，并将各种工作委派给引用对象。

聚合（或组合）组合是许多设计模式背后的关键原则（包括装饰在内）。记住这一点后，让我们继续关于模式的讨论。

../../_images/send_solution1.png

封装器是装饰模式的别称，这个称谓明确地表达了该模式的主要思想。 “封装器” 是一个能与其他 “目标” 对象连接的对象。封装器包含与目标对象相同的一系列方法，它会将所有接收到的请求委派给目标对象。但是，封装器可以在将请求委派给目标前后对其进行处理，所以可能会改变最终结果。

那么什么时候一个简单的封装器可以被称为是真正的装饰呢？正如之前提到的，封装器实现了与其封装对象相同的接口。因此从客户端的角度来看，这些对象是完全一样的。封装器中的引用成员变量可以是遵循相同接口的任意对象。这使得你可以将一个对象放入多个封装器中，并在对象中添加所有这些封装器的组合行为。

比如在消息通知示例中，我们可以将简单邮件通知行为放在基类 通知器中，但将所有其他通知方法放入装饰中。

../../_images/send_solution2.png

客户端代码必须将基础通知器放入一系列自己所需的装饰中。因此最后的对象将形成一个栈结构。

../../_images/send_solution.png

实际与客户端进行交互的对象将是最后一个进入栈中的装饰对象。由于所有的装饰都实现了与通知基类相同的接口，客户端的其他代码并不在意自己到底是与 “纯粹” 的通知器对象，还是与装饰后的通知器对象进行交互。

我们可以使用相同方法来完成其他行为（例如设置消息格式或者创建接收人列表）。只要所有装饰都遵循相同的接口，客户端就可以使用任意自定义的装饰来装饰对象。

装饰模式结构¶

../../_images/decorator_structure.png

部件（Component）声明封装器和被封装对象的公用接口。
具体部件 （Concrete Component）类是被封装对象所属的类。它定义了基础行为，但装饰类可以改变这些行为。
基础装饰 （Base Decorator）类拥有一个指向被封装对象的引用成员变量。该变量的类型应当被声明为通用部件接口，这样它就可以引用具体的部件和装饰。装饰基类会将所有操作委派给被封装的对象。
具体装饰类 （Concrete Decorators）定义了可动态添加到部件的额外行为。具体装饰类会重写装饰基类的方法，并在调用父类方法之前或之后进行额外的行为。
客户端 （Client）可以使用多层装饰来封装部件，只要它能使用通用接口与所有对象互动即可。

真实世界类比¶

../../_images/decorator_real_world.png

穿衣服是使用装饰的一个例子。觉得冷时，你可以穿一件毛衣。如果穿毛衣还觉得冷，你可以再套上一件夹克。如果遇到下雨，你还可以再穿一件雨衣。所有这些衣物都 “扩展” 了你的基本行为，但它们并不是你的一部分，如果你不再需要某件衣物，可以方便地随时脱掉。

代码示例¶

//@ 所有饮料的基类
class IBeverage
{
public:
	virtual ~IBeverage() = default;
	virtual string name() = 0;  //@ 名称
	virtual double cost() = 0;  //@ 价钱
};

//@ 黑咖啡，属于混合咖啡
class HouseBlend : public IBeverage
{
public:
	virtual string name() override
	{
		return "HouseBlend";
	}

	virtual double cost() override 
	{
		return 30.0;
	}
};

//@ 深度烘培咖啡豆
class DarkRoast : public IBeverage
{
public:
	virtual string name() override 
	{
		return "DarkRoast";
	}

	virtual double cost() override 
	{
		return 28.5;
	}
};

//@ 调味品
class CondimentDecorator : public IBeverage
{
public:
	CondimentDecorator(std::shared_ptr<IBeverage> beverage) : pBeverage_(beverage) {}

	virtual string name() override
	{
		return pBeverage_->name();
	}

	virtual double cost() override
	{
		return pBeverage_->cost();
	}

protected:
	std::shared_ptr<IBeverage> pBeverage_;
};


//@ 奶油
class Cream : public CondimentDecorator
{
public:
	Cream(std::shared_ptr<IBeverage> beverage) : CondimentDecorator(beverage) {}

	virtual string name() override
	{
		return pBeverage_->name() + " + Cream";
	}

	virtual double cost() override 
	{
		return pBeverage_->cost() + 3.5;
	}
};

//@ 摩卡
class Mocha : public CondimentDecorator
{
public:
	Mocha(std::shared_ptr<IBeverage> beverage) : CondimentDecorator(beverage) {}

	virtual string name() override 
	{
		return pBeverage_->name() + " + Mocha";
	}

	virtual double cost() override 
	{
		return pBeverage_->cost() + 2.0;
	}
};

//@ 糖浆
class Syrup : public CondimentDecorator
{
public:
	Syrup(std::shared_ptr<IBeverage> beverage) : CondimentDecorator(beverage) {}

	virtual string name() override 
	{
		return pBeverage_->name() + " + Syrup";
	}

	virtual double cost() override 
	{
		return pBeverage_->cost() + 3.0;
	}
};

int main()
{
	/********** 黑咖啡 **********/
	std::shared_ptr<IBeverage> pHouseBlend(new HouseBlend());
	cout << pHouseBlend->name() << " : " << pHouseBlend->cost() << endl;

	//@ 黑咖啡 + 奶牛
	std::shared_ptr<CondimentDecorator> pCream(new Cream(pHouseBlend));
	cout << pCream->name() << " : " << pCream->cost() << endl;

	//@ 黑咖啡 + 摩卡
	std::shared_ptr<CondimentDecorator> pMocha(new Mocha(pHouseBlend));	
	cout << pMocha->name() << " : " << pMocha->cost() << endl;

	//@ 黑咖啡 + 糖浆
	std::shared_ptr<CondimentDecorator> pSyrup(new Syrup(pHouseBlend));
	cout << pSyrup->name() << " : " << pSyrup->cost() << endl;

	/********** 深度烘培咖啡豆 **********/
	std::shared_ptr<IBeverage> pDarkRoast(new DarkRoast());
	cout << pDarkRoast->name() << " : " << pDarkRoast->cost() << endl;

	// 深度烘培咖啡豆 + 奶油
	std::shared_ptr<CondimentDecorator> pCreamDR(new Cream(pDarkRoast));
	cout << pCreamDR->name() << " : " << pCreamDR->cost() << endl;

	//// 深度烘培咖啡豆 + 奶油 + 摩卡
	std::shared_ptr<CondimentDecorator> pCreamMocha(new Mocha(pCreamDR));
	cout << pCreamMocha->name() << " : " << pCreamMocha->cost() << endl;

	//// 深度烘培咖啡豆 + 奶油 + 摩卡 + 糖浆
	std::shared_ptr<CondimentDecorator> pCreamMochaSyrup(new Syrup(pCreamMocha));
	cout << pCreamMochaSyrup->name() << " : " << pCreamMochaSyrup->cost() << endl;

	return 0;
}

装饰模式总结¶

实现方式¶

确保业务逻辑可用一个基本组件及多个额外可选层次表示。
找出基本组件和可选层次的通用方法。创建一个组件接口并在其中声明这些方法。
创建一个具体组件类，并定义其基础行为。
创建装饰基类，使用一个成员变量存储指向被封装对象的引用。该成员变量必须被声明为组件接口类型，从而能在运行时连接具体组件和装饰。装饰基类必须将所有工作委派给被封装的对象。
确保所有类实现组件接口。
将装饰基类扩展为具体装饰。具体装饰必须在调用父类方法（总是委派给被封装对象）之前或之后执行自身的行为。
客户端代码负责创建装饰并将其组合成客户端所需的形式。

优点¶

无需创建新子类即可扩展对象的行为。
可以在运行时添加或删除对象的功能。
可以用多个装饰封装对象来组合几种行为。
单一职责原则。你可以将实现了许多不同行为的一个大类拆分为多个较小的类。

缺点¶

在封装器栈中删除特定封装器比较困难。
实现行为不受装饰栈顺序影响的装饰比较困难。
各层的初始化配置代码看上去可能会很糟糕。

适用场景¶

在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
当不能采用继承的方式对系统进行扩展或者采用继承不利于系统扩展和维护时可以使用装饰模式。不能采用继承的情况主要有两类：
第一类是系统中存在大量独立的扩展，为支持每一种扩展或者扩展之间的组合将产生大量的子类，使得子类数目呈爆炸性增长
第二类是因为类已定义为不能被继承