Java设计模式：组合模式之透明与安全的两种实现

文摘科技 2024-11-12 20:34 广东

一、概念

组合模式（Composite Pattern）是一种结构型设计模式，它将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得客户端对单个对象和复合对象的使用具有一致性。组合模式常用于构建复杂的嵌套结构，如文件目录、组织结构等。

二、组合模式的基本结构

组合模式包含以下角色：

抽象组件（Component）：定义了组合中所有对象的共同接口，包括一些管理和访问子组件的方法。它可以是接口或抽象类。通常至少包含添加、删除和获取子组件的方法，以及一个执行操作的方法。
具体组件（Leaf）：实现了抽象组件接口，但不包含子组件。这是树形结构中的叶子节点，没有子节点。叶子节点通常实现抽象组件中的操作，但不实现子组件管理的方法（或抛出异常或空实现）。
复合组件（Composite）：也是抽象组件的子类，用于组合子组件。它实现了抽象组件中定义的管理和访问子组件的方法，并存储了子组件的引用。复合组件可以根据需要添加、删除和管理子组件。复合组件也实现了抽象组件中的操作，通常是通过递归调用其子组件的操作来实现的。

三、组合模式优缺点

3.1 优点

客户端使用简单：客户端可以统一地使用组合结构或单个对象，无需关心它们的具体差异。
良好的扩展性：可以较容易地在组合体内加入新的对象，而客户端代码不需要修改。
清晰的层次结构：提供了清晰的树形结构来表示对象的层次关系，方便管理和访问。

3.2 缺点

设计复杂度增加：由于需要定义抽象组件、具体组件和复合组件，设计变得更加复杂。
限制类型：不容易在组合中限制构件的类型。
功能增加困难：不容易通过继承为构件增加新功能，因为继承会导致与组合模式的设计原则相冲突。

三、使用场景

当你想表示对象的部分以及整体层次时，如树形菜单、文件/文件夹结构等。
当你希望客户端忽略组合对象与单个对象的不同，统一地使用它们时。
当你需要在组合体内以递归方式执行一些操作时，如遍历树形结构。

四、组合模式的实现方式

Java实现组合模式时，通常有两种主要的方法：透明组合模式和安全组合模式。这两种实现方式在处理子组件的管理上有所不同。

4.1 透明组合模式

透明组合模式中，抽象组件（Component）会声明所有用于管理子组件的方法，如添加（add）、移除（remove）和获取子组件（getChild）等。因此，对于客户端来说，无论是叶子节点还是复合节点，它们都具备相同的接口。但是，叶子节点中的这些方法可能没有任何实际操作，甚至抛出异常。

// 透明组合模式的抽象组件
interface Component {
    void operation();
    void add(Component component);
    void remove(Component component);
    Component getChild(int index);
}

// 叶子组件
class Leaf implements Component {
    private String name;

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

    @Override
    public void operation() {
        // 实现具体操作
    }

    @Override
    public void add(Component component) {
        // 对叶子节点，这个方法没有意义
        throw new UnsupportedOperationException("Cannot add children to leaf nodes.");
    }

    @Override
    public void remove(Component component) {
        throw new UnsupportedOperationException("Cannot remove children from leaf nodes.");
    }

    @Override
    public Component getChild(int index) {
        return null;
    }
}

// 复合组件
class Composite implements Component {
    private List<Component> children = new ArrayList<>();

    @Override
    public void operation() {
        // 实现具体操作，并且可能会递归调用子组件的操作
    }

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

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

    @Override
    public Component getChild(int index) {
        return children.get(index);
    }
}

客户端可以调用叶子节点上的add()和remove()方法，所以这种方式被认为不是类型安全的。

4.2 安全组合模式

安全组合模式中，抽象组件只声明了共同的方法（通常是业务方法），不声明管理子组件的方法。这些方法被单独定义在复合组件中。这样，叶子节点就不会拥有这些不相关的方法，客户端在使用时也无法调用这些方法，因此是类型安全的。

// 安全组合模式的抽象组件
interface Component {
    void operation();
}

// 叶子组件
class Leaf implements Component {
    private String name;

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

    @Override
    public void operation() {
        // 实现叶子节点的具体操作
    }
}

// 复合组件
class Composite implements Component {
    private List<Component> children = new ArrayList<>();

    @Override
    public void operation() {
        // 实现复合组件的具体操作，可能包含对子组件的调用
        for (Component child : children) {
            child.operation();
        }
    }

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

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

    public Component getChild(int index) {
        return children.get(index);
    }
}