组合模式

Published on 2016 - 07 - 17

组合模式的定义

组合模式(Composite Pattern)也叫合成模式,有时又叫做部分-整体模式(Part-Whole),主要是用来描述部分与整体的关系,其定义如下:

Compose objects into tree structures to represent part-whole hierarchies.Composite lets clients treat individual objects and compositions of objects uniformly.(将对象组合成树形结构以表示“部分-整体”的层次结构,使得用户对单个对象和组合对象的使用具有一致性。)

组合模式的通用类图,如图6所示。

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

  • Component抽象构件角色

定义参加组合对象的共有方法和属性,可以定义一些默认的行为或属性,比如我们例子中的getInfo就封装到了抽象类中。

  • Leaf叶子构件

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

  • Composite树枝构件

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

我们来看组合模式的通用源代码,首先看抽象构件,它是组合模式的精髓,如代码清单18所示。

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

组合模式的重点就在树枝构件,其通用代码如代码清单19所示。

public class Composite extends Component {
     //构件容器
     private ArrayList<Component> componentArrayList = new ArrayList<Component>();
     //增加一个叶子构件或树枝构件
     public void add(Component component){
             this.componentArrayList.add(component);
     }
     //删除一个叶子构件或树枝构件
     public void remove(Component component){
             this.componentArrayList.remove(component);
     }
     //获得分支下的所有叶子构件和树枝构件
     public ArrayList<Component> getChildren(){
             return this.componentArrayList;
     }
}

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

public class Leaf extends Component {
     /*
      * 可以覆写父类方法
      * public void doSomething(){
      * 
      * }
      */
}

场景类负责树状结构的建立,并可以通过递归方式遍历整个树,如代码清单21所示。

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);          
     }
     //通过递归遍历树
     public static void display(Composite root){
             for(Component c:root.getChildren()){
                  if(c instanceof Leaf){ //叶子节点
                          c.doSomething();
                  }else{ //树枝节点
                          display((Composite)c);
                  }
             }
     }
}

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

组合模式的应用

组合模式的优点

  • 高层模块调用简单

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

  • 节点自由增加

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

组合模式的缺点

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

组合模式的使用场景

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

组合模式的注意事项

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

组合模式的扩展

真实的组合模式

什么是真实的组合模式?就是你在实际项目中使用的组合模式,而不是仅仅依照书本上学习到的模式,它是“实践出真知”。在我们的例子中,经过精简后,确实是类、接口减少了很多,而且程序也简单很多,但是大家可能还是很迷茫,这个Client程序并没有改变多少呀,非常正确,树的组装是跑不了的,你要知道在项目中使用关系型数据库来存储这些信息,你可以从数据库中直接提取出哪些人要分配到树枝,哪些人要分配到树叶,树枝与树枝、树叶的关系等,这些都是由相关的业务人员维护到数据库中的,通常这里是把数据存放到一张单独的表中,表结构如图7所示。

这张数据表定义了一个树形结构,我们要做的就是从数据库中把它读取出来,然后展现到前台上,用for循环加上递归就可以完成这个读取。用了数据库后,数据和逻辑已经在表中定义好了,我们直接读取放到树上就可以了,这个还是比较容易做的,大家不妨自己考虑一下。

这才是组合模式的真实引用,它依靠了关系数据库的非对象存储性能,非常方便地保存了一个树形结构。大家可以在项目中考虑采用,想想看现在还有哪个项目不使用关系型数据库呢?

透明的组合模式

组合模式有两种不同的实现:透明模式和安全模式,我们上面讲的就是安全模式,那透明模式是什么样子呢?透明模式的通用类图,如图8所示。

我们与图6所示的安全模式类图对比一下就非常清楚了,透明模式是把用来组合使用的方法放到抽象类中,比如add()、remove()以及getChildren等方法(顺便说一下,getChildren一般返回的结果为Iterable的实现类,很多,大家可以看JDK的帮助),不管叶子对象还是树枝对象都有相同的结构,通过判断是getChildren的返回值确认是叶子节点还是树枝节点,如果处理不当,这个会在运行期出现问题,不是很建议的方式;安全模式就不同了,它是把树枝节点和树叶节点彻底分开,树枝节点单独拥有用来组合的方法,这种方法比较安全,我们的例子使用了安全模式。

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

