【白话设计模式十七】组合模式(Composite)
#0 系列目录#java
- 白话设计模式
- 工厂模式
- 单例模式
- 【白话设计模式一】简单工厂模式(Simple Factory)
- 【白话设计模式二】外观模式(Facade)
- 【白话设计模式三】适配器模式(Adapter)
- 【白话设计模式四】单例模式(Singleton)
- 【白话设计模式五】工厂方法模式(Factory Method)
- 【白话设计模式六】抽象工厂模式(Abstract Factory)
- 【白话设计模式七】策略模式(Strategy)
- 【白话设计模式八】命令模式(Command)
- 【白话设计模式九】桥接模式(Bridge)
- 【白话设计模式十】装饰模式(Decorator)
- 【白话设计模式十一】生成器模式(Builder)
- 【白话设计模式十二】原型模式(Prototype)
- 【白话设计模式十三】中介者模式(Mediator)
- 【白话设计模式十四】代理模式(Proxy)
- 【白话设计模式十五】观察者模式(Observer)
- 【白话设计模式十六】迭代器模式(Iterator)
- 【白话设计模式十七】组合模式(Composite)
- 【白话设计模式十八】模板方法模式(Template Method)
- 【白话设计模式十九】状态模式(State)
- 【白话设计模式二十】备忘录模式(Memento)
- 【白话设计模式二十一】享元模式(Flyweight)
- 【白话设计模式二十二】解释器模式(Interpreter)
- 【白话设计模式二十三】职责链模式(Chain of Responsibility)
- 【白话设计模式二十四】访问者模式(Visitor)
- 【白话设计模式二十五】临别总结：设计模式与7大原则
#1 场景问题# ##1.1 商品类别树## 考虑这样一个实际的应用：管理商品类别树。算法
在实现跟商品有关的应用系统的时候，一个很常见的功能就是商品类别树的管理，好比有以下所示的商品类别树：设计模式
- 服装
- 男装
- 衬衣
- 夹克
- 女装
- 裙子
- 套装
仔细观察上面的商品类别树，有如下几个明显的特色：缓存
有一个根节点，好比服装，它没有父节点，它能够包含其它的节点；安全
树枝节点，有一类节点能够包含其它的节点，称之为树枝节点，好比男装、女装；测试
叶子节点，有一类节点没有子节点，称之为叶子节点，好比衬衣、夹克、裙子、套装；ui
如今须要管理商品类别树，假如就要求能实现输出如上商品类别树的结构的功能，应该如何实现呢？this
##1.2 不用模式的解决方案## 要管理商品类别树，就是要管理树的各个节点，如今树上的节点有三类，根节点、树枝节点和叶子节点，再进一步分析发现，根节点和树枝节点是相似的，都是能够包含其它节点的节点，把它们称为容器节点。.net
这样一来，商品类别树的节点就被分红了两种，一种是容器节点，另外一种是叶子节点。容器节点能够包含其它的容器节点或者叶子节点。把它们分别实现成为对象，也就是容器对象和叶子对象，容器对象能够包含其它的容器对象或者叶子对象，换句话说，容器对象是一种组合对象。设计
而后在组合对象和叶子对象里面去实现要求的功能就能够了，看看代码实现。
- 先看叶子对象的代码实现，示例代码以下：
/**
* 叶子对象
*/
public class Leaf {
/**
* 叶子对象的名字
*/
private String name = "";
/**
* 构造方法，传入叶子对象的名字
* @param name 叶子对象的名字
*/
public Leaf(String name){
this.name = name;
}
/**
* 输出叶子对象的结构，叶子对象没有子对象，也就是输出叶子对象的名字
* @param preStr 前缀，主要是按照层级拼接的空格，实现向后缩进
*/
public void printStruct(String preStr){
System.out.println(preStr+"-"+name);
}
}
- 再来看看组合对象的代码实现，组合对象里面能够包含其它的组合对象或者是叶子对象，因为类型不同，须要分开记录。示例代码以下：
/**
* 组合对象，能够包含其它组合对象或者叶子对象
*/
public class Composite {
/**
* 用来记录包含的其它组合对象
*/
private Collection<Composite> childComposite = new ArrayList<Composite>();
/**
* 用来记录包含的其它叶子对象
*/
private Collection<Leaf> childLeaf = new ArrayList<Leaf>();
/**
* 组合对象的名字
*/
private String name = "";
/**
* 构造方法，传入组合对象的名字
* @param name 组合对象的名字
*/
public Composite(String name){
this.name = name;
}
/**
* 向组合对象加入被它包含的其它组合对象
* @param c 被它包含的其它组合对象
*/
public void addComposite(Composite c){
this.childComposite.add(c);
}
/**
* 向组合对象加入被它包含的叶子对象
* @param leaf 被它包含的叶子对象
*/
public void addLeaf(Leaf leaf){
this.childLeaf.add(leaf);
}
/**
* 输出组合对象自身的结构
* @param preStr 前缀，主要是按照层级拼接的空格，实现向后缩进
*/
public void printStruct(String preStr){
//先把本身输出去
System.out.println(preStr+"+"+this.name);
//而后添加一个空格，表示向后缩进一个空格，输出本身包含的叶子对象
preStr+=" ";
for(Leaf leaf : childLeaf){
leaf.printStruct(preStr);
}
//输出当前对象的子对象了
for(Composite c : childComposite){
//递归输出每一个子对象
c.printStruct(preStr);
}
}
}
- 写个客户端来测试一下，看看是否能实现要求的功能，示例代码以下：
public class Client {
public static void main(String[] args) {
//定义全部的组合对象
Composite root = new Composite("服装");
Composite c1 = new Composite("男装");
Composite c2 = new Composite("女装");
//定义全部的叶子对象
Leaf leaf1 = new Leaf("衬衣");
Leaf leaf2 = new Leaf("夹克");
Leaf leaf3 = new Leaf("裙子");
Leaf leaf4 = new Leaf("套装");
//按照树的结构来组合组合对象和叶子对象
root.addComposite(c1);
root.addComposite(c2);
c1.addLeaf(leaf1);
c1.addLeaf(leaf2);
c2.addLeaf(leaf3);
c2.addLeaf(leaf4);
//调用根对象的输出功能来输出整棵树
root.printStruct("");
}
}
##1.3 有何问题## 上面的实现，虽然能实现要求的功能，可是有一个很明显的问题：那就是必须区分组合对象和叶子对象，并进行有区别的对待，好比在Composite和Client里面，都须要去区别对待这两种对象。
区别对待组合对象和叶子对象，不只让程序变得复杂，还对功能的扩展也带来不便。实际上，大多数状况下用户并不想要去区别它们，而是认为它们是同样的，这样他们操做起来最简单。
换句话说，对于这种具备总体与部分关系，并能组合成树形结构的对象结构，如何才可以以一个统一的方式来进行操做呢？
#2 解决方案# ##2.1 组合模式来解决## 用来解决上述问题的一个合理的解决方案就是组合模式。那么什么是组合模式呢？
- 组合模式定义
- 应用组合模式来解决的思路
仔细分析上面不用模式的例子中，要区分组合对象和叶子对象的根本缘由，就在于没有把组合对象和叶子对象统一块儿来，也就是说，组合对象类型和叶子对象类型是彻底不一样的类型，这致使了操做的时候必须区分它们。
组合模式经过引入一个抽象的组件对象，做为组合对象和叶子对象的父对象，这样就把组合对象和叶子对象统一块儿来了，用户使用的时候，始终是在操做组件对象，而再也不去区分是在操做组合对象仍是在操做叶子对象。
组合模式的关键就在于这个抽象类，这个抽象类既能够表明叶子对象，也能够表明组合对象，这样用户在操做的时候，对单个对象和组合对象的使用就具备了一致性。
##2.2 模式结构和说明## 组合模式的结构如图15.1所示：
Component：
抽象的组件对象，为组合中的对象声明接口，让客户端能够经过这个接口来访问和管理整个对象结构，能够在里面为定义的功能提供缺省的实现。Leaf：
叶子节点对象，定义和实现叶子对象的行为，再也不包含其它的子节点对象。Composite：
组合对象，一般会存储子组件，定义包含子组件的那些组件的行为，并实如今组件接口中定义的与子组件有关的操做。Client：客户端，经过组件接口来操做组合结构里面的组件对象。
一种典型的Composite对象结构一般是如图15.2所示的树形结构，一个Composite对象能够包含多个叶子多象和其它的Composite对象，虽然15.2的图看起来好像有些对称，可是那只是为了让图看起来美观一点，并非说Composite组合的对象结构就是这样对称的，这点要提早说明一下。
##2.3 组合模式的示例代码##
- 先看看组件对象的定义，示例代码以下：
/**
* 抽象的组件对象，为组合中的对象声明接口，实现接口的缺省行为
*/
public abstract class Component {
/**
* 示意方法，子组件对象可能有的功能方法
*/
public abstract void someOperation();
/**
* 向组合对象中加入组件对象
* @param child 被加入组合对象中的组件对象
*/
public void addChild(Component child) {
// 缺省的实现，抛出例外，由于叶子对象没有这个功能，
//或者子组件没有实现这个功能
throw new UnsupportedOperationException("对象不支持这个功能");
}
/**
* 从组合对象中移出某个组件对象
* @param child 被移出的组件对象
*/
public void removeChild(Component child) {
// 缺省的实现，抛出例外，由于叶子对象没有这个功能，
//或者子组件没有实现这个功能
throw new UnsupportedOperationException("对象不支持这个功能");
}
/**
* 返回某个索引对应的组件对象
* @param index 须要获取的组件对象的索引，索引从0开始
* @return 索引对应的组件对象
*/
public Component getChildren(int index) {
// 缺省的实现，抛出例外，由于叶子对象没有这个功能，
//或者子组件没有实现这个功能
throw new UnsupportedOperationException("对象不支持这个功能");
}
}
- 接下来看看Composite对象的定义，示例代码以下：
/**
* 组合对象，一般须要存储子对象，定义有子部件的部件行为，
* 并实如今Component里面定义的与子部件有关的操做
*/
public class Composite extends Component {
/**
* 用来存储组合对象中包含的子组件对象
*/
private List<Component> childComponents = null;
/**
* 示意方法，一般在里面须要实现递归的调用
*/
public void someOperation() {
if (childComponents != null){
for(Component c : childComponents){
//递归的进行子组件相应方法的调用
c.someOperation();
}
}
}
public void addChild(Component child) {
//延迟初始化
if (childComponents == null) {
childComponents = new ArrayList<Component>();
}
childComponents.add(child);
}
public void removeChild(Component child) {
if (childComponents != null) {
childComponents.remove(child);
}
}
public Component getChildren(int index) {
if (childComponents != null){
if(index>=0 && index<childComponents.size()){
return childComponents.get(index);
}
}
return null;
}
}
- 该来看叶子对象的定义了，相对而言比较简单，示例代码以下：
/**
* 叶子对象，叶子对象再也不包含其它子对象
*/
public class Leaf extends Component {
/**
* 示意方法，叶子对象可能有本身的功能方法
*/
public void someOperation() {
// do something
}
}
- 对于Client，就是使用Component接口来操做组合对象结构，因为使用方式千差万别，这里仅仅提供一个示范性质的使用，顺便看成测试代码使用，示例代码以下：
public class Client {
public static void main(String[] args) {
//定义多个Composite对象
Component root = new Composite();
Component c1 = new Composite();
Component c2 = new Composite();
//定义多个叶子对象
Component leaf1 = new Leaf();
Component leaf2 = new Leaf();
Component leaf3 = new Leaf();
//组合成为树形的对象结构
root.addChild(c1);
root.addChild(c2);
root.addChild(leaf1);
c1.addChild(leaf2);
c2.addChild(leaf3);
//操做Component对象
Component o = root.getChildren(1);
System.out.println(o);
}
}
##2.4 使用组合模式重写示例## 理解了组合模式的定义、结构和示例代码事后，对组合模式应该有必定的掌握了，下面就来使用组合模式，来重写前面不用模式的示例，看看用组合模式来实现会是什么样子，跟不用模式有什么相同和不一样之处。
为了总体理解和把握整个示例，先来看看示例的总体结构，如图15.3所示：
- 首先就是
要为组合对象和叶子对象添加一个抽象的父对象作为组件对象，在组件对象里面，定义一个输出组件自己名称的方法以实现要求的功能，示例代码以下：
/**
* 抽象的组件对象
*/
public abstract class Component {
/**
* 输出组件自身的名称
*/
public abstract void printStruct(String preStr);
/**
* 向组合对象中加入组件对象
* @param child 被加入组合对象中的组件对象
*/
public void addChild(Component child) {
throw new UnsupportedOperationException("对象不支持这个功能");
}
/**
* 从组合对象中移出某个组件对象
* @param child 被移出的组件对象
*/
public void removeChild(Component child) {
throw new UnsupportedOperationException("对象不支持这个功能");
}
/**
* 返回某个索引对应的组件对象
* @param index 须要获取的组件对象的索引，索引从0开始
* @return 索引对应的组件对象
*/
public Component getChildren(int index) {
throw new UnsupportedOperationException("对象不支持这个功能");
}
}
- 先看叶子对象的实现，它变化比较少，
只是让叶子对象继承了组件对象，其它的跟不用模式比较，没有什么变化，示例代码以下：
/**
* 叶子对象
*/
public class Leaf extends Component{
/**
* 叶子对象的名字
*/
private String name = "";
/**
* 构造方法，传入叶子对象的名字
* @param name 叶子对象的名字
*/
public Leaf(String name){
this.name = name;
}
/**
* 输出叶子对象的结构，叶子对象没有子对象，也就是输出叶子对象的名字
* @param preStr 前缀，主要是按照层级拼接的空格，实现向后缩进
*/
public void printStruct(String preStr){
System.out.println(preStr+"-"+name);
}
}
- 接下来看看组合对象的实现，这个对象变化就比较多，大体有以下的改变：
新的Composite对象须要继承组件对象；
原来用来记录包含的其它组合对象的集合，和包含的其它叶子对象的集合，这两个集合被合并成为一个，就是统一的包含其它子组件对象的集合。使用组合模式来实现，再也不须要区分究竟是组合对象仍是叶子对象了；
原来的addComposite和addLeaf的方法，能够不须要了，合并实现成组件对象中定义的方法addChild，固然须要如今的Composite来实现这个方法。使用组合模式来实现，再也不须要区分究竟是组合对象仍是叶子对象了；
原来的printStruct方法的实现，彻底要按照如今的方式来写，变化较大；
具体的示例代码以下：
/**
* 组合对象，能够包含其它组合对象或者叶子对象
*/
public class Composite extends Component{
/**
* 用来存储组合对象中包含的子组件对象
*/
private List<Component> childComponents = null;
/**
* 组合对象的名字
*/
private String name = "";
/**
* 构造方法，传入组合对象的名字
* @param name 组合对象的名字
*/
public Composite(String name){
this.name = name;
}
public void addChild(Component child) {
//延迟初始化
if (childComponents == null) {
childComponents = new ArrayList<Component>();
}
childComponents.add(child);
}
/**
* 输出组合对象自身的结构
* @param preStr 前缀，主要是按照层级拼接的空格，实现向后缩进
*/
public void printStruct(String preStr){
//先把本身输出去
System.out.println(preStr+"+"+this.name);
//若是还包含有子组件，那么就输出这些子组件对象
if(this.childComponents!=null){
//而后添加一个空格，表示向后缩进一个空格
preStr+=" ";
//输出当前对象的子对象了
for(Component c : childComponents){
//递归输出每一个子对象
c.printStruct(preStr);
}
}
}
}
- 客户端也有变化，
客户端再也不须要区分组合对象和叶子对象了，统一都是使用组件对象，调用的方法也都要改变成组件对象定义的方法。示例代码以下：
public class Client {
public static void main(String[] args) {
//定义全部的组合对象
Component root = new Composite("服装");
Component c1 = new Composite("男装");
Component c2 = new Composite("女装");
//定义全部的叶子对象
Component leaf1 = new Leaf("衬衣");
Component leaf2 = new Leaf("夹克");
Component leaf3 = new Leaf("裙子");
Component leaf4 = new Leaf("套装");
//按照树的结构来组合组合对象和叶子对象
root.addChild(c1);
root.addChild(c2);
c1.addChild(leaf1);
c1.addChild(leaf2);
c2.addChild(leaf3);
c2.addChild(leaf4);
//调用根对象的输出功能来输出整棵树
root.printStruct("");
}
}
经过上面的示例，你们能够看出，经过使用组合模式，把一个“部分-总体”的层次结构表示成了对象树的结构，这样一来，客户端就无需再区分操做的是组合对象仍是叶子对象了，对于客户端而言，操做的都是组件对象。
#3 模式讲解# ##3.1 认识组合模式##
- 组合模式的目的
组合模式的目的是：让客户端再也不区分操做的是组合对象仍是叶子对象，而是以一个统一的方式来操做。
实现这个目标的关键之处，是设计一个抽象的组件类，让它能够表明组合对象和叶子对象。这样一来，客户端就不用区分究竟是组合对象仍是叶子对象了，只须要所有当成组件对象进行统一的操做就能够了。
- 对象树
一般，组合模式会组合出树形结构来，组成这个树形结构所使用的多个组件对象，就天然的造成了对象树。
这也意味着凡是可使用对象树来描述或操做的功能，均可以考虑使用组合模式，好比读取XML文件，或是对语句进行语法解析等。
- 组合模式中的递归
组合模式中的递归，指的是对象递归组合，不是常说的递归算法。一般咱们谈的递归算法，是指“一个方法会调用方法本身”这样的算法，是从功能上来说的，好比那个经典的求阶乘的例子，示例以下：
public class RecursiveTest {
/**
* 示意递归算法，求阶乘。这里只是简单的实现，只能实现求数值较小的阶乘，
* 对于数据比较大的阶乘，好比求100的阶乘应该采用java.math.BigDecimal
* 或是java.math.BigInteger
* @param a 求阶乘的数值
* @return 该数值的阶乘值
*/
public int recursive(int a){
if(a==1){
return 1;
}
return a * recursive(a-1);
}
public static void main(String[] args) {
RecursiveTest test = new RecursiveTest();
int result = test.recursive(5);
System.out.println("5的阶乘="+result);
}
}
而这里的组合模式中的递归，是对象自己的递归，是对象的组合方式，是从设计上来说的，在设计上称做递归关联，是对象关联关系的一种，若是用UML来表示对象的递归关联的话，一对一的递归关联如图15.4所示，而一对多的递归关联如图15.5所示：
另外组合对象还有一个特色，就是理论上没有层次限制，组合对象A包含组合对象B，组合对象B又包含组合对象C……，这样下去是没有尽头的。所以在实现的时候，一个必然的选择就是递归实现。
- Component中是否应该实现一个Component列表
大多数状况下，一个Composite对象会持有子节点的集合。有些朋友可能就会想，那么能不能把这个子节点集合定义到Component中去呢？由于在Component中还声明了一些操做子节点的方法，这样一来，大部分的工做就能够在Component中完成了。
事实上，这种方法是不太好的，由于在父类来存放子类的实例对象，对于Composite节点来讲没有什么，它原本就须要存放子节点，可是对于叶子节点来讲，就会致使空间的浪费，由于叶节点自己不须要子节点。
所以只有当组合结构中叶子对象数目较少的时候，才值得使用这种方法。
- 最大化Component定义
前面讲到了组合模式的目的是：让客户端再也不区分操做的是组合对象仍是叶子对象，而是以一种统一的方式来操做。
因为要统一两种对象的操做，因此Component里面的方法也主要是两种对象对外方法的和，换句话说，有点大杂烩的意思，组件里面既有叶子对象须要的方法，也有组合对象须要的方法。
其实这种实现是与类的设计原则相冲突的，类的设计有这样的原则：一个父类应该只定义那些对它的子类有意义的操做。可是看看上面的实现就知道，Component中的有些方法对于叶子对象是没有意义的。那么怎么解决这一冲突呢？
常见的作法是在Component里面为对某些子对象没有意义的方法，提供默认的实现，或是默认抛出不支持该功能的例外。这样一来，若是子对象须要这个功能，那就覆盖实现它，若是不须要，那就不用管了，使用父类的默认实现就能够了。
从另外一个层面来讲，若是把叶子对象当作是一个特殊的Composite对象，也就是没有子节点的组合对象而已。这样看来，对于Component而言，子对象就所有看做是组合对象，所以定义的全部方法都是有意义的了。
- 子部件排序
在某些应用中，使用组合模式的时候，须要按照必定的顺序来使用子组件对象，好比进行语法分析的时候，使用组合模式构建的抽象语法树，在解析执行的时候，是须要按照顺序来执行的。
对于这样的功能，须要在设计的时候，就要把组件对象的索引考虑进去，并仔细的设计对子节点的访问和管理接口，一般的方式是须要按照顺序来存储，这样在获取的时候就能够按照顺序获得了。能够考虑结合Iterator模式来实现按照顺序的访问组件对象。
##3.2 安全性和透明性## 根据前面的讲述，在组合模式中，把组件对象分红了两种，一种是能够包含子组件的Composite对象，一种是不能包含其它组件对象的叶子对象。
Composite对象就像是一个容器，能够包含其它的Composite对象或叶子对象。固然有了容器，就要能对这个容器进行维护，须要向里面添加对象，并可以从容器里面获取对象，还有能从容器中删除对象，也就是说须要管理子组件对象。
这就产生了一个很重要的问题：到底在组合模式的类层次结构中，在哪一些类里面定义这些管理子组件的操做，到底应该在Component中声明这些操做，仍是在Composite中声明这些操做？
这就须要仔细思考，在不一样的实现中，进行安全性和透明性的权衡选择。
这里所说的安全性是指：从客户使用组合模式上看是否更安全。若是是安全的，那么不会有发生误操做的可能，能访问的方法都是被支持的功能。
这里所说的透明性是指：从客户使用组合模式上，是否须要区分究竟是组合对象仍是叶子对象。若是是透明的，那就是再也不区分，对于客户而言，都是组件对象，具体的类型对于客户而言是透明的，是客户无须要关心的。
- 透明性的实现
若是把管理子组件的操做定义在Component中，那么客户端只须要面对Component，而无需关心具体的组件类型，这种实现方式就是透明性的实现。事实上，前面示例的实现方式都是这种实现方式。
可是透明性的实现是以安全性为代价的，由于在Component中定义的一些方法，对于叶子对象来讲是没有意义的，好比：增长、删除子组件对象。而客户不知道这些区别，对客户是透明的，所以客户可能会对叶子对象调用这种增长或删除子组件的方法，这样的操做是不安全的。
组合模式的透明性实现，一般的方式是：在Component中声明管理子组件的操做，并在Component中为这些方法提供缺省的实现，若是是有子对象不支持的功能，缺省的实现能够是抛出一个例外，来表示不支持这个功能。
- 安全性的实现
若是把管理子组件的操做定义在Composite中，那么客户在使用叶子对象的时候，就不会发生使用添加子组件或是删除子组件的操做了，由于压根就没有这样的功能，这种实现方式是安全的。
可是这样一来，客户端在使用的时候，就必须区分到底使用的是Composite对象，仍是叶子对象，不一样对象的功能是不同的。也就是说，这种实现方式，对客户而言就不是透明的了。
下面把用透明性方式实现的示例，改为用安全性的方式再实现一次，这样你们能够对比来看，能够更好的理解组合模式的透明性和安全性这两种实现方式。
先仍是来看一下使用安全性方式实现示例的结构，如图15.6所示：
（1）首先看看Component的定义，跟透明性的实现相比，安全性的实现方式，Component里面再也不定义管理和操做子组件的方法，把相应的方法都去掉。示例代码以下：
/**
* 抽象的组件对象，安全性的实现方式
*/
public abstract class Component {
/**
* 输出组件自身的名称
*/
public abstract void printStruct(String preStr);
}
（2）Composite对象和Leaf对象的实现都没有任何的变化，这里就不去赘述了
（3）接下来看看客户端的实现，客户端的变化主要是要区分Composite对象和Leaf对象，而原来是不区分的，都是Component对象。示例代码以下：
public class Client {
public static void main(String[] args) {
//定义全部的组合对象
Composite root = new Composite("服装");
Composite c1 = new Composite("男装");
Composite c2 = new Composite("女装");
//定义全部的叶子对象
Leaf leaf1 = new Leaf("衬衣");
Leaf leaf2 = new Leaf("夹克");
Leaf leaf3 = new Leaf("裙子");
Leaf leaf4 = new Leaf("套装");
//按照树的结构来组合组合对象和叶子对象
root.addChild(c1);
root.addChild(c2);
c1.addChild(leaf1);
c1.addChild(leaf2);
c2.addChild(leaf3);
c2.addChild(leaf4);
//调用根对象的输出功能来输出整棵树
root.printStruct("");
}
}
从上面的示例能够看出，从实现上，透明性和安全性的实现差异并非很大。
- 两种实现方式的选择
对于组合模式而言，在安全性和透明性上，会更看重透明性，毕竟组合模式的功能就是要让用户对叶子对象和组合对象的使用具备一致性。
并且对于安全性的实现，须要区分是组合对象仍是叶子对象，可是有的时候，你须要将对象进行类型转换，却发现类型信息丢失了，只好强行转换，这种类型转换必然是不够安全的。
对于这种状况的处理方法是在Component里面定义一个getComposite的方法，用来判断是组合对象仍是叶子对象，若是是组合对象，就返回组合对象，若是是叶子对象，就返回null，这样就能够先判断，而后再强制转换。
所以在使用组合模式的时候，建议多用透明性的实现方式，而少用安全性的实现方式。
##3.3 父组件引用## 在上面的示例中，都是在父组件对象里面，保存有子组件的引用，也就是说都是从父到子的引用。而本节来讨论一下子组件对象到父组件对象的引用，这个在实际开发中也是很是有用的，好比：
如今要删除某个商品类别。若是这个类别没有子类别的话，直接删除就行了，没有太大的问题，可是若是它还有子类别，这就涉及到它的子类别如何处理了，一种状况是连带所有删除，一种是上移一层，把被删除的商品类别对象的父商品类别，设置成为被删除的商品类别的子类别的父商品类别。
如今要进行商品类别的细化和调整，把本来属于A类别的一些商品类别，调整到B类别里面去，某个商品类别的调整会伴随着它全部的子类别一块儿调整。这样的调整可能会：把本来是兄弟关系的商品类别变成父子关系，也可能会把本来是父子关系的商品类别调整成了兄弟关系，如此等等会有不少种可能。
要实现上述的功能，一个较为简单的方案就是在保持从父组件到子组件引用的基础上，再增长保持从子组件到父组件的引用，这样在删除一个组件对象或是调整一个组件对象的时候，能够经过调整父组件的引用来实现，这能够大大简化实现。
一般会在Component中定义对父组件的引用，组合对象和叶子对象均可以继承这个引用。那么何时来维护这个引用呢？
较为容易的办法就是：在组合对象添加子组件对象的时候，为子组件对象设置父组件的引用；在组合对象删除一个子组件对象的时候，再从新设置相关子组件的父组件引用。把这些实现到Composite中，这样全部的子类均可以继承到这些方法，从而更容易的维护子组件到父组件的引用。
仍是看示例会比较清楚。在前面实现的商品类别的示例基础上，来示例对父组件的引用，并实现删除某个商品类别，而后把被删除的商品类别对象的父商品类别，设置成为被删除的商品类别的子类别的父商品类别。也就是把被删除的商品类别对象的子商品类别都上移一层。
- 先看看Component组件的定义，大体有以下变化：
添加一个属性来记录组件对象的父组件对象，同时提供相应的getter/setter方法来访问父组件对象；
添加一个能获取一个组件所包含的子组件对象的方法，提供给实现当某个组件被删除时，把它的子组件对象上移一层的功能时使用；
public abstract class Component {
/**
* 记录父组件对象
*/
private Component parent = null;
/**
* 获取一个组件的父组件对象
* @return 一个组件的父组件对象
*/
public Component getParent() {
return parent;
}
/**
* 设置一个组件的父组件对象
* @param parent 一个组件的父组件对象
*/
public void setParent(Component parent) {
this.parent = parent;
}
/**
* 返回某个组件的子组件对象
* @return 某个组件的子组件对象
*/
public List<Component> getChildren() {
throw new UnsupportedOperationException("对象不支持这个功能");
}
/*-------------------如下是原有的定义----------------------*/
public abstract void printStruct(String preStr);
public void addChild(Component child) {
throw new UnsupportedOperationException("对象不支持这个功能");
}
public void removeChild(Component child) {
throw new UnsupportedOperationException("对象不支持这个功能");
}
public Component getChildren(int index) {
throw new UnsupportedOperationException("对象不支持这个功能");
}
}
- 接下来看看Composite的实现，大体有以下变化：
在添加子组件的方法实现里面，加入对父组件的引用实现；
在删除子组件的方法实现里面，加入把被删除的商品类别对象的父商品类别，设置成为被删除的商品类别的子类别的父商品类别的功能；
实现新的返回组件的子组件对象的功能；
/**
* 组合对象，能够包含其它组合对象或者叶子对象
*/
public class Composite extends Component{
public void addChild(Component child) {
//延迟初始化
if (childComponents == null) {
childComponents = new ArrayList<Component>();
}
childComponents.add(child);
//添加对父组件的引用
child.setParent(this);
}
public void removeChild(Component child) {
if (childComponents != null) {
//查找到要删除的组件在集合中的索引位置
int idx = childComponents.indexOf(child);
if (idx != -1) {
//先把被删除的商品类别对象的父商品类别，
//设置成为被删除的商品类别的子类别的父商品类别
for(Component c : child.getChildren()){
//删除的组件对象是本实例的一个子组件对象
c.setParent(this);
//把被删除的商品类别对象的子组件对象添加到当前实例中
childComponents.add(c);
}
//真的删除
childComponents.remove(idx);
}
}
}
public List<Component> getChildren() {
return childComponents;
}
/*------------如下是原有的实现，没有变化----------------*/
private List<Component> childComponents = null;
private String name = "";
public Composite(String name){
this.name = name;
}
public void printStruct(String preStr){
System.out.println(preStr+"+"+this.name);
if(this.childComponents!=null){
preStr+=" ";
for(Component c : childComponents){
c.printStruct(preStr);
}
}
}
}
-
叶子对象没有任何的改变，这里就不去赘述了
-
能够来写个客户端测试一下了，在原来的测试后面，删除一个节点，而后再次输出整棵树的结构，看看效果。示例代码以下：
public class Client {
public static void main(String[] args) {
//定义全部的组合对象
Component root = new Composite("服装");
Component c1 = new Composite("男装");
Component c2 = new Composite("女装");
//定义全部的叶子对象
Component leaf1 = new Leaf("衬衣");
Component leaf2 = new Leaf("夹克");
Component leaf3 = new Leaf("裙子");
Component leaf4 = new Leaf("套装");
//按照树的结构来组合组合对象和叶子对象
root.addChild(c1);
root.addChild(c2);
c1.addChild(leaf1);
c1.addChild(leaf2);
c2.addChild(leaf3);
c2.addChild(leaf4);
//调用根对象的输出功能来输出整棵树
root.printStruct("");
System.out.println("---------------------------->");
//而后删除一个节点
root.removeChild(c1);
//从新输出整棵树
root.printStruct("");
}
}
运行结果以下：
+服装
+男装
-衬衣
-夹克
+女装
-裙子
-套装
---------------------------->
+服装
+女装
-裙子
-套装
-衬衣
-夹克
仔细观察上面的结果，当男装的节点被删除后，会把原来男装节点下的子节点，添加到原来男装的父节点，也就是服装的下面了。输出是按照添加的前后顺序来的，因此先输出了女装的，而后才是衬衣和夹克节点。
##3.4 环状引用## 所谓环状引用指的是：在对象结构中，某个对象包含的子对象，或是子对象的子对象，或是子对象的子对象的子对象……,如此通过N层后，出现所包含的子对象中有这个对象自己，从而构成了环状引用。好比：A包含B，B包含C，而C又包含了A，转了一圈，转回来了，就构成了一个环状引用。
这个在使用组合模式构建树状结构的时候，是须要考虑的一种状况。一般状况下，组合模式构建的树状结构，是不该该出现环状引用的，若是出现了，多半是有错误发生了。所以在应用组合模式实现功能的时候，就应该考虑要检测并避免出现环状引用，不然很容易引发死循环的操做，或是同一个功能被操做屡次。
可是要说明的是：组合模式的实现里面也是能够有环状引用的，固然须要特殊构建环状引用，并提供相应的检测和处理，这里不去讨论这种状况。
那么该如何检测是否有环状引用的状况发生呢？
一个很简单的思路就是记录下每一个组件从根节点开始的路径，由于要出现环状引用，在一条路径上，某个对象就必然会出现两次。所以只要每一个对象在整个路径上只是出现了一次，那么就不会出现环状引用。
这个判断的功能能够添加到Composite对象的添加子组件的方法中，若是是环状引用的话，就抛出例外，并不会把它加入到子组件中去。
仍是经过示例来讲明吧。在前面实现的商品类别的示例基础上，来加入对环状引用的检测和处理。约定用组件的名称来表明组件，也就是说，组件的名称是惟一的，不会重复的，只要检测在一条路径上，组件名称不会重复，那么组件就不会重复。
- 先看看Component的定义，大体有以下的变化：
添加一个记录每一个组件的路径的属性，并提供相应的getter/setter方法；
为了拼接组件的路径，新添加一个方法来获取组件的名称；
public abstract class Component {
/**
* 记录每一个组件的路径
*/
private String componentPath = "";
/**
* 获取组件的路径
* @return 组件的路径
*/
public String getComponentPath() {
return componentPath;
}
/**
* 设置组件的路径
* @param componentPath 组件的路径
*/
public void setComponentPath(String componentPath) {
this.componentPath = componentPath;
}
/**
* 获取组件的名称
* @return 组件的名称
*/
public abstract String getName();
/*-------------------如下是原有的定义----------------------*/
public abstract void printStruct(String preStr);
public void addChild(Component child) {
throw new UnsupportedOperationException("对象不支持这个功能");
}
public void removeChild(Component child) {
throw new UnsupportedOperationException("对象不支持这个功能");
}
public Component getChildren(int index) {
throw new UnsupportedOperationException("对象不支持这个功能");
}
}
- 再看看Composite的实现，大体有以下的变化：
提供获取组件名称的实现；
在添加子组件的实现方法里面，进行是否环状引用的判断，并计算组件对象的路径，而后设置回组件对象去；
public class Composite extends Component{
public String getName(){
return this.name;
}
public void addChild(Component child) {
//延迟初始化
if (childComponents == null) {
childComponents = new ArrayList<Component>();
}
childComponents.add(child);
//先判断组件路径是否为空，若是为空，说明本组件是根组件
if(this.getComponentPath()==null || this.getComponentPath().trim().length()==0){
//把本组件的name设置到组件路径中
this.setComponentPath(this.name);
}
//判断要加入的组件在路径上是否出现过
//先判断是不是根组件
if(this.getComponentPath().startsWith(child.getName()+".")){
//说明是根组件，重复添加了
throw new java.lang.IllegalArgumentException("在本通路上，组件 '"+child.getName()+"' 已被添加过了");
} else {
if(this.getComponentPath().indexOf("."+child.getName()) < 0){
//表示没有出现过,那么能够加入
//计算组件的路径
String componentPath = this.getComponentPath()+"."+child.getName();
//设置子组件的路径
child.setComponentPath(componentPath);
}else{
throw new java.lang.IllegalArgumentException("在本通路上，组件 '"+child.getName()+"' 已被添加过了");
}
}
}
/*---------------如下是原有的实现，没有变化------------------*/
private List<Component> childComponents = null;
private String name = "";
public Composite(String name){
this.name = name;
}
public void printStruct(String preStr){
System.out.println(preStr+"+"+this.name);
if(this.childComponents!=null){
preStr+=" ";
for(Component c : childComponents){
c.printStruct(preStr);
}
}
}
}
-
叶子对象的实现，只是多了一个实现获取组件名称的方法，也就是直接返回叶子对象的Name，跟Composite中的实现是相似的，就不去代码示例了
-
客户端的代码能够不作修改，能够正常执行，输出商品类别树来。固然，若是想要看到环状引用检测的效果，你能够作一个环状引用测试看看，好比：
public class Client {
public static void main(String[] args) {
//定义全部的组合对象
Component root = new Composite("服装");
Component c1 = new Composite("男装");
Component c2= new Composite("衬衣");
Component c3= new Composite("男装");
//设置一个环状引用
root.addChild(c1);
c1.addChild(c2);
c2.addChild(c3);
//调用根对象的输出功能来输出整棵树
root.printStruct("");
}
}
运行结果以下：
Exception in thread "main" java.lang.IllegalArgumentException: 在本通路上，组件 '男装' 已被添加过了； 后面的堆栈信息就省略了
- 说明
上面进行环路检测的实现是很是简单的，可是还有一些问题没有考虑，好比：要是删除了路径上的某个组件对象，那么全部该组件对象的子组件对象所记录的路径，都须要修改，要把这个组件从全部相关路径上都去除掉。就是在被删除的组件对象的全部子组件对象的路径上，查找到被删除组件的名称，而后经过字符串截取的方式把它删除掉。
只是这样的实现方式有些不太好，要实现这样的功能，能够考虑使用动态计算路径的方式，每次添加一个组件的时候，动态的递归寻找父组件，而后父组件再找父组件，一直到根组件，这样就能避免某个组件被删除后，路径发生了变化，须要修改全部相关路径记录的状况。
##3.5 组合模式的优缺点##
- 定义了包含基本对象和组合对象的类层次结构
在组合模式中，基本对象能够被组合成更复杂的组合对象，而组合对象又能够组合成更复杂的组合对象，能够不断地递归组合下去，从而构成一个统一的组合对象的类层次结构。
- 统一了组合对象和叶子对象
在组合模式中，能够把叶子对象看成特殊的组合对象看待，为它们定义统一的父类，从而把组合对象和叶子对象的行为统一块儿来。
- 简化了客户端调用
组合模式经过统一组合对象和叶子对象，使得客户端在使用它们的时候，就不须要再去区分它们，客户不关心使用的究竟是什么类型的对象，这就大大简化了客户端的使用。
- 更容易扩展
因为客户端是统一的面对Component来操做，所以，新定义的Composite或Leaf子类可以很容易的与已有的结构一块儿工做，而客户端不须要为增添了新的组件类而改变。
- 很难限制组合中的组件类型
容易增长新的组件也会带来一些问题，好比很难限制组合中的组件类型。这在须要检测组件类型的时候，使得咱们不能依靠编译期的类型约束来完成，必须在运行期间动态检测。
##3.6 思考组合模式##
- 组合模式的本质
组合模式的本质：统一叶子对象和组合对象。
组合模式经过把叶子对象当成特殊的组合对象看待，从而对叶子对象和组合对象一视同仁，通通当成了Component对象，有机的统一了叶子对象和组合对象。
正是由于统一了叶子对象和组合对象，在将对象构建成树形结构的时候，才不须要作区分，反正是组件对象里面包含其它的组件对象，如此递归下去；也才使得对于树形结构的操做变得简单，无论对象类型，统一操做。
- 什么时候选用组合模式
建议在以下状况中，选用组合模式：
若是你想表示对象的部分-总体层次结构，能够选用组合模式，把总体和部分的操做统一块儿来，使得层次结构实现更简单，从外部来使用这个层次结构也简单；
若是你但愿统一的使用组合结构中的全部对象，能够选用组合模式，这正是组合模式提供的主要功能；
##3.7 相关模式##
- 组合模式和装饰模式
这两个模式能够组合使用。
装饰模式在组装多个装饰器对象的时候，是一个装饰器找下一个装饰器，下一个再找下一个，如此递归下去。那么这种结构也可使用组合模式来帮助构建，这样一来，装饰器对象就至关于组合模式的Composite对象了。
要让两个模式能很好的组合使用，一般会让它们有一个公共的父类，所以装饰器必须支持组合模式须要的一些功能，好比：增长、删除子组件等等。
- 组合模式和享元模式
这两个模式能够组合使用。
若是组合模式中出现大量类似的组件对象的话，能够考虑使用享元模式来帮助缓存组件对象，这能够减小对内存的须要。
使用享元模式也是有条件的，若是组件对象的可变化部分的状态可以从组件对象里面分离出去，并且组件对象自己不须要向父组件发送请求的话，就能够采用享元模式。
- 组合模式和迭代器模式
这两个模式能够组合使用。
在组合模式中，一般可使用迭代器模式来遍历组合对象的子对象集合，而无需关心具体存放子对象的聚合结构。
- 组合模式和访问者模式
这两个模式能够组合使用。
访问者模式可以在不修改原有对象结构的状况下，给对象结构中的对象增添新的功能。将访问者模式和组合模式合用，能够把本来分散在Composite和Leaf类中的操做和行为都局部化。
若是在使用组合模式的时候，预计到从此可能会有增添其它功能的可能，那么能够采用访问者模式，来预留好添加新功能的方式和通道，这样之后在添加新功能的时候，就不须要再修改已有的对象结构和已经实现的功能了。
- 组合模式和职责链模式
这两个模式能够组合使用。
职责链模式要解决的问题是：实现请求的发送者和接收者之间解耦。职责链模式的实现方式是把多个接收者组合起来，构成职责链，而后让请求在这条链上传递，直到有接收者处理这个请求为止。
能够应用组合模式来构建这条链，至关因而子组件找父组件，父组件又找父组件，如此递归下去，构成一条处理请求的组件对象链。
- 组合模式和命令模式
这两个模式能够组合使用。
命令模式中有一个宏命令的功能，一般这个宏命令就是使用组合模式来组装出来的。
- 1. 设计模式学习笔记十七：组合模式（Composite Pattern）
- 2. 设计模式 | 组合模式（composite）
- 3. 设计模式：组合（Composite）模式
- 4. 设计模式10——组合模式（composite）
- 5. 设计模式：组合模式（Composite Pattern）
- 6. 设计模式（八）组合模式 Composite
- 7. 设计模式-组合模式（Composite）
- 8. 设计模式--Composite组合模式
- 9. C++设计模式-Composite组合模式
- 10. Java设计模式--组合模式（Composite）
- 更多相关文章...
- • Scala 模式匹配 - Scala教程
- • SVN 启动模式 - SVN 教程
- • 委托模式
- • IntelliJ IDEA代码格式化设置
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Appium入门
- 2. Spring WebFlux 源码分析(2)-Netty 服务器启动服务流程 --TBD
- 3. wxpython入门第六步（高级组件）
- 4. CentOS7.5安装SVN和可视化管理工具iF.SVNAdmin
- 5. jedis 3.0.1中JedisPoolConfig对象缺少setMaxIdle、setMaxWaitMillis等方法，问题记录
- 6. 一步一图一代码，一定要让你真正彻底明白红黑树
- 7. 2018-04-12—（重点）源码角度分析Handler运行原理
- 8. Spring AOP源码详细解析
- 9. Spring Cloud（1）
- 10. python简单爬去油价信息发送到公众号