组合模式（Composite Pattern）。

定义

组合模式也叫合成模式，有时又叫部分-整体模式（Part-Whole），主要是用来描述部分与整体的关系，其定义如下：
将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。

我们先来说说组合模式的几个角色。

• Component抽象构件角色

定义参加组合对象的共有方法和属性，可以定义一些默认的行为或属性。

• Leaf叶子构件

叶子对象，其下再也没有其他的分支，也就是遍历的最小单位。

• Composite树枝构件

树枝对象，他的作用是组合树枝节点和叶子节点形成一个树形结构。

通用源码

我们来看组合模式的通用源代码，首先看抽象构件，他是组合模式的精髓，如下所示。

public abstract class Component {
	/**
	 * 个体和整体都具有的共享
	 */
	public void doSomething() {
		// 编写业务逻辑
	}
}

组合模式的重点就在树枝构件，其通用代码如下图所示。

public class Composite extends Component {
	// 构件容器
	private List<Component> componentArrayList = new ArrayList<Component>();

	/**
	 * 增加一个叶子构件或树枝构件
	 * 
	 * @param component
	 */
	public void add(Component component) {
		this.componentArrayList.add(component);
	}

	/**
	 * 删除一个叶子构件或树枝构件
	 * 
	 * @param component
	 */
	public void remove(Component component) {
		this.componentArrayList.remove(component);
	}

	/**
	 * 获得分支下的所有叶子构件和树枝构件
	 * 
	 * @return
	 */
	public List<Component> getChildren() {
		return this.componentArrayList;
	}
}

树叶节点是没有子下级对象的对象，定义参加组合的原始对象行为，其通用源代码如下所示。

public class Leaf extends Component {

	@Override
	public void doSomething() {
		// 可以覆写父类的方法
	}
}

场景类负责树状结构的建立，并可以通过递归方式遍历整个树，如下所示。

public class Client {
	public static void main(String[] args) {
		// 创建一个根节点
		Composite root = new Composite();
		root.doSomething();
		// 创建一个树枝构件
		Composite branch = new Composite();
		// 创建一个叶子节点
		Leaf leaf = new Leaf();
		// 建立整体
		root.add(branch);
		branch.add(leaf);
		// 遍历树
		display(root);
	}

	/**
	 * 通过递归遍历树
	 * 
	 * @param root
	 */
	private static void display(Composite root) {
		for (Component c : root.getChildren()) {
			if (c instanceof Leaf) { // 叶子节点
				c.doSomething();
			} else { // 树枝节点
				display((Composite) c);
			}
		}
	}
}

各位可能已经看出一些问题了，组合模式是对依赖倒置原则的破坏，但是他还有其他类型的变形，面向对象就是这么多的形态和变化，请继续阅读下去，就会找到解决方案。

优点

• 高层模块调用简单

一棵树形机构中的所有节点都是Component，局部和整体对调用者来说没有任何区别，也就是说，高层模块不必关系自己处理的是单个对象还是整个组合结构，简化了高层模块的代码。

• 节点自由增加

使用了组合模式后，我们可以看看，如果想增加一个树枝节点、树叶节点是不是都很容易，只要找到他的父节点就成，非常容易扩展，符合开闭原则，对以后的维护非常有利。

缺点

组合模式有一个非常明显的缺点，看到我们在场景类中国你的定义，提到树叶和树枝使用时的定义了吗？直接使用了实现类！这在面向接口编程上是很不恰当的，与依赖倒置原则冲突，在使用的时候要考虑清除，他限制了你接口的影响范围。

使用场景

• 维护和展示部分-整体关系的场景，如树形菜单、文件和文件夹管理。
• 从一个整体中能够独立出部分模块或功能的场景。

注意事项

只要是树形结构，就要考虑使用组合模式，这个一定要记住，只要是要体现局部和整体的关系的时候，而且这种关系还可能比较深，考虑一下组合模式吧。

扩展

真实的组合模式

什么是真实的组合模式？就是你在实际项目中使用的组合模式，而不是仅仅依照书本上学习到的模式，他是“实践出真知”。