public abstract class Component {
     //个体和整体都具有的共享
     public void doSomething(){
             //编写业务逻辑
     }
     //增加一个叶子构件或树枝构件
     public abstract void add(Component component);
     //删除一个叶子构件或树枝构件
     public abstract void remove(Component component);
     //获得分支下的所有叶子构件和树枝构件
     public abstract ArrayList<Component> getChildren();
}

抽象构件定义了树枝节点和树叶节点都必须具有的方法和属性,这样树枝节点的实现就不需要任何变化,如代码清单19所示。

树叶节点继承了Component抽象类,不想让它改变有点难,它必须实现三个抽象方法,怎么办?好办,给个空方法,如代码清单23所示。

public class Leaf extends Component {
     @Deprecated
     public void add(Component component) throws UnsupportedOperationException{
             //空实现,直接抛弃一个"不支持请求"异常
             throw new UnsupportedOperationException();
     }
     @Deprecated
     public void remove(Component component)throws UnsupportedOperationException{
             //空实现
             throw new UnsupportedOperationException();
     }
  @Deprecated
     public ArrayList<Component> getChildren()throws UnsupportedOperationException{
             //空实现
             throw new UnsupportedOperationException();          
     }
}

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

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

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

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

组合模式的遍历

我们在上面也还提到了一个问题,就是树的遍历问题,从上到下遍历没有问题,但是我要是从下往上遍历呢?比如组织机构这棵树,我从中抽取一个用户,要找到它的上级有哪些,下级有哪些,怎么处理?想想,再想想!想出来了吧,我们对下答案,类图如图9所示。

看类图中,在Corp类中增加了两个方法,setParent是设置父节点是谁,getParent是查找父节点是谁,我们来看一下程序的改变,如代码清单25所示。

public abstract class Corp {
     //公司每个人都有名称
     private String name = "";
     //公司每个人都职位
     private String position = "";
     //公司每个人都有薪水
     private int salary =0;
     //父节点是谁
     private Corp parent = null;
     public Corp(String _name,String _position,int _salary){
             this.name = _name;
             this.position = _position;
             this.salary = _salary;
     }
     //获得员工信息
      public String getInfo(){
             String info = "";
             info = "姓名:" + this.name;
             info = info + "\t职位:"+ this.position;
             info = info + "\t薪水:" + this.salary;
             return info;
     }
     //设置父节点
     protected void setParent(Corp _parent){
             this.parent = _parent;
     }
     //得到父节点
     public Corp getParent(){
             return this.parent;
     }
}

就增加了粗体部分,然后我们再来看看树枝节点的改变,如代码清单26所示。

public class Branch extends Corp {
     //领导下边有哪些下级领导和小兵
     ArrayList<Corp> subordinateList = new ArrayList<Corp>();
     //构造函数是必需的
     public Branch(String _name,String _position,int _salary){
             super(_name,_position,_salary);
     }
     //增加一个下属,可能是小头目,也可能是个小兵
     public void addSubordinate(Corp corp) {
             corp.setParent(this); //设置父节点
             this.subordinateList.add(corp);
     }
     //我有哪些下属
     public ArrayList<Corp> getSubordinate() {
             return this.subordinateList;
     }
}

增加了粗体部分。看懂程序了吗?甭管是树枝节点还是树叶节点,在每个节点都增加了一个属性:父节点对象,这样在树枝节点增加子节点或叶子节点是设置父节点,然后你看整棵树除了根节点外每个节点都有一个父节点,剩下的事情还不好处理吗?每个节点上都有父节点了,你要往上找,那就找呗!大家自己考虑一下,写个find方法,然后一步一步往上找,非常简单的方法,这里就不再赘述。

有了这个parent属性,什么后序遍历(从下往上找)、中序遍历(从中间某个环节往上或往下遍历)都解决了,这个就不多说了。

再提一个问题,树叶节点和树枝节点是有顺序的,你不能乱排,怎么办?比如我们上面的例子,研发一组下边有3个成员,这3个成员要进行排序(在机关里这叫做排位,同样是同事也有个先后升迁顺序),你怎么处理?问我呀,问你呢,好好想想,以后用得着的!

参考文档