组合模式

定义：

将对象组合成树形结构来表示“部分-整体”的层次结构。组合模式使得客户能以一致的方式处理个别对象和组合对象。

设计类图：

组合模式中的角色：

• Component抽象组件：为组合中所有对象提供一个接口，不管是叶子对象还是组合对象。
• Composite组合节点对象：实现了Component的所有操作，并且持有子节点对象。
• Leaf叶节点对象：叶节点对象没有任何子节点，实现了Component中的某些操作。

组合模式让我们能用树形方式创建对象的结构，树里面包含了组合以及个别的对象。

使用组合结构，我们能把相同的操作应用在组合和个别对象上。换句活说，在大多数情况下，我们可以忽略对象组合和个别对象之问的差别。

示例代码：

public abstract class Component {
    protected String name;

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

    public abstract void operation();

   public void add(Component c) {
        throw new UnsupportedOperationException();
    }

    public void remove(Component c) {
        throw new UnsupportedOperationException();
    }

    public Component getChild(int i) {
        throw new UnsupportedOperationException();
    }

    public List getChildren() {
        return null;
    }
}

public class Composite extends Component {
    private List components = new ArrayList<>();

    public Composite(String name) {
        super(name);
    }

    @Override
    public void operation() {
        System.out.println("组合节点"+name+"的操作");
        //调用所有子节点的操作
        for (Component component : components) {
             component.operation();
        }
    }

    @Override
    public void add(Component c) {
        components.add(c);
    }

    @Override
    public void remove(Component c) {
        components.remove(c);
    }

    @Override
    public Component getChild(int i) {
        return components.get(i);
    }

    @Override
    public List getChildren() {
        return components;
    }
}

public class Leaf extends Component {

    public Leaf(String name) {
        super(name);
    }

    @Override
    public void operation() {
        System.out.println("叶节点"+name+"的操作");
    }
}

public class Client {
    public static void main(String[] args) {
        //创建根节点对象
        Component component = new Composite("component");

        //创建两个组合节点对象
        Component composite1 = new Composite("composite1");
        Component composite2 = new Composite("composite2");

        //将两个组合节点对象添加到根节点
        component.add(composite1);
        component.add(composite2);

        //给第一个组合节点对象添加两个叶子节点
        Component leaf1 = new Leaf("leaf1");
        Component leaf2 = new Leaf("leaf2");
        composite1.add(leaf1);
        composite1.add(leaf2);

        //给第二个组合节点对象添加一个叶子节点和一个组合节点
        Component leaf3 = new Leaf("leaf3");
        Component composite3 = new Composite("composite3");
        composite2.add(leaf3);
        composite2.add(composite3);

        //给第二个组合节点下面的组合节点添加两个叶子节点
        Component leaf4 = new Leaf("leaf4");
        Component leaf5 = new Leaf("leaf5");
        composite3.add(leaf4);
        composite3.add(leaf5);

        //执行所有节点的操作
        component.operation();
    }
}

输出结果：

  上述代码中，在组合节点对象Composite的operation()方法中除了执行自身的操作外，还调用了子节点的operation()方法，这样使得客户端可以透明的遍历所有的节点对象的操作，而不用关心操作的是叶子节点还是组合节点，将它们一视同仁。这看上去有点像二叉树的遍历，不过这里并不是二叉树，每个组合节点可以有若干个子节点，而这些子节点，如果是组合节点，则可以继续拥有子节点，如果是叶子节点，那么就终止了。

  叶子节点和组合节点可以有相同的操作，如上面代码中的operation()方法，但是叶子节点不具备add、remove以及getChild操作，如果你试图在叶子节点上调用这些方法就会抛出不支持的异常。组合节点可以添加子节点，因此组合节点实现了add、remove以及getChild等操作。组合节点持有一个节点的集合，在组合节点的operation()方法中通过遍历调用持有节点的operation()方法，就像是在递归遍历一样。通过这种方式Client客户端可以透明的访问节点对象，你可以在客户端中调用一个组合节点的operation()方法，也可以调用一个叶子节点的operation()方法，也就是说你根本不需要关心调用的是组合节点还是叶子节点，它们都可以进行相同的操作。

菜单的例子

  服务员需要打印菜单，如菜单的名称和价格，但是菜单既可以有子菜单组合，也可以有子菜单项，对于子菜单组合，它的下面又可能会有子菜单项，如饮料菜单和甜点菜单等会包含很多东西，而子菜单项就是一个具体的菜名，不会有子菜单了。现在要打印所有的菜单描述，我们用组合模式来实现这个功能：

实现代码：

/**
 * 抽象菜单组件
 */
public abstract class MenuComponent {

    public void add(MenuComponent menu) {
        throw new UnsupportedOperationException();
    }

    public void remove(MenuComponent menu) {
        throw new UnsupportedOperationException();
    }

    public MenuComponent getChild(int i) {
        throw new UnsupportedOperationException();
    }

