组合模式
组合模式的解读
树形结构不论在生活中或者是开发中都是一种非常常见的结构，一个容器对象（如文件夹）下可以存放多种不同的叶子对象或者容器对象，容器对象与叶子对象之间属性差别可能非常大。
由于容器对象和叶子对象在功能上的区别，在使用这些对象的代码中必须有区别地对待容器对象和叶子对象，而实际上大多数情况下我们希望一致地处理它们，因为对于这些对象的区别对待将会使得程序非常复杂。
组合模式角色分析
组合模式分为三个角色，分别是Component（抽象构件）、Leaf（叶子构件）和Composite（容器构件）
Component（抽象构件）：
它可以是接口或抽象类，为叶子构件和容器构件对象声明接口，在该角色中可以包含所有子类共有行为的声明和实现。在抽象构件中定义了访问及管理它的子构件的方法，如增加子构件、删除子构件、获取子构件等。Leaf（叶子构件）：
它在组合结构中表示叶子节点对象，叶子节点没有子节点，它实现了在抽象构件中定义的行为。对于那些访问及管理子构件的方法，可以通过异常等方式进行处理。Composite（容器构件）：
它在组合结构中表示容器节点对象，容器节点包含子节点，其子节点可以是叶子节点，也可以是容器节点，它提供一个集合用于存储子节点，实现了在抽象构件中定义的行为，包括那些访问及管理子构件的方法，在其业务方法中可以递归调用其子节点的业务方法。
提出需求
实现统计一个集团公司的总人数。已知该集团组织架构如下
需求分析
既然本篇是讲组合模式，很显然这个需求可以使用组合模式来尝试解决一下。我们可以建立一个AbstractoOrganization对应Component（抽象构件），总公司以及各个分公司都是Composite（容器构件），分公司下面的各个部分则对应的是Leaf（叶子构件）
代码实现
AbstractOrganization
/**
* @Author: ming.wang
* @Date: 2019/2/26 15:31
* @Description: 抽象类或者接口都可以
*/
public abstract class AbstractOrganization {
public abstract int countEmp();//计算员工数量
public void add(AbstractOrganization organization) {
new UnsupportedOperationException("不支持添加操作");
}
public void remove(AbstractOrganization organization) {
new UnsupportedOperationException("不支持删除操作");
}
}
Company:相当于容器构件
/**
* @Author: ming.wang
* @Date: 2019/2/26 15:39
* @Description: 相当于容器构件
*/
@Getter
@Setter
@ToString
public class Company extends AbstractOrganization {
private String name;
private List<AbstractOrganization> organizations=new ArrayList<>();
public Company(String name) {
this.name = name;
}
@Override
public int countEmp() {
int result=0;
for (int i = 0; i < organizations.size(); i++) {
result+=organizations.get(i).countEmp();
}
return result;
}
@Override
public void add(AbstractOrganization organization) {
organizations.add(organization);
}
@Override
public void remove(AbstractOrganization organization) {
organizations.remove(organization);
}
}
Department:相当于叶子构件
/**
* @Author: ming.wang
* @Date: 2019/2/26 15:34
* @Description: 相当于叶子构件
*/
@Getter
@Setter
@ToString
public class Department extends AbstractOrganization {
private String name;
private int count;
public Department(String name, int count) {
this.name = name;
this.count = count;
}
@Override
public int countEmp() {
System.out.println(name+ "正在统计中。。");
System.out.println("统计结果- 人数 :" +count);
System.out.println();
return count;
}
}
Test
/**
* @Author: ming.wang
* @Date: 2019/2/26 15:50
* @Description:
*/
public class Test {
public static void main(String[] args) {
AbstractOrganization 总公司 = new Company("总公司");
AbstractOrganization 华北公司 = new Company("华北公司");
AbstractOrganization 财务部_华北公司=new Department("财务部_华北公司",1);
AbstractOrganization 研发部_华北公司=new Department("研发部_华北公司",2);
AbstractOrganization 销售部_华北公司=new Department("销售部_华北公司",3);
AbstractOrganization 华南公司 = new Company("华南公司");
AbstractOrganization 财务部_华南公司=new Department("财务部_华南公司",4);
AbstractOrganization 研发部_华南公司=new Department("研发部_华南公司",5);
AbstractOrganization 销售部_华南公司=new Department("销售部_华南公司",6);
AbstractOrganization 华中公司 = new Company("华中公司");
AbstractOrganization 财务部_华中公司=new Department("财务部_华中公司",7);
AbstractOrganization 研发部_华中公司=new Department("研发部_华中公司",8);
AbstractOrganization 销售部_华中公司=new Department("销售部_华中公司",9);
AbstractOrganization 华东公司 = new Company("华东公司");
AbstractOrganization 财务部_华东公司=new Department("财务部_华东公司",10);
AbstractOrganization 研发部_华东公司=new Department("研发部_华东公司",11);
AbstractOrganization 销售部_华东公司=new Department("销售部_华东公司",12);
华北公司.add(财务部_华北公司);
华北公司.add(研发部_华北公司);
华北公司.add(销售部_华北公司);
华南公司.add(财务部_华南公司);
华南公司.add(研发部_华南公司);
华南公司.add(销售部_华南公司);
华中公司.add(财务部_华中公司);
华中公司.add(研发部_华中公司);
华中公司.add(销售部_华中公司);
华东公司.add(财务部_华东公司);
华东公司.add(研发部_华东公司);
华东公司.add(销售部_华东公司);
总公司.add(华北公司);
总公司.add(华南公司);
总公司.add(华中公司);
总公司.add(华东公司);
System.out.println("总人数:"+总公司.countEmp());
}
}
运行结果
财务部_华北公司正在统计中。。
统计结果- 人数 :1
研发部_华北公司正在统计中。。
统计结果- 人数 :2
销售部_华北公司正在统计中。。
统计结果- 人数 :3
财务部_华南公司正在统计中。。
统计结果- 人数 :4
研发部_华南公司正在统计中。。
统计结果- 人数 :5
销售部_华南公司正在统计中。。
统计结果- 人数 :6
财务部_华中公司正在统计中。。
统计结果- 人数 :7
研发部_华中公司正在统计中。。
统计结果- 人数 :8
销售部_华中公司正在统计中。。
统计结果- 人数 :9
财务部_华东公司正在统计中。。
统计结果- 人数 :10
研发部_华东公司正在统计中。。
统计结果- 人数 :11
销售部_华东公司正在统计中。。
统计结果- 人数 :12
总人数:78
总结
当我们在程序设计过程中，遇到如下需求的时候，可以考虑使用组合模式。
- 在具有整体和部分的层次结构中，希望通过一种方式忽略整体与部分的差异，客户端可以一致地对待它们。
- 在一个使用面向对象语言开发的系统中需要处理一个树形结构。
- 在一个系统中能够分离出叶子对象和容器对象，而且它们的类型不固定，需要增加一些新的类型。
源码阅读
在开源源码中有很多使用了组合模式，其中最典型的是org.apache.ibatis.scripting.xmltags.SqlNode,感兴趣的小伙伴可以去瞅瞅哦。
