Gof定义

将对象组合成树形结构以表示“部分–整体”的层次结构。Composite使得用户对单个对象和组合对象使用具有一致性。

在面向对象系统中,我们经常会遇到一类具有”容器“特征的对象—即他们在充当对象的同时,又是其他对象的容器。比如在一些管理系统中就会出现总公司下面有很多的分公司,分公司下面有很多的部门,每个部门下又有很多的员工,像分公司和部门就是既充当了“对象”的角色也充当了“容器”的角色;还有我们可能玩过的“俄罗斯套娃”也是这种结构,一个大娃娃里面装个小娃娃,小的里面又有个小的直到最小的一个,中间的娃娃就是既充当了“对象”也充当了“容器”。先看下面这个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
interface IBox
{
void Process();
}
/// <summary>
/// 相当于树的叶子节点,没有子对象了
/// </summary>
public class SingleBox : IBox
{
public void Process()
{
}
}
/// <summary>
/// 容器
/// </summary>
public class ContainerBox : IBox
{
List<IBox> list = new List<IBox>();
public void Process() { }
public List<IBox> GetBoxes()
{
return list;
}
}
/// <summary>
/// 客户代码
/// </summary>
public class App
{
static void Mina()
{
///此处从工厂方法中得到盒子的对象,但我们不知道是SingleBox还是ContainerBox
///所以要做判断
IBox box = Factory.Create();
if (box is ContainerBox)
{
box.Process();
List<IBox> list = ((ContainerBox)box).GetBoxes();
}
else if(box is SingleBox)
{
box.Process();
}
}
}

动机

上面代码的问题的根据在于:客户代码过多地依赖对象容器复杂的内部实现结构,对象容器内部实现结构(而非抽象接口)的变化将引起客户代码的频繁变化,带来了代码的维护性、扩展性等弊端。

如何将“客户代码与复杂的对象容器结构”解耦?让对象容器自己来实现自身的复杂结构,从而使得客户代码就像处理简单对象一样来处理复杂的对象容器?

这就要使用Composite模式了,先看下Composite模式的结构图:

2010-12-29_130718

  • Component:定义了Leaf和Composite的一些共有特性。
  • Composite:有容器特征的类型。
  • Leaf:叶节点,即一个单独的个体,下面没有子节点。

依据上面的结构图完成代码实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
public abstract class Component
{
protected string _name;
public Component(string name)
{
_name = name;
}
public abstract void Operation();
public abstract void Add(Component component);
public abstract void Remove(Component component);
}
public class Leaf : Component
{
public Leaf(string name) : base(name) { }
public override void Add(Component component)
{
throw new NotSupportedException();
}
public override void Remove(Component component)
{
throw new NotSupportedException();
}
public override void Operation()
{
//...do something
}
}
public class Composite : Component
{
public Composite(string name):base(name){}
List<Component> list = new List<Component>();
/// <summary>
/// 添加
/// </summary>
/// <param name="conponent"></param>
public override void Add(Component component)
{
if (list != null)
{
list = new List<Component>();
}
list.Add(component);
}
/// <summary>
/// 删除
/// </summary>
/// <param name="component"></param>
public override void Remove(Component component)
{
if (list == null)
{
throw new NullReferenceException();
}
list.Remove(component);
}
public override void Operation()
{
if (list != null)
{
foreach (Component c in list)
{
c.Operation();
}
}
}
}

Leaf类为叶子节点类,它的实例是没有子节点的,但是在抽象类中的方法Add和Remove方法必须要实现,按理说这样的实现是没有意义的,所以在此处抛出了NotSupportedException 异常,在客户端调用捕获到再做相应的处理,这种模式称之为“透明足组合模式”,这样做的好处是叶子(Leaf)和容器(Composite)对于外界没有分别,它们具有一致的接口行为。还有一种情况叫“安全组合模式”,在抽象类(Component)中不定义Add Remove方法,而是在容器的实现类中去定义,这样就各司其职了,看下面结构图:

2010-12-29_130818

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
public abstract class Component
{
protected string _name;
public Component(string name)
{
_name = name;
}
public abstract void Operation();
}
public class Leaf : Component
{
public Leaf(string name) : base(name) { }
public override void Operation()
{
//...do something
}
}
public class Composite : Component
{
public Composite(string name) : base(name) { }
List<Component> list = new List<Component>();
/// <summary>
/// 添加
/// </summary>
/// <param name="conponent"></param>
public void Add(Component component)
{
if (list != null)
{
list = new List<Component>();
}
list.Add(component);
}
/// <summary>
/// 删除
/// </summary>
/// <param name="component"></param>
public void Remove(Component component)
{
if (list == null)
{
throw new NullReferenceException();
}
list.Remove(component);
}
public override void Operation()
{
if (list != null)
{
foreach (Component c in list)
{
c.Operation();
}
}
}
}

使用“安全组合模式”Leaf和Composite就不具有相同的接口,所以在客户端调用的时候还是要去判断是什么类型,比较麻烦。所以说选择哪种还要看具体的需求。

Composite模式的几个要点

  • Composite模式采用树形结构来实现普遍存在的对象容器,从而将“一对多”的关系转化为“一对一”的关系,使得客户代码可以一致地处理对象和对象容器,无需关心处理的是单个的对象还是组合的对象容器。
  • 将“客户代码与复杂的对象容器结构”解耦是Composite模式的核心思>想,解耦之后,客户代码将与纯粹的抽象接口——而非对象容器的复内部实现结构——发生依赖关系,从而更能“应对变化”。
  • Composite模式中,是将“Add和Remove等和对象容器相关的方法”定义在“表示抽象对象的Component类”中,还是将其定义在“表示对象容器的Composite类”中,是一个关乎“透明性”和“安全性”的两难问题,需要仔细权衡。这里有可能违背面向对象的“单一职责原则”,但是对于这种特殊结构,这又是必须付出的代价。ASP.NET控件的实现在这方面为我们提供了一个很好的示范。
  • Composite模式在具体实现中,可以让父对象中的子对象反向追溯; 如果父对象有频繁的遍历需求,可使用缓存技巧来改善效率。

返回开篇(索引)