设计模式GOF23--组合模式

发表于 | 分类于

使用组合模式的场景

  • 把部分和整体的关系用树形结构来表示，从而使客户端可以使用统一的方式处理部分对象和整体对象。

组合模式的核心

  • 抽象构建（Component）角色：定义了叶子和容器构件的共同点
  • 叶子（Leaf）构件角色：无子节点
  • 容器（Composite）构件角色：有容器特征，可以包含子节点
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 * 抽象组件
 */
public interface Component {
    void operation();
}

/**
 * 叶子组件
 */
interface Leaf extends Component{

}

/**
 * 容器组件
 */
interface Composite extends Component{
    void add(Component c);
    void remove(Component c);
    Component getChild(int index);
}

组合模式工作流程分析

  • 组合模式为处理树形结构提供了完美的解决方案，描述了如何将容器和叶子进行递归组合，使得用户在使用时可以一致性的对待容器和叶子。
  • 当容器对象的指定方法被调用时，将遍历整个树形结构，寻找也包含这个方法的成员，并调用执行。其中，使用了递归的机制对整个结构进行处理。

使用组合模式，模拟杀毒软件架构设计

下面，我们使用组合模式，来模拟杀毒过程。我们先定义抽象组件，定义其共同点。其次，我们定义叶子节点（图片文件、文本文件、视频文件）。之后，我们定义容器组件（文件夹）。容器组件中，我们使用递归方法进行查杀，直到叶子节点查杀完毕。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
/**
 * 抽象组件
 */
public interface AbstractFile {
    void killVirus();
}

/**
 * 叶子组件  图片文件
 */
class ImageFile implements AbstractFile{
    private String name;
    public ImageFile(String name) {
        super();
        this.name = name;
    }
    @Override
    public void killVirus() {
        System.out.println("--图片文件："+name+"进行查杀");
    }
}

/**
 * 叶子组件  文本文件
 */
class TextFile implements AbstractFile{
    private String name;
    public TextFile(String name) {
        super();
        this.name = name;
    }
    @Override
    public void killVirus() {
        System.out.println("--文本文件："+name+"进行查杀");
    }
}

/**
 * 叶子组件  视频文件
 */
class VideoFile implements AbstractFile{
    private String name;
    public VideoFile(String name) {
        super();
        this.name = name;
    }
    @Override
    public void killVirus() {
        System.out.println("--视频文件："+name+"进行查杀");
    }
}

/**
 * 容器组件
 */
class Folder implements AbstractFile{
    private String name;
    //定义容器，用来存放本容器构建下的子节点
    private List<AbstractFile> list = new ArrayList<>();
    public Folder(String name) {
        this.name = name;
    }
    public void add(AbstractFile abstractFile){
        list.add(abstractFile);
    }
    public void romove(AbstractFile abstractFile){
        list.remove(abstractFile);
    }
    public AbstractFile getChile(int index){
        return list.get(index);
    }
    @Override
    public void killVirus() {
        System.out.println("==文件夹："+name+"进行查杀");
        for (AbstractFile file: list) {
            file.killVirus();
        }
    }
}

调用执行：模拟文件夹存放模式，在文件夹我的收藏里存放一个图像，一个文本，一个电影文件夹，在电影文件夹中，我们存放两个视频文件。模拟查杀模式。我们只需调用我的收藏进行查杀，其下包括其都将进行查杀。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class Client {
    public static void main(String[] args) {
        AbstractFile f2,f3,f4,f5,f6;
        Folder f1 = new Folder("我的收藏");
        f2 = new ImageFile("头像.jpg");
        f3 = new TextFile("Hello.txt");

        f1.add(f2);
        f1.add(f3);
       // f1.killVirus();
        Folder f11 = new Folder("电影");
        f4 = new VideoFile("笑傲江湖.avi");
        f5 = new VideoFile("神雕侠侣.avi");

        f11.add(f4);
        f11.add(f5);
        f1.add(f11);
        f1.killVirus();
    }
}
结果：
==文件夹：我的收藏进行查杀
--图片文件：头像.jpg进行查杀
--文本文件：Hello.txt进行查杀
==文件夹：电影进行查杀
--视频文件：笑傲江湖.avi进行查杀
--视频文件：神雕侠侣.avi进行查杀

开发中的应用场景：

  • 操作系统的资源管理器
  • GUI中的容器层次图
  • XML文件解析
  • OA系统中，组织结构的处理
  • Junit单元测试框架
    • 底层设计就是典型的组合模式，TestCase（叶子）、TestUnit(容器)、Test接口（抽象）
注：该博文为学习总结，视频来源为高淇java300集