合成模式

模式介绍

合成（Composit）模式属于对象的结构模式，有时又叫做部分-整体模式，合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式可以使客户端将单纯元素与复合元素同等看待。

工作原理

合成模式把部分与整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由它们复合而成的合成对象同等看待。

可以看出上面的类图结构涉及到三个角色：

• 抽象构件（Component）角色：这是一个抽象角色，它给参加组合的对象规定一个接口。这个角色给出共有的接口及其默认行为。
• 树叶构件（Leaf）角色：代表参加组合的树叶对象。一个树叶没有下级的子对象。定义出参加组合的原始对象的行为。
• 树枝构件（Composite）角色：代表参加组合的由子对象的对象，并给出树枝构件对象的行为。

可以看出，Composite 类型的对象含有其他的 Component 类型的对象。换言之，Composite 类型的对象可以含有其他的树枝（Composite）类型或树叶（Leaf）类型的对象。

合成模式的实现根据所实现接口的区别分为两种形式，分别是安全式和透明式。

合成模式可以不提供父对象的管理方法，但是合成模式必须在合适的地方提供子对象的管理方法。在什么地方声明子对象的管理方法，诸如 add()、remove() 以及 getChild() 等。

透明式

在 Component 里面声明所有的用来管理子类对象的方法，包括 add()、remove() 以及 getChild() 方法。这样做的好处是所有的构件类都有相同的接口。在客户端看来，树叶类对象与合成类对象的区别起码在接口层次上消失了，客户端可以同等地对待所有的对象。这就是透明式的合成模式。

这个选择的缺点是不够安全，因为树叶类对象和合成类对象在本质上是有区别的。树叶类对象不可能有下一层次的对象，因此 add()、remove() 以及 getChild() 方法没有意义，但是在编译时期不会出错，而只会在运行期才会出错。

模式图解

这种形式涉及到三个角色：

• 抽象构件（Component）角色：这是一个抽象角色，它给参加组合的对象规定一个接口，规范共有的接口及默认行为。这个接口可以用来管理所有的子对象，要提供一个接口以规范取得和管理下层组件的接口，包括 add()、remove() 以及 getChild() 之类的方法。
• 树叶构件（Leaf）角色：代表参加组合的树叶对象，定义出参加组合的原始对象的行为。树叶类会给出 add()、remove() 以及 getChild() 之类的用来管理子类对象的方法的平庸实现。
• 树枝构件（Composite）角色：代表参加组合的子对象的对象，定义出这样的对象的行为。

示例代码

抽象构件角色

public interface Component {

    /**
     * 某个商业方法
     */
    void sampleOperation();

    /**
     * 返还自己的实例
     *
     * @return
     */
    Composite getComposite();

    /**
     * 聚集管理方法，增加一个子构件对象
     *
     * @param component
     */
    void add(Component component);

    /**
     * 聚集管理方法，删除一个子构件对象
     *
     * @param component
     */
    void remove(Component component);
}

树枝构件角色

public class Composite implements Component {

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

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

    @Override
    public Composite getComposite() {
        return this;
    }

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

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

树叶构件角色

public class Leaf implements Component {

    @Override
    public void sampleOperation() {
        System.out.println("leaf");
    }

    @Override
    public Composite getComposite() {
        return null;
    }

    @Override
    public void add(Component component) {

    }

    @Override
    public void remove(Component component) {

    }
}

安全式

在 Composite 类里面声明所有的用来管理子类对象的方法。这样的做法是安全的做法，因为树叶类型的对象根本就没有管理子类对象的方法，因此，如果客户但对树叶类对象使用这些方法时，程序会在编译时期出错。编译通不过，就不会出现运行时错误。

这个选择的缺点是不够透明，因为树叶类和合成类将具有不同的接口。

模式图解

这种形式涉及到三个角色：

• 抽象构件（Component）角色：这是一个抽象角色，它给参加组合的对象定义出公共的接口及其默认行为，可以用来管理所有的子对象。在安全式的合成模式里，构件角色并不定义出管理子对象的方法，这一定义由树枝构件对象给出。
• 树叶构件（Leaf）角色：树叶对象是没有下级子对象的对象，定义出参加组合的原始对象的行为。
• 树枝构件（Composite）角色：代表参加组合的有下级子对象的对象。树枝构件类给出所有的管理子对象的方法，如 add()、remove() 以及 components() 的声明。

示例代码

抽象构件角色

public interface Component {

