小侃设计模式（九）-组合模式

1.概述

组合模式（Composite Pattern）又叫部分整体模式，它创建了对象组的树形结构，将对象组合成树状结构以表示“整体-部分”的层析关系，使用户对单个对象和组合对象具有一致的访问性，是结构型设计模式的一种。本文将分析组合模式的原理及使用方式。

2.原理及使用

2.1 原理

组合模式一般用来描述整体与部分的关系，它将对象组织到树形结构中，以树的管理方式来管理对象。顶层的节点被称为根节点，根节点下包含树枝节点和叶子节点，树枝节点下面可以包含树枝节点和叶子节点。这个模式与二叉树的模式类似，树形结构图如下：

根节点和树枝节点本质上是同一种数据类型，都可以作为存储子类的容器；叶子节点与树枝节点有所区别，叶子节点不具备存储子类的功能。但是在组合模式中，树枝节点和叶子节点会被看作同一种书籍类型（为了统一抽象和定义，让树枝节点和叶子节点具备统一行为）。
因此，在组合模式中，整个树形结构中的对象都是同一种类型，具备相同的行为，操作时不需要区分节点，效率较高。
组合模式类图如下：

组合模式主要包含以下三个角色：

抽象构件角色（Component）：为树叶构件和树枝构件声明公共接口，它可以是接口或者抽象类，可以实现一些默认行为；
树枝构件角色（Composite）：是组合中的分支节点对象，它有子节点，用于继承和实现抽象构件，负责管理字节点；
树叶构件角色（Leaf）：是组合中的叶节点对象，它没有子节点，用于继承或实现抽象构件。

组合模式可以分为透明式组合模式和安全式组合模式，它们之间的区别在于：透明式的组合模式在抽象构件角色（Component）中声明访问和管理子类的接口；安全式的组合模式在抽象构件角色中不声明管理子类接口，管理工作由树枝构件自己完成。上述类图主要是透明式组合模式。

2.2 案例

有一个学校，展现出学校下的各个组织。学校下面有学院，学院下面有不同的专业。不同的组织可以对其下属组织进行新增、裁撤等。

分析：首先需要定义一个抽象构件角色（OrganizationComponent）来实现一些组织的基础操作，比如：add()、delete()、getChildren()等；学校下面的学校（University）、学院（College）可以作为一个树枝构件角色，学校的子节点是学院，学院的子节点是专业(Profession)；专业（Profession）在这里属于叶子节点（实际中还可能有班级这类的子组织，这里不做考虑了）。

由上述分析可得出案例的类图如下：

编码如下：

//抽象组件
public abstract class UniversityComponent {

    public String name;

    public String description;

    public UniversityComponent(String name, String description) {
        this.name = name;
        this.description = description;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    protected void add(UniversityComponent universityComponent) {
        throw new UnsupportedOperationException();
    }

    protected void remove(UniversityComponent universityComponent) {
        throw new UnsupportedOperationException();
    }

    protected List<UniversityComponent> getChildern() {
        throw new UnsupportedOperationException();
    }

    protected abstract void operation();
}

//学校树枝构件
@Slf4j
public class University extends UniversityComponent {

    private List<UniversityComponent> lists = new ArrayList<>();

    public University(String name, String description) {
        super(name, description);
    }

    @Override
    protected void add(UniversityComponent universityComponent) {
        lists.add(universityComponent);
        log.info("学校新增子组织：" + JSON.toJSONString(universityComponent));
    }

    @Override
    protected void remove(UniversityComponent universityComponent) {
        lists.remove(universityComponent);
        log.info("学校裁剪组织：" + JSON.toJSONString(universityComponent));
    }

    @Override
    protected List<UniversityComponent> getChildern() {
        log.info("返回学校组织：" + JSON.toJSONString(lists));
        return lists;
    }

    @Override
    protected void operation() {
        System.out.println("----------------------" + name + "学校组织----------------------");
        lists.forEach(list -> {
            System.out.println("名称：" + list.getName() + ",备注：" + list.getDescription());
        });
    }
}

//学院树枝构件
@Slf4j
public class College extends UniversityComponent {

    private List<UniversityComponent> lists = new ArrayList<>();

    public College(String name, String university) {
        super(name, university);
    }

    @Override
    protected void add(UniversityComponent universityComponent) {
        lists.add(universityComponent);
        System.out.println("学院添加组织：" + JSON.toJSONString(universityComponent) + ",成功");
    }

    @Override
    protected void remove(UniversityComponent universityComponent) {
        lists.remove(universityComponent);
        System.out.println("学院删除组织：" + JSON.toJSONString(universityComponent) + ",成功");
    }

    @Override
    protected List<UniversityComponent> getChildern() {
        log.info("学院包含组织：" + JSON.toJSONString(lists));
        return lists;
    }

    @Override
    protected void operation() {
        System.out.println("-----------------" + name + "学院组织----------------");
        lists.forEach(list -> {
            System.out.println("名称：" + list.getName() + ",备注：" + list.getDescription());
        });
    }
}

//树枝节点（专业）
public class Profession extends UniversityComponent {

    public Profession(String name, String description) {
        super(name, description);
    }

    @Override
    protected void operation() {
        System.out.println("名称：" + name + ",备注：" + description);
    }
}

//测试类
public class Test {
    public static void main(String[] args) {

        University university = new University("清华大学", "中国数一数二的大学");

        College college1 = new College("艺术学院", "女生比较多的学院");
        College college2 = new College("经济管理学院", "五道口");

        Profession profession1 = new Profession("舞蹈专业", "专注于舞蹈");
        Profession profession2 = new Profession("播音专业", "专注于播音");
        Profession profession3 = new Profession("表演专业", "专注于表演");
        Profession profession4 = new Profession("金融投资", "专注于金融投资");

        college1.add(profession1);
        college1.add(profession2);
        college1.add(profession3);

        college2.add(profession4);

        university.add(college1);
        university.add(college2);

        university.operation();

        college1.operation();
        college2.operation();

    }
}

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

运行结果如下：

3.小结

1.组合模式具有较强扩展性，当需要更改组织关系时，只需调整内部关系，由于是通过接口进行关联，因此只需更改传入组织即可，不需要大规模修改代码；
2.简化了客户端的操作，客户端所给的对象一致，不需要考虑整体部分或者叶子节点的问题；
3.方便创建出复杂的层次结构。客户端不用理会组合里面的组成细节，容易添加节点或者叶子从而创建出复杂的树形结构；
4.需要遍历组织机构，或者处理的对象具有树形结构时，非常适合使用组合模式；
5.要求较高的抽象性，如果节点和叶子有很多差异性的话，比如很多方法和属性都不一样，不适合使用组合模式。

4.参考文献

1.《设计模式-可复用面向对象软件的基础》-Erich Gamma、Richard Helm、Ralph Johnson、John Vlissides
2.《可复用物联网Web3D框架的设计与实现》-程亮（知网）
3.https://www.bilibili.com/video/BV1G4411c7N4-尚硅谷设计模式
4.https://zhuanlan.zhihu.com/p/444784138