组合模式-树形结构的处理

 A公司需要筛选出年龄35岁及以上(如果是领导，年龄为45岁及以上)的人。其组织架构图如下。

图 A公司部分组织架构图

图 传统解决方案

public class Development {

    private String name;

    public Development(String name) {
        this.name = name;
    }

    List<Employee> employeeList = new ArrayList<>();
    List<Development> developmentList = new ArrayList<>();

    public void find() {
        for (Employee employee : employeeList) {
            employee.find();
        }
        for (Development development : developmentList) {
            development.find();
        }
    }

    public String getName() {
        return name;
    }
}

public class Employee {

    private Development development;

    private String name;
    private Integer age;
    private Boolean isLead;

    public Employee(Development development,String name, Integer age, Boolean isLead) {
        this.development = development;
        this.name = name;
        this.age = age;
        this.isLead = isLead;
    }

    public void find() {
        if ((!isLead && age >= 35) || (isLead && age >= 45)) {
            System.out.println(development.getName() + ":" + name + "超龄：" + age + " " + (isLead ? "是" : "不是") + "领导");
        }
    }

}

public class Client {

    Development development = new Development("董事会");

    {
        development.employeeList.add(new Employee(development,"黄总", 53,true));

        development.developmentList.add(new Development("行政部"));
        development.developmentList.add(new Development("营销部"));
        Development techDev = new Development("技术部门");
        development.developmentList.add(techDev);

        techDev.employeeList.add(new Employee(techDev,"技术部经理",36,true));
        techDev.developmentList.add(new Development("技术A组"));
        techDev.developmentList.add(new Development("技术C组"));
        Development bDev = new Development("技术B组");
        techDev.developmentList.add(bDev);

        bDev.employeeList.add(new Employee(bDev,"小黄",27,false));
        bDev.employeeList.add(new Employee(bDev,"小张",27,false));
        bDev.employeeList.add(new Employee(bDev,"老刘",35,false));
    }

    public static void main(String[] args) {
        Client client = new Client();
        client.development.find();
//        运行结果：
//        董事会:黄总超龄：53 是领导
//        技术B组:老刘超龄：35 不是领导
    }

}

在上图的架构图中，同一层存在员工及部门两类实体，它们都有个查找的方法。在代码中在成员变量中将这两类分别存储在两个不同容器中，在查找方法中，也分别对这两个类别调用了查找方法。代码有些冗余。

我们可以把同一层的员工及部门看作是同一类，这样我们只需要一个容器及查找方法也是只要在一处调用该方法了。这就是组合模式。

1 组合模式概述

由于容器对象和叶子对象在功能上的区别，在使用这些对象的代码中，必须有区别地对待容器对象和叶子对象，而实际上大多数情况下希望一致地处理它们，因为区别对待这些对象将会使得程序变得复杂。

组合模式为解决此类问题而诞生，可以让叶子对象和容器对象的使用具有一致性。

组合多个对象形成树形结构以表示具有”部分—整体“关系的层次结构。组合模式对单个对象（即叶子对象）和组合对象（即容器对象）的使用具有一致性，有被称为”部分—整体“模式（Part-Whole）。

图 组合模式结构图

Component:抽象构件，可以是接口或抽象类。可以包含所有子类共同行为的声名和实现。定义了访问及管理它的子构建的方法，例如增加、删除、获取子构件。

Leaf: 叶子构件，没有子节点,对于那些访问及管理子构件的方法，可以通过捕获异常等方式进行处理。

Composite: 容器构件，表示容器对象，包含了子节点。子节点可以是叶子节点，也可以是容器节点。

public interface Component {

    void find(); //查找超龄员工

    void addChildren(Component component);

    void removeChildren(Component component);

    Component getChildren(int pos);

}

public class Development implements Component{

    private String name;

    public Development(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    private final List<Component> componentList = new ArrayList<>();

    @Override
    public void find() {
        for (Component component : componentList) component.find();;
    }

    @Override
    public void addChildren(Component component) {
       componentList.add(component);
    }

    @Override
    public void removeChildren(Component component) {
        componentList.remove(component);
    }

    @Override
    public Component getChildren(int pos) {
        return componentList.get(pos);
    }
}

public class Employee implements Component{

    private String name;
    private Integer age;
    private Boolean isLead;

    public Employee(String name, Integer age, Boolean isLead) {
        this.name = name;
        this.age = age;
        this.isLead = isLead;
    }

    @Override
    public void find() {
        if ((!isLead && age >= 35) || (isLead && age >= 45)) {
            System.out.println(name + "超龄：" + age + " " + (isLead ? "是" : "不是") + "领导");
        }
    }

    @Override
    public void addChildren(Component component) {
        throw new RuntimeException("该方法不可用");
    }

    @Override
    public void removeChildren(Component component) {
        throw new RuntimeException("该方法不可用");
    }

    @Override
    public Component getChildren(int pos) {
        throw new RuntimeException("该方法不可用");
    }

}

public class Client {

    private static final Component component = new Development("董事会");

    static {
        component.addChildren(new Employee("黄总", 53,true));

        component.addChildren(new Development("行政部"));
        component.addChildren(new Development("营销部"));
        Component techCom = new Development("技术部");
        component.addChildren(techCom);

        techCom.addChildren(new Employee("技术部经理",36,true));
        techCom.addChildren(new Development("技术A组"));
        techCom.addChildren(new Development("技术C组"));
        Component bDev = new Development("技术B组");
        techCom.addChildren(bDev);

        bDev.addChildren(new Employee("小黄",27,false));
        bDev.addChildren(new Employee("小张",27,false));
        bDev.addChildren(new Employee("老刘",35,false));
    }

    public static void main(String[] args) {
        component.find();
    }
}

1.1 透明组合模式

抽象构件中声明了所有用于管理成员对象的方法，包括addChildren()、removeChildren等。

优点：确保所有构件类都有相同的接口。在客户端看来，叶子对象与容器所提供的方法是一致的，客户端可以相同地对待所有对象。

缺点：不够安全，叶子对象和容器对象在本质上是有区别的，叶子对象不可能有下一层级的对象，即提供管理成员对象的方法是没有任何意义的。如果在运行阶段调用了这些方法，可能会出错。

透明组合模式是组合模式标准形式。

1.2 安全组合模式

抽象构件中没有声明任何用于管理成员对象的方法，而是在容器构件Composite类中声明并实现了这些方法。

优点：安全，客户端不可能会调用到叶子阶段的管理成员对象的方法。

缺点：不够透明，客户端不能完全针对抽象编程，必须有区别地对待叶子构件和容器构件。

2 优缺点

优点：

1. 可以清楚地定义分层次的复杂对象，表示对象全部或部分层次，让客户端忽略了层次的差异，方便对整个层次结构进行控制。
2. 增加新的容器构件和叶子构件都很方便，无须对现有类库进行任何修改，符合开闭原则。

缺点：

1. 在增加新构件时很难对容器中的构件类型进行限制。当希望一个容器只能有某些特定类型对象时，因为它们都来自相同的抽象层，在这种情况下，必须通过在运行时进行类型检查来实现，这个过程较为复杂。

3 适用场景

1. 在具有整体和部分的层次结构中，希望通过一种方式忽略整体与部分的差异，客户端可以一致性对待它们。
2. 一个系统中能够分离出叶子对象和容器对象，而且它们的类型不固定，将来需要增加一些新的类型。