1. 定义
我们知道古代的皇帝想要管理国家,是不可能直接管理到具体每一个老百姓的,因此设置了很多机构,比如说三省六部,这些机构下面又有很多小的组织.他们共同管理着这个国家.再比如说,一个大公司,下面有很多小的部门,每一个部门下面又有很多个部门.说到底这就是组合模式
组合模式(CompositePattern)也称为整体-部分(Part-Whole)模式,它的宗旨是通过将单个对象(叶子节点)和组合对象(树枝节点)用相同的接口进行表示,使得客户对单个对象和组合对象的使用具有一致性,属于结构型模式
原文∶Compose objects into tree structures to represent part-whole hierarchies.Composite lets clients treat individual objects and compositions of objects uniformly
解释∶将对象组合成树形结构以表示"部分-整体"的层次结构，使得用户对单个对象和组合对象的使用具有一致性
组合关系与聚合关系的区别∶
- 组合关系∶在古代皇帝三宫六院,贵妃很多,但是每一个贵妃只属于皇帝(具有相同的生命周期)
- 聚合关系∶一个老师有很多学生,但是每一个学生又属于多个老师(具有不同的生命周期)
组合模式一般用来描述整体与部分的关系,它将对象组织到树形结构中,最顶层的节点称为根节点,根节点下面可以包含树枝节点和叶子节点,树枝节点下面又可以包含树枝节点和叶子节点.如下图所示
由上图可以看出,其实根节点和树枝节点本质上是同一种数据类型,可以作为容器使用;而叶子节
点与树枝节点在语义上不属于同一种类型,但是在组合模式中,会把树枝节点和叶子节点认为是同一种数据类型(用同一接口定义),让它们具备一致行为.这样,在组合模式中,整个树形结构中的对象都是同一种类型,带来的一个好处就是客户无需辨别树枝节点还是叶子节点,而是可以直接进行操作,给客户使用带来极大的便利
组合模式包含3个角色∶
- 抽象根节点(Component)∶定义系统各层次对象的共有方法和属性,可以预先定义一些默认行为和属性
- 树枝节点(Composite)∶定义树枝节点的行为,存储子节点,组合树枝节点和叶子节点形成一个树形结构
- 叶子节点(Leaf)∶叶子节点对象,其下再无分支,是系统层次遍历的最小单位
组合模式在代码具体实现上,有两种不同的方式,分别是透明组合模式和安全组合模式
2. 组合模式的应用场景
当子系统与其内各个对象层次呈现树形结构时,可以使用组合模式让子系统内各个对象层次的行为操作具备一致性.客户端使用该子系统内任意一个层次对象时,无须进行区分,直接使用通用操作即可,为客户端的使用带来了便捷.
注∶如果树形然构系统不使用组合模式进行案构,那么按照正常的思维逻辑,对该系统进行职贡分析,按上文树形结构图所示,该系统具备两种对象层次类型∶树枝节点和叶子节点.那么我们就需要构造两种对应的类型,然后由于树枝节点具备容器功能,因此树枝节点类内部需维护多个集合存储其他对象层次(如∶List,List>,如果当前系统对象层次更复杂时,那么树枝节点内就又要增加对应的层次集合,这对树枝节点的构建带来了巨大的复杂性,臃肿性以及不可扩展性.网时客户端访问该系统层次时,还需进行层次区分,这样才能使用对应的行为,给客户端的使用也带未了巨大的复杂性.而如果使用组合模式构建该系统,由于组合模式抽取了系统各个层次的共性行为,具体层次只需按需实现所需行为即可,这样子系统各个层次就都属于同一种类型,所以树枝节点只需维护一个集合(ListKComponent>)即可存储系统所有层次内容,并且客户端也无需区分该系统各个层次对象,对内系统架构简洁优雅,对外接口精词易用
先对组合模式主要总结为以下应用场景∶
- 希望客户端可以忽略组合对象与单个对象的差异时
- 对象层次具备整体和部分,呈树形结构
在我们生活中的组合模式也非常常见,比如树形菜单,操作系统目录结构,公司组织架构等
3. 透明组合模式的写法
透明组合模式是把所有公共方法都定义在 Component 中,这样做的好处是客户端无需分辨是叶子节点(Leaf)和树枝节点(Composite),它们具备完全一致的接口.其 UML 类图如下所示∶
来看一个例子,还是以咕泡的课程为例.这次我们来设计一个课程的关系结构.比如我们有 Java 入门课程,人工智能课程,Java 设计模式,源码分析,软技能等,而 Java 设计模式,源码分析,软技能又属于 Java 架构师系列课程包,每个课程的定价都不一样.但是,这些课程不论怎么组合,都有一些共性,而且是整体和部分的关系,可以用组合模式来设计.先创建一个顶层的抽象组件 CourseComponent 类
public abstract class CourseComponent {
public void addChild(CourseComponent catalogComponent){
throw new UnsupportedOperationException("不支持添加操作");
}
public void removeChild(CourseComponent catalogComponent){
throw new UnsupportedOperationException("不支持删除操作");
}
public String getName(CourseComponent catalogComponent){
throw new UnsupportedOperationException("不支持获取名称操作");
}
public double getPrice(CourseComponent catalogComponent){
throw new UnsupportedOperationException("不支持获取价格操作");
}
public void print(){
throw new UnsupportedOperationException("不支持打印操作");
}
}
把所有可能用到的方法都定义到这个最顶层的抽象类中,但是不写任何逻辑处理的代码,而是直接抛异常.这里,有些小伙伴会有疑惑,为什么不用抽象方法?因为,用了抽象方法,其子类就必须实现,这样便体现不出各子类的细微差异.因此,子类继承此抽象类后,只需要重写有差异的方法覆盖父类的方法即可.下面我们分别创建课程类 Course 和课程包 CoursePackage 类.先创建 Course 类
public class Course extends CourseComponent {
private String name;
private double price;
public Course(String name, double price) {
this.name = name;
this.price = price;
}
@Override
public String getName(CourseComponent catalogComponent) {
return this.name;
}
@Override
public double getPrice(CourseComponent catalogComponent) {
return this.price;
}
@Override
public void print() {
System.out.println(name + " (￥" + price + "元)");
}
}
再创建 CoursePackage 类
public class CoursePackage extends CourseComponent {
private List<CourseComponent> items = new ArrayList<CourseComponent>();
private String name;
private Integer level;
public CoursePackage(String name, Integer level) {
this.name = name;
this.level = level;
}
@Override
public void addChild(CourseComponent catalogComponent) {
items.add(catalogComponent);
}
@Override
public String getName(CourseComponent catalogComponent) {
return this.name;
}
@Override
public void removeChild(CourseComponent catalogComponent) {
items.remove(catalogComponent);
}
@Override
public void print() {
System.out.println(this.name);
for (CourseComponent catalogComponent : items) {
//控制显示格式
if (this.level != null) {
for (int i = 0; i < this.level; i++) {
//打印空格控制格式
System.out.print(" ");
}
for (int i = 0; i < this.level; i++) {
//每一行开始打印一个+号
if (i == 0) {
System.out.print("+");
}
System.out.print("-");
}
}
//打印标题
catalogComponent.print();
}
}
}
测试代码
public class Test {
public static void main(String[] args) {
System.out.println("============透明组合模式===========");
CourseComponent javaBase = new Course("Java 入门课程",8280);
CourseComponent ai = new Course("人工智能",5000);
CourseComponent packageCourse = new CoursePackage("Java 架构师课程",2);
CourseComponent design = new Course("Java 设计模式",1500);
CourseComponent source = new Course("源码分析",2000);
CourseComponent softSkill = new Course("软技能",3000);
packageCourse.addChild(design);
packageCourse.addChild(source);
packageCourse.addChild(softSkill);
CourseComponent catalog = new CoursePackage("课程主目录",1);
catalog.addChild(javaBase);
catalog.addChild(ai);
catalog.addChild(packageCourse);
catalog.print();
}
}
运行结果
============透明组合模式===========
课程主目录
+-Java 入门课程 (￥8280.0 元)
+-人工智能 (￥5000.0元)
+-Java 架构师课程
+--Java 设计模式 (￥1500.0 元)
+--源码分析 (￥2000.0元)
+--软技能 (￥3000.0元)
透明组合模式把所有公共方法都定义在 Component 中,这样做的好处是客户端无需分辨是叶子节点(Leaf)和树枝节点(Composite),它们具备完全一致的接口;缺点是叶子节点(Leaf)会继承得到一些它所不需要(管理子类操作的方法)的方法,这与设计模式接口隔离原则相违背
为了让大家更加透彻理解,下面我们来看安全组合模式的写法
4. 安全组合模式的写法
安全组合模式是只规定系统各个层次的最基础的一致行为,而把组合(树节点)本身的方法(管理子类对象的添加,删除等)放到自身当中.其 UML 类图如下所示
再举一个程序员更熟悉的例子.对于程序员来说,电脑是每天都要接触的.电脑的文件系统其实就是一个典型的树形结构,目录包含文件夹和文件,文件夹里面又可以包含文件夹和文件,下面我们就用代码来实现一个目录系统
文件系统有两个大的层次∶文件夹,文件.其中,文件夹能容纳其他层次,为树枝节点;文件为最小单位,为叶子节点.由于目录系统层次较少,且树枝节点(文件夹)结构相对稳定,而文件其实可以有很多类型,所以这里我们选择使用安全组合模式来实现目录系统,可以避免为叶子类型(文件)引入冗余方法.先创建最顶层的抽象组件 Directory 类
public abstract class Directory {
protected String name;
public Directory(String name) {
this.name = name;
}
public abstract void show();
}
然后分别创建 File 类和 Folder 类.先看 File 类
public class File extends Directory {
public File(String name) {
super(name);
}
@Override
public void show() {
System.out.println(this.name);
}
}
然后创建 Folder 类
public class Folder extends Directory {
private List<Directory> dirs;
private Integer level;
public Folder(String name,Integer level) {
super(name);
this.level = level;
this.dirs = new ArrayList<Directory>();
}
@Override
public void show() {
System.out.println(this.name);
for (Directory dir : this.dirs) {
//控制显示格式
if(this.level != null){
for(int i = 0; i < this.level; i ++){
//打印空格控制格式
System.out.print(" ");
}
for(int i = 0; i < this.level; i ++){
//每一行开始打印一个+号
if(i == 0){ System.out.print("+"); }
System.out.print("-");
}
}
//打印名称
dir.show();
}
}
public boolean add(Directory dir) {
return this.dirs.add(dir);
}
public boolean remove(Directory dir) {
return this.dirs.remove(dir);
}
public Directory get(int index) {
return this.dirs.get(index);
}
public void list(){
for (Directory dir : this.dirs) {
System.out.println(dir.name);
}
}
}
注意 Folder 类不仅覆盖了顶层的 show()方法,而且还增加了 list()方法,看测试代码
public class Test {
public static void main(String[] args) {
System.out.println("============安全组合模式===========");
File qq = new File("QQ.exe");
File wx = new File("微信.exe");
Folder office = new Folder("办公软件",2);
File word = new File("Word.exe");
File ppt = new File("PowerPoint.exe");
File excel = new File("Excel.exe");
office.add(word);
office.add(ppt);
office.add(excel);
Folder wps = new Folder("金山软件",3);
wps.add(new File("WPS.exe"));
office.add(wps);
Folder root = new Folder("根目录",1);
root.add(qq);
root.add(wx);
root.add(office);
System.out.println("----------show()方法效果-----------");
root.show();
System.out.println("----------list()方法效果-----------");
root.list();
}
}
运行结果
============安全组合模式===========
----------show()方法效果-----------
根目录
+-QQ.exe
+-微信.exe
+-办公软件
+--Word.exe
+--PowerPoint.exe
+--Excel.exe
+--金山软件
+---WPS.exe
----------list()方法效果-----------
QQ.exe
微信.exe
办公软件
安全组合模式的好处是接口定义职责清晰,符合设计模式单一职责原则和接口隔离原则;缺点是客户需要区分树枝节点(Composite)和叶子节点(Leaf),这样才能正确处理各个层次的操作,客户端无法依赖抽象(Component),违背了设计模式依赖倒置原则
5. 组合模式在源码中的应用
组合模式在源码中应用也是非常广泛的.首先我们来看一个非常熟悉的 HashMap,他里面有一个 putAll 方法
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
...
public void putAll(Map<? extends K, ? extends V> m) {
putMapEntries(m, true);
}
...
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
if (table == null) { // pre-size
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
}
else if (s > threshold)
resize();
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
...
}
我们看到 putAll()方法传入的是 Map 对象,Map 就是一个抽象构件(同时这个构件中只支持键值对的存储格式),而 HashMap 是一个中间构件,HashMap 中的 Node 节点就是叶子节点.说到中间构件就会有规定的存储方式.HashMap 中的存储方式是一个静态内部类的数组 Node<K,V>[]tab,其源码如下
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
...
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
同理,我们常用的 ArrayList 对象也有 addAll() 方法,其参数也是 ArrayList 的父类 Collection,来看源代码
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
...
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
...
}
组合对象和被组合对象都应该有统一的接口实现或者统一的抽象父类.在这里我再举一个开源框架中非常经典的案例,MyBatis 解析各种 Mapping 文件中的 SQL,设计了一个非常关键的类叫做 SqlNode,xml 中的每一个 Node 都会解析为一个 SqlNode 对象,最后把所有的 SqlNode 拼装到-起就成了一条完整的 SQL 语句,它的顶层设计非常简单.来看源代码
public interface sqlNode{
boolean apply(Dynamiccontext context);
}
Apply()方法会根据传入的参数 context,参数解析该 SqlNode 所记录的 SQL 片段,并调用 DynamicContext.appendSq()方法将解析后的 SQL 片段追加到 Dynamiccontext.sqlBuilder 中保存.当 SQL 节点下的所有 SqNode 完成解析后,可以通过 DynamicContext.getSql() 获取一条完成的 SQL 语句.对具体源码实现感兴趣的小伙伴可以去研究一下,我们这里给大家展示一下类图
6. 组合模式的优缺点
很多小伙伴肯定还有个疑问,既然组合模式会被分为两种实现,那么肯定是不同的场合某一种会更加适合,也即具体情况具体分析.透明组合模式将公共接口封装到抽象根节点(Component)中,那么系统所有节点就具备一致行为,所以如果当系统绝大多数层次具备相同的公共行为时,采用透明组合模式也许会更好(代价∶为剩下少数层次节点引入不需要的方法);而如果当系统各个层次差异性行为较多或者树节点层次相对稳定(健壮)时,采用安全组合模式
注∶设计模式的出现并不是说我们要写的代码一定要遵循设计模式所要求的方方面面,这是不现实同时也是不可能的.设计模式的出现,其实只是强调好的代码所具备的一些特征(六大设计原则),这些特征对于项目开发是具备积极效应的,但不是说我们每实现一个类就一定要全部满足设计模式的要求,如果真的存在完全满足设计模式的要求,反而可能存在过度设计的嫌疑.同时,23种设计模式,其实都是严格依循设计模式六大原则进行设计,只是不同的模式在不同的场景中会更加适用.设计模式的理解应该重于意而不是形,真正编码时,经常使用的是某种设计模式的变形体,真正切合项目的模式才是正确的模式
下面我们再来总结一下组合模式的优缺点
优点∶
- 清楚地定义分层次的复杂对象,表示对象的全部或部分层次
- 让客户端忽略了层次的差异,方便对整个层次结构进行控制
- 简化客户端代码
- 符合开闭原则
缺点∶
- 限制类型时会较为复杂
- 使设计变得更加抽象