一、定义
组合模式（Composite Pattern）也称为 整体-部分（Part-Whole）模式，它的宗旨是通过将单个对象（叶子节点）和组合对象（树枝节点）用相同的接口进行表示，使得客户对单个对象和组合对象的使用具有一致性。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。
组合模式 一般用来描述整体与部分的关系，它将对象组织到树形结构中，最顶层的节点称为根节点，根节点下面可以包含 树枝节点和叶子节点，树枝节点下面又可以包含树枝节点和叶子节点。如下图所示：
由上图可以看出，其实根节点和树枝节点本质上是同一种数据类型（蓝色圆圈，可以作为容器使用；而叶子节点与树枝节点在语义上不属于同一种类型，但是在组合模式中，会把树枝节点和叶子节点认为是同一种数据类型（用同一接口定义），让它们具备一致行为。这样，在组合模式 中，整个树形结构中的对象都是同一种类型，带来的一个好处就是客户无需辨别树枝节点还是叶子节点，而是可以直接进行操作，给客户使用带来极大的便利。组合模式 核心：借助同一接口，使叶子节点和树枝节点的操作具备一致性。
组成元素：
- 抽象构件角色(Composite)：是组合中对象声明接口，实现所有类共有接口的默认行为。
- 树叶构件角色(Leaf)：上述提到的单个对象，叶节点没有子节点。
- 树枝构件角色(Composite)：定义有子部件的组合部件行为，存储子部件，在Component接口中实现与子部件有关的操作。
- 客户端(Client)：使用 Component 部件的对象。
二、应用场景
当子系统与其内各个对象层次呈现树形结构时，可以使用组合模式让该子系统内各个对象层次的行为操作具备一致性。客户端使用该子系统内任意一个层次对象时，无须进行区分，直接使用通用操作即可，为客户端的使用带来了便捷。如果树形结构系统不使用组合模式 进行架构，那么按照正常的思维逻辑，对该系统进行职责分析，按上文树形结构图所示，该系统具备两种对象层次类型：树枝节点和叶子节点。那么我们就需要构造两种对应的类型，然后由于树枝节点具备容器功能，因此树枝节点类内部需维护多个集合存储其他对象层次（eg:
List<Composite>,List<Leaf>），如果当前系统对象层次更复杂时，那么树枝节点内就又要增加对应的层次集合，这对树枝节点的构建带来了巨大的复杂性，臃肿性以及不可扩展性。同时客户端访问该系统层次时，还需进行层次区分，这样才能使用对应的行为，给客户端的使用也带来了巨大的复杂性。而如果使用组合模式构建该系统，由于组合模式抽取了系统各个层次的共性行为，具体层次只需按需实现所需行为即可，这样子系统各个层次就都属于同一种类型，所以树枝节点只需维护一个集合（List<Component>）即可存储系统所有层次内容，并且客户端也无需区分该系统各个层次对象，对内系统架构简洁优雅，对外接口精简易用。组合模式在代码具体实现上，有两种不同的方式：
- 透明模式：把组合（树节点）使用的方法放到统一行为（Component）中，让不同层次（树节点，叶子节点）的结构都具备一致行为；其 UML 类图如下所示：
透明组合模式 把所有公共方法都定义在 Component 中，这样做的好处是客户端无需分辨是叶子节点（Leaf）和树枝节点（Composite），它们具备完全一致的接口；缺点是叶子节点（Leaf）会继承得到一些它所不需要（管理子类操作的方法）的方法，这与设计模式接口隔离原则相违背。
透明组合模式 通用代码如下所示：
public class Client { public static void main(String[] args) { // 来一个根节点 Component root = new Composite("root"); // 来一个树枝节点 Component branchA = new Composite("---branchA"); Component branchB = new Composite("------branchB"); // 来一个叶子节点 Component leafA = new Leaf("------leafA"); Component leafB = new Leaf("---------leafB"); Component leafC = new Leaf("---leafC"); root.addChild(branchA); root.addChild(leafC); branchA.addChild(leafA); branchA.addChild(branchB); branchB.addChild(leafB); String result = root.operation(); System.out.println(result);} }
// 抽象根节点 public abstract class Component { protected String name; public Component(String name) { this.name = name; } public abstract String operation(); public boolean addChild(Component component) { throw new UnsupportedOperationException("addChild not supported!"); } public boolean removeChild(Component component) { throw new UnsupportedOperationException("removeChild not supported!"); } public Component getChild(int index) { throw new UnsupportedOperationException("getChild not supported!"); } }
// 树节点 public class Composite extends Component{ private List<Component> mComponents; public Composite(String name) { super(name); this.mComponents = new ArrayList<>(); } @Override public String operation() { StringBuilder builder = new StringBuilder(this.name); for (Component component : this.mComponents) { builder.append(" "); builder.append(component.operation()); } return builder.toString(); } @Override public boolean addChild(Component component) { return this.mComponents.add(component); } @Override public boolean removeChild(Component component) { return this.mComponents.remove(component); } @Override public Component getChild(int index) { return this.mComponents.get(index); } }
//叶子节点 public class Leaf extends Component { public Leaf(String name) { super(name); } @Override public String operation() { return this.name; } }
透明组合模式 中，由于 Component 包含叶子节点所不需要的方法，违背了最少知道原则，因此，我们直接将这些方法默认抛出UnsupportedOperationException异常。
- 安全模式：统一行为（Component）只规定系统各个层次的最基础的一致行为，而把组合（树节点）本身的方法（管理子类对象的添加，删除等）放到自身当中；其 UML 类图如下所示：
安全组合模式 把系统各层次公有的行为定义在 Component 中，把组合（树节点）特有的行为（管理子类增加，删除等）放到自身（Composite）中。这样做的好处是接口定义职责清晰，符合设计模式单一职责原则 和 接口隔离原则；缺点是客户需要区分树枝节点（Composite）和叶子节点（Leaf），这样才能正确处理各个层次的操作，客户端无法依赖抽象（Component），违背了设计模式依赖倒置原则。
安全组合模式 的通用代码相对 透明组合模式 而言，需要进行如下修改：
- 修改 Component 代码：只保留各层次公有行为：
// 抽象根节点 public abstract class Component { protected String name; public Component(String name) { this.name = name; } public abstract String operation(); }
- 修改客户端代码：将树枝节点类型更改为 Composite 类型，以便获取管理子类操作的方法：
public class Client { public static void main(String[] args) { // 来一个根节点 Composite root = new Composite("root"); // 来一个树枝节点 Composite branchA = new Composite("---branchA"); Composite branchB = new Composite("------branchB"); // 来一个叶子节点 Component leafA = new Leaf("------leafA"); Component leafB = new Leaf("---------leafB"); Component leafC = new Leaf("---leafC"); root.addChild(branchA); root.addChild(leafC); branchA.addChild(leafA); branchA.addChild(branchB); branchB.addChild(leafB); String result = root.operation(); System.out.println(result);} }
运行结果显示：root 包含 branchA 和 leafC；branchA 包含 leafA 和 branchB；branchB 包含 leafB。
三、组合模式在源码中应用
组合模式在源码中HashMap中也有应用，他里面有一个putAll()方法
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; }
四、总结
透明组合模式将公共接口封装到抽象根节点(Component) 中， 那么系统所有节点就具备一致行为，所以如果当系统绝大多数层次具备相同的公共行为时，采用透明组合模式也许会更好(代价：为剩下少数层次节点引入不需要的方法)；而如果当系统各个层次差异性行为较多或者树节点层次相对稳定(健壮)时，采用安全组合模式。
优点：
- 清楚地定义分层次的复杂对象，表示对象的全部或部分层次
- 让客户端忽略了层次的差异，方便对整个层次结构进行控制
- 简化客户端代码
缺点：
- 限制类型时会较为复杂
- 使设计变得更加抽象
注：设计模式的出现并不是说我们要写的代码一定要埋设计模式所要求的方方面画，这是不现实同时也是不可能的。设计模式的出现，其实只是强调好的代码所具备的一些特征(六大设计原则)，这些特征对于项目开发是具备积极效应的，但不是说我们每实现一个类就一定要全部满足设计模式的要求，如果真的存在完全满足设计模式的要求，反而可能存在过度设计的嫌疑。同时，23种设计模式，其实都是严格依循设计模式六大原则进行设计，只是不同的模式在不同的场景中会更加造用。设计模式的理解应该重于意而不是形，真正编码时，经常使用的是某种设计模式的变形体，真正切合项目的模式才是正确的模式.