透明的组合模式

组合模式有两种不同的实现：透明模式和安全模式，上面讲的就是安全模式。透明模式是把用来组合使用的方法放到抽象类中，比如add()、remove()以及getChildren等方法（顺便说一下，getChildren一般返回的结果为Iterable的实现类），不管叶子对象还是树枝对象都有相同的结构，通过判断是getChildren的返回值确认是叶子节点还是树枝节点，如果处理不当，这个会在运行期出现问题，不是很建议的方式；安全模式就不同了，他是把树枝节点和树叶节点彻底分开，树枝节点单独拥有用来组合的方式，这种方式比较安全。

由于透明模式的使用者还是比较多，我们也把他的通用源代码共享出来，首先看抽象构件，如下所示。

public abstract class Component {
	/**
	 * 个体和整体都具有的共享
	 */
	public void doSomething() {
		// 编写业务逻辑
	}

	/**
	 * 增加一个叶子构件或树枝构件
	 * 
	 * @param component
	 */
	public abstract void add(Component component);

	/**
	 * 删除一个叶子构件或树枝构件
	 * 
	 * @param component
	 */
	public abstract void remove(Component component);

	/**
	 * 获得分支下的所有叶子构件和树枝构件
	 * 
	 * @return
	 */
	public abstract List<Component> getChildren();
}

抽象构件定义了树枝节点和树叶节点都必须具有的方法和属性，这样树枝节点的实现就不需要任何变化，如上面的Composite所示。

树叶节点继承了Component抽象类，不想让他改变有点难，他必须实现三个抽象方法，怎么办？好办，给个空方法，如下所示。

public class Leaf extends Component {

	@Deprecated
	@Override
	public void add(Component component) {
		throw new UnsupportedOperationException();
	}

	@Deprecated
	@Override
	public void remove(Component component) {
		throw new UnsupportedOperationException();
	}

	@Deprecated
	@Override
	public List<Component> getChildren() {
		throw new UnsupportedOperationException();
	}

}

为什么要加个Deprecated注解呢？就是在编译器期告诉调用者，你可以调用我这个方法，但是可能出现错误哦，我已经告诉你“该方法已经失效”了，你还使用那在运行器也会抛出UnsupportedOperationException异常。

在透明模式下，遍历整个树形结构是比较容易的，不用进行强制类型转换，如下所示。

public class Client {
	// 通过递归遍历树
	public static void display(Component root) {
		for (Component c : root.getChildren()) {
			if (c instanceof Leaf) { // 叶子节点
				c.doSomething();
			} else { // 树枝节点
				display(c);
			}
		}
	}
}

仅仅在遍历时不再进行强制的类型转化了，其他的组装则没有任何变化。透明模式的好处就是他基本遵循了依赖倒置原则，方便系统进行扩展。

遍历

我们在上面也还提到了一个问题，就是树的遍历问题，从上到下遍历没有问题，但是我要从下往上遍历呢？甭管是树叶节点还是树叶节点，在每个节点都增加了一个属性，父节点对象，这样在树枝节点增加子节点或叶子节点是设置父节点，然后你看整棵树除了根节点外每个节点都有一个父节点，剩下的事情还不好处理吗？每个节点上都有父节点了，你要往上找，那就找呗！

最佳实践

组合模式在项目中到处都有，比如现在的页面结构一般都是上下结构，上面方系统的Logo，下面分为两部分：左边是导航菜单，右边是展示区，左边的导航菜单一般都是树形的结构，比较清晰，有非常多的JavaScript源码实现了类似的树形菜单，大家可以到网上搜索一下。

还有，大家常用的XML结构也是一个树形结构，根节点、元素节点、值元素这些都与我们的组合模式相匹配。

还有一个非常重要的例子：我们自己本身也是一个树状结构的一个树枝或树叶。根据我能够找到我的父母，根据父亲又能找到爷爷奶奶，根据母亲能够找到外公外婆等，很典型的树形结构。