    public String getName() {
        throw new UnsupportedOperationException();
    }

    public double getPrice() {
        throw new UnsupportedOperationException();
    }

    public abstract void print();
}

/**
 * 菜单组件
 * 菜单组件有菜单名和子菜单，但没有价格，支持添加、删除和打印等操作
 */
public class Menu extends MenuComponent {
    private List menuList = new ArrayList<>();
    private String name;

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

    @Override
    public void add(MenuComponent menu) {
        menuList.add(menu);
    }

    @Override
    public void remove(MenuComponent menu) {
        menuList.remove(menu);
    }

    @Override
    public MenuComponent getChild(int i) {
        return menuList.get(i);
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void print() {
        System.out.println("--------");
        System.out.println(getName());
        //打印所有子菜单
        for (MenuComponent menu : menuList) {
             menu.print();
        }
        System.out.println("--------");
    }
}

/**
 * 菜单项
 * 菜单项拥有名称和价格，可以打印，但是不支持添加、删除等操作
 */
public class MenuItem extends MenuComponent {
    private String name;
    private double price;

    public MenuItem(String name, double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public double getPrice() {
        return price;
    }

    @Override
    public void print() {
        System.out.println(getName() + " -- " + getPrice());
    }
}

public class Client {
    public static void main(String[] args) {
        Menu menu = new Menu("所有菜单");

        Menu menu1 = new Menu("子菜单1");
        Menu menu2 = new Menu("子菜单2");
        Menu menu3 = new Menu("子菜单3");

        //给所有菜单添加三个子菜单
        menu.add(menu1);
        menu.add(menu2);
        menu.add(menu3);

        //给第二个菜单添加一个菜单项和一个子菜单
        menu2.add(new MenuItem("子菜单2--菜单项", 10.0));
        Menu menu4 = new Menu("子菜单2--子菜单");
        menu2.add(menu4);
        menu4.add(new MenuItem("子菜单2--子菜单--菜单项", 20.0));

        //打印所有菜单
        menu.print();
    }
}

打印结果：

  在抽象菜单MenuComponent组件中，我们将一些操作默认抛出UnsupportedOperationException异常，如果子类支持该操作就重写实现该操作，如果子类不支持该操作，就不用管它。使用组合模式，打印菜单变得非常容易，而且更好的一点是，你现在可以拿任何一个子菜单来打印结果，而不用管它是具体的菜单项还是里面又包含了子菜单。如果不用组合模式，很难想象有一种方法能很方便的将所有的菜单打印出来。

菜单例子中，既要管理层次结构，又要执行打印操作，是否破坏了单一职责？

  严格来说，是的。我们可以这么说，组合模式以单一职责换取透明性。 什么是透明性？通过让组件的接口同时包含一些管理子节点和叶节点的操作，客户就可以将组合和叶节点 一视同仁。也就是说一个元素究竟是组合还是叶节点，对客户是透明的。

  现在，我们在 MenuComponent 类中同时具有两种类型的操作． 因为客户有机会对一个元素做一些没有意义的操作（例如试图把菜单添加到菜单项），所以我们失去 一些‘安会性”。这是设计上的抉择；我们当然也可以采用另一种方向的设计，将责任区分开来放在不同的接口中。这么一来，设计上就比较安全，但我们也因此失去了透明性，客户的代码将必须使用条件语句和 instanceof 操作符处理不同类型的节点。

  所以， 这是一个很典型的折衷案例。尽管我们受到设计原则的指导，但是，我们总是需要观察某原则对我们的设计所造成的影响。有时候，我们会故意做一些看似违反原则的事情。然而，在某些例子中，这是观点的问题。比方说让管理孩子的操作（例如 add ( ）、 remove( ）、 getchild ( ) ）出现在叶节点中，似乎很不恰当，但是换个视角来看，你可以把叶布点视为没有孩子的节点。

组合模式的扩展

子节点可以指向父节点

  组件可以有一个指向父节点的引用，以便在游走时更容易。而且，如果引用某个孩子，你想从树形结构中删除这个孩子，你会需要从父节点中去蒯除它。一旦孩子有了指向父亲的引用，这做起来就很容易。这样做也使得遍历操作可上可下，更加自由灵活。

使用缓存

  有时候，如果这个组合结构很复杂，或者遍历的代价太高，那么实现组合节点的缓存就很有帮助。比方说，如果你要不断地遍历一个组合，而且它的每一个子节点都需要进行某些计算，那你就应该使用缓存来临时保存结果，从而省去遍历的开支。

组合模式应用场景

  这个应用的地方也比较多，比如大多数系统的UI界面的导航菜单一般都是组合模式，再如Android里面的xml布局都是用的组合模式。在选择是否应用组合模式时，要考虑设计上的抉择，到底是要透明性更多一点，还是安全性更多一点，需要做一个平衡。

参考：

• 《设计模式之禅》
• 《Head First设计模式》