11. 设计模式之组合模式

前言

组合模式又叫整体-部分模式，它是一种将对象组合成树状层次结构的模式，用来表示整体-部分的关系，使用户对单个对象和组合对象具有一致的访问性，属于结构性设计模式。

在组合模式中，整个树形结构中的对象都属于同一种类型。带来的好处是用户不需要辨识是树枝节点还是树叶节点，可以进行直接操作，给用户使用带来了极大的便利。

本节，就组合模式，展开详细介绍。

1. 组合模式中的几种角色

1.1 抽象构件（Component）角色：

它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口；在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构件完成。（总的抽象类或接口，定义一些通用的方法，比如新增、删除）

1.2 树叶构件（Leaf）角色：

是组合中的叶节点对象，它没有子节点，用于继承或实现抽象构件。

1.3 树枝构件（Composite）角色 / 中间构件：

是组合中的分支节点对象，它有子节点，用于继承和实现抽象构件。它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法。

2. 代码示例

2.1 定义顶层接口

package com.wanlong.design_pattern.structure.combine;

import java.util.List;

public interface IComponent {
    void add(IComponent component);

    void remove(IComponent component);

    List<IComponent> getChild();

    void operation();
}

2.2 定义抽象构件角色

package com.wanlong.design_pattern.structure.combine;

import java.util.List;

/**
 * @author wanlong
 * @version 1.0
 * @description: 安全组合模式抽象角色
 * @date 2022/9/19 14:04
 */

public abstract class AbstractComponent implements IComponent {

    @Override
    public void add(IComponent component) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void remove(IComponent component) {
        throw new UnsupportedOperationException();
    }

    @Override
    public List<IComponent> getChild() {
        return null;
    }
}

2.3 定义树枝构件

package com.wanlong.design_pattern.structure.combine;

import java.util.ArrayList;
import java.util.List;

/**
 * @author wanlong
 * @version 1.0
 * @description: 定义树枝构件
 * @date 2022/9/19 14:10
 */

public class Composite extends AbstractComponent {
    private String name;

    private List<IComponent> child = new ArrayList<IComponent>();

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

    @Override
    public void add(IComponent component) {
        this.child.add(component);
    }

    @Override
    public void remove(IComponent component) {
        this.child.remove(component);
    }

    @Override
    public List<IComponent> getChild() {
        return this.child;
    }

    @Override
    public void operation() {
        System.out.println("树枝节点：" + name);
        for (IComponent iComponent : child) {
            iComponent.operation();
        }
    }
}

2.4 定义树叶构件

package com.wanlong.design_pattern.structure.combine;

/**
 * @author wanlong
 * @version 1.0
 * @description: 树叶角色
 * @date 2022/9/19 14:09
 */

public class Leaf extends AbstractComponent {
    private String name;

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

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

}

2.5 客户端调用

@Test
public void testCombine() {
    IComponent composite = new Composite("根节点");

    IComponent composite1 = new Composite("树枝1");
    IComponent leaf1 = new Leaf("叶子节点1");
    IComponent leaf2 = new Leaf("叶子节点2");
    IComponent leaf3 = new Leaf("叶子节点3");
    IComponent leaf4 = new Leaf("叶子节点4");
    composite1.add(leaf1);
    composite1.add(leaf2);
    composite1.add(leaf3);
    composite1.add(leaf4);
    composite.add(composite1);

    IComponent composite2 = new Composite("树枝2");
    IComponent leaf5 = new Leaf("叶子节点5");
    IComponent leaf6 = new Leaf("叶子节点6");
    IComponent leaf7 = new Leaf("叶子节点7");
    composite2.add(leaf5);
    composite2.add(leaf6);
    composite2.add(leaf7);
    composite.add(composite2);
    System.out.println("========整颗树遍历=======");
    composite.operation();
    System.out.println("=====树枝1 遍历=====");
    composite1.operation();
    System.out.println("=====--树枝2遍历-----=====");
    composite2.operation();
}

代码运行结果：

========整颗树遍历=======
树枝节点：根节点
树枝节点：树枝1
叶子节点：叶子节点1
叶子节点：叶子节点2
叶子节点：叶子节点3
叶子节点：叶子节点4
树枝节点：树枝2
叶子节点：叶子节点5
叶子节点：叶子节点6
叶子节点：叶子节点7
=====树枝1 遍历=====
树枝节点：树枝1
叶子节点：叶子节点1
叶子节点：叶子节点2
叶子节点：叶子节点3
叶子节点：叶子节点4
=====--树枝2遍历-----=====
树枝节点：树枝2
叶子节点：叶子节点5
叶子节点：叶子节点6
叶子节点：叶子节点7

3. 总结

3.1 优缺点

3.1.1 优点

1. 组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码
2. 更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足开闭原则；

3.1.2 缺点：

1. 设计较复杂，客户端需要花更多时间理清类之间的层次关系；
2. 不容易限制容器中的构件
3. 不容易用继承的方法来增加构件的新功能
4. 在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。

3.2 常用场景

1. spring中的CompositeCacheManager使用
2. 希望客户端可以忽略组合对象与单个对象的差异时
3. 处理一个树型结构

以上，本人菜鸟一枚，如有错误，请不吝指正。