Decorator 裝飾對象結構模式：動態地給一個對象添加一些額外的職責，也稱包裝器 Wrapper。不過和 Adapter 模式不同，Decorator 模式僅改變對象的職責而不改變接口；而適配器則給對象一個全新的接口。
問題：要使用的對象將執行所需的基本功能。但是，可能需要爲這個對象將添加某些功能，這些附加，功能可能發生在對象的基礎功能之前或之後。所以，Decorator 適用於如下情況：1）在不影響其他對象的情況下，以動態、透明的方式給單個對象添加職責。2）處理那些可以撤消的職責。3）當不能採用生成子類的方法進行擴充時。一種情況是，可能有大量獨立的擴展，爲支持每一種組合將產生大量的子類，使得子類數目呈爆炸性增長。另一種情況可能是因爲類定義被隱藏，或類定義不能用於生成子類。
Decorator 裝飾模式的通用結構圖如下：
Component：定義一個對象接口，可以給這些對象動態地添加職責。
ConcreteComponent：定義一個對象，可以給這個對象添加一些職責。
Decorator：維持一個指向 Component 對象的指針，並定義一個與 Component 接口一致的接口。
ConcreteDecorator：向組件添加職責。
Decorator 將請求轉發給它的 Component 對象，並有可能在轉發請求前後執行一些附加的動作。
參與者與協作者：ConcreteComponent 讓 Decorator 對象爲自己添加功能。有時候用 ConcreteComponent 的派生類提供核心功能，在這種情況下 ConcreteComponent 類就不再具體的，而是抽象的。Component 類定義了所有這些類所使用的接口。
Decorator 裝飾模式，示例代碼如下：
1: //Decorator.h
2: #pragma once
3:
4: #include <iostream>
5: #include <string>
6:
7: // Component: 抽象基類, 定義一個對象接口, 可以爲這個接口動態的添加職責.
8: class Component
9: {
10: public:
11: Component(){ }
12: virtual ~Component(){ }
13:
14: //
15: virtual void Operation() = 0;
16: };
17:
18: // 派生自 Component, 在這裏表示需要給它動態添加職責的類
19: class ConcreteComponent : public Component
20: {
21: public:
22: ConcreteComponent(){ }
23: virtual ~ConcreteComponent(){ }
24:
25: //
26: virtual void Operation()
27: {
28: std::cout << "Operation of ConcreteComponent" << std::endl;
29: }
30: };
31:
32: // Decorator 裝飾類，抽象基類, 維護一個指向 Component 對象的指針
33: // Decorator 與 Component 是聚合關係
34: // 必須定義一個與 Component 接口一致的接口
35: // 如果僅需要添加一個職責時，沒有必要定義抽象的 Decorator 類，這時可以
36: // 把 Decorator 向 Component 轉發請求的職責合併到 ConcreteDecorator 中。
37: class Decorator : public Component
38: {
39: public:
40: Decorator(Component* pComponent)
41: : m_pComponent(pComponent){ }
42: virtual ~Decorator()
43: {
44: if(m_pComponent)
45: delete m_pComponent;
46: m_pComponent = NULL;
47: }
48:
49: //
50: virtual void Operation()
51: {
52: if(m_pComponent != NULL)
53: m_pComponent->Operation();
54: }
55:
56: protected:
57: Component* m_pComponent;
58: };
59:
60: // 派生自 Decorator, 這裏代表爲 ConcreateComponent 動態添加職責的類
61: // Decorator 的子類定義了特殊的裝飾功能，即爲 Component 添加了特定的功能
62: // Decorator 的子類，可以自由添加其它的一些操作及屬性
63: class ConcreteDecoratorA : public Decorator
64: {
65: public:
66: ConcreteDecoratorA(Component* pComponent, int elem)
67: : Decorator(pComponent), _privateElement(elem)
68: { }
69: virtual ~ConcreteDecoratorA(){ }
70:
71: virtual void Operation()
72: {
73: m_pComponent->Operation();
74: AddedBehavior();
75: PrintSelfState();
76: }
77: private:
78: void AddedBehavior()
79: {
80: std::cout << "AddedBehavior of ConcreteDecoratorA" << std::endl;
81: }
82:
83: // ConcreateDecoratorA 自己添加的操作
84: void PrintSelfState() const
85: {
86: std::cout << "ConcreteDecoratorA::_privateElement= "
87: << _privateElement << std::endl;
88: }
89: private:
90: int _privateElement;
91: };
92:
93: // ConcreateDecoratorB, Decorator 的子類，可以自由添加其它的一些操作及屬性
94: class ConcreteDecoratorB : public Decorator
95: {
96: public:
97: ConcreteDecoratorB(Component* pComponent, const std::string strB)
98: : Decorator(pComponent), _strB(strB)
99: { }
100: virtual ~ConcreteDecoratorB(){ }
101:
102: virtual void Operation()
103: {
104: m_pComponent->Operation();
105: AddedBehavior();
106: PrintSelfState();
107: }
108: private:
109: void AddedBehavior()
110: {
111: std::cout << "AddedBehavior of ConcreteDecoratorB" << std::endl;
112: }
113:
114: //ConcreateDecoratorB 自己添加的操作及屬性
115: void PrintSelfState() const
116: {
117: std::cout << "ConcreteDecoratorB:_strB= " << _strB << std::endl;
118: }
119: private:
120: std::string _strB;
121: };
122:
123: // ConcreateDecoratorC, Decorator 的子類，可以自由添加其它的一些操作及屬性
124: class ConcreteDecoratorC : public Decorator
125: {
126: public:
127: ConcreteDecoratorC(Component* pComponent) : Decorator(pComponent){ }
128: virtual ~ConcreteDecoratorC(){ }
129:
130: virtual void Operation()
131: {
132: m_pComponent->Operation();
133: AddedBehavior();
134: }
135: private:
136: void AddedBehavior()
137: {
138: std::cout << "AddedBehavior of ConcreteDecoratorC" << std::endl;
139: }
140: };
141: //Factory for test
142: class Factory
143: {
144: public:
145: //test
146: //如下工廠方法返回的爲：
147: //return (new ConcreteDecoratorC ( new ConcreteDecoratorA (new ConcreteComponent, 3)));
148: //可以看出，我們使用 ConcreteDecoratorA 裝飾了 ConcreteComponent
149: //然後又用 ConcreteDecoratorC 裝飾了 ConcreteDecoratorA
150: Component* getComponent1()
151: {
152: Component* myComponent;
153: myComponent = new ConcreteDecoratorA(new ConcreteComponent, 3);
154: myComponent = new ConcreteDecoratorC(myComponent);
155:
156: return myComponent;
157: }
158:
159: //test
160: //如下工廠方法返回的爲：
161: //return (new ConcreteDecoratorC ( new ConcreteDecoratorB
162: // ( new ConcreteDecoratorA (new ConcreteComponent, 3), "test")));
163: //可以看出，我們使用 ConcreteDecoratorA 裝飾了 ConcreteComponent
164: //然後又用 ConcreteDecoratorB 裝飾了 ConcreteDecoratorA
165: //最後又用 ConcreteDecoratorC 裝飾了 ConcreteDecoratorB
166: Component* getComponent2()
167: {
168: Component* myComponent;
169: myComponent = new ConcreteDecoratorA(new ConcreteComponent, 3);
170: myComponent = new ConcreteDecoratorB(myComponent, "test");
171: myComponent = new ConcreteDecoratorC(myComponent);
172:
173: return myComponent;
174: }
175: };
//test
1: //
2: #include "Decorator.h"
3: #include <stdlib.h>
4:
5: int main()
6: {
7: Factory* myFactory = new Factory;
8: Component* myComponent1 = myFactory->getComponent1();
9: myComponent1->Operation();
10:
11: std::cout << std::endl;
12:
13: Component* myComponent2 = myFactory->getComponent2();
14: myComponent2->Operation();
15:
16: delete myComponent2;
17: delete myComponent1;
18: delete myFactory;
19:
20: return EXIT_SUCCESS;
21: }
22:
Decorator 模式幫助我們將問題分爲兩部分:
1):如何實現提供新功能的對象.
2):如何爲每種特殊情況組織對象.
這樣能夠將 Decorator 對象的實現與決定如何使用 Decorator 的對象分離開來從而提高了內聚性, 因爲每個 Decoroator 對象只用關心自己添加的功能---無需關心自己如何被添加到對象鏈中.
Decorator 模式要求對象鏈的實例化與使用它的 Client 對象完全分離開.最典型的實現是通過使用工廠對象,根據某些配置信息實例化對象鏈。我們上面的簡單示例就使用了工廠方法來創建簡單的對象鏈。***
Java 中的 I/O 流就廣泛使用了 Decorator 模式。如 ByteArrayInputStream，FileInputStream，FilterInputStream，InputStream，ObjectInputStream，SequenceInputStream 和 StringBufferInputStream 這些類都直接派生自 java.io.InputStream 這些類都扮演裝飾對象的角色。所有的裝飾都(直接或間接地)派生自 FilterInputStream 類。