    /**
     * 某个商业方法
     */
    void sampleOperation();

    /**
     * 返还自己的实例
     *
     * @return
     */
    Composite getComposite();
}

树枝构件角色

public class Composite implements Component {

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

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

    @Override
    public Composite getComposite() {
        return this;
    }

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

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

树叶构件角色

public class Leaf implements Component{
    @Override
    public void sampleOperation() {
        System.out.println("leaf");
    }

    @Override
    public Composite getComposite() {
        return null;
    }
}

融合安全与透明

抽象构件角色

public abstract class Component {

    /**
     * 某个商业方法
     */
    public abstract void sampleOperation();

    /**
     * 返还自己的实例
     *
     * @return
     */
    public abstract Composite getComposite();

    /**
     * 聚集管理方法，增加一个子构件对象
     *
     * @param component
     */
    public void add(Component component) {
        throw new UnsupportedOperationException();
    }

    /**
     * 聚集管理方法，删除一个子构件对象
     *
     * @param component
     */
    public void remove(Component component) {
        throw new UnsupportedOperationException();
    }
}

树枝构件角色

public class Composite extends Component {

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

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

    @Override
    public Composite getComposite() {
        return this;
    }

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

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

树叶构件角色

public class Leaf extends Component {

    @Override
    public void sampleOperation() {
        System.out.println("leaf");
    }

    @Override
    public Composite getComposite() {
        return null;
    }
}

使用场景

1. 文件系统：文件和目录可以组合成树形结构，目录可以包含文件或其他目录。
2. 组织结构：公司中的部门和员工可以组合成层次结构。
3. JDK中的HashMap：
   • Map是一个抽象的构建，类似Component。
   • HashMap是一个中间的构建，类似Composite，实现了put和putAll等方法。
   • Node是HashMap的静态内部类，类似Leaf，没有put和putAll这些方法。
   • 例如，创建两个HashMap并使用putAll方法将一个映射复制到另一个映射中，展示了合成模式的应用。

与其它模式的关联

与合成模式有关联的模式有命令模式、装饰模式、迭代模式、责任链模式和享元模式。

命令模式

合成模式常常可以应用到命令类的合成上，由几个具体命令类合成宏命令类。命令模式的简略类图如下：

装饰模式

用继承关系为装饰模式增加新的行为很困难。如果建立一个抽象构件类的子类，当然可以把新的行为添加到抽象子类中去，但是这样并不能影响到已有的合成类和树叶类的行为。为了能将新的行为添加到已有的合成类和树叶类中去，就必须建立符合类和树叶类的子类，这就意味着要修改或复制所有的已有的类。

如果建立合成类的子类，把新行为添加到它里面的话，为了保持多态性，就只好为树叶类也建立子类，并把新行为添加到里面。最后，也必须对抽象构件类这样做。装饰模式的简略类图如下图所示：

迭代模式

合成模式常常用迭代子模式遍历子类对象，迭代模式的简略类图如下图所示：

责任链模式

一个责任链模式往往应用到一个树结构上，因为责任链模式会使用到合成模式、迭代模式和装饰模式。责任链模式的类图如下图所示：

享元模式

严格来说，享元模式并不是一个单纯的模式，而是一个由数个模式组合而成的复合模式。享元模式的工厂角色是一个工厂方法模式，工厂方法的内部记录了所创建的产品实例，并循环使用这些实例。

复合享元对象是合成模式的应用，抽象享元角色就是复合构件角色，而具体享元角色就是具体构件角色。复合享元是树枝构件，而单纯享元是树叶构件。享元模式的类图如下图所示：