go 组合模式

组合模式

允许你将对象组合成树形结构来表现“整体/部分”层次结构。组合能让客户以一致的方式处理个别对象以及对象组合。

模型说明

• Component: 接口描述了树中简单项目和复杂项目所共有的操作。

• Leaf: 是树的基本结构，它不包含子项目。

• 一般情况下，叶节点最终会完成大部分的实际工作，因为它们无法将工作指派给其他部分。

• Container: 又名 “组合 （Composite）”——是包含叶节点或其他容器等子项目的单位。容器不知道其子项目所属的具体类，它只通过通用的组件接口与其子项目交互。

• 容器接收到请求后会将工作分配给自己的子项目，处理中间结果，然后将最终结果返回给客户端。

• Client: 通过组件接口与所有项目交互。因此，客户端能以相同方式与树状结构中的简单或复杂项目交互。

优缺点

1.优点

• 你可以利用多态和递归机制更方便地使用复杂树结构。
• 开闭原则: 无需更改现有代码，你就可以在应用中添加新元素，使其成为对象树的一部分。

2.缺点

• 对于功能差异较大的类，提供公共接口或许会有困难。在特定情况下，你需要过度一般化组件接口，使其变得令人难以理解。

使用场景

• 如果你需要实现树状对象结构，可以使用组合模式。
• 如果你希望客户端代码以相同方式处理简单和复杂元素，可以使用该模式。

参考代码

• 用一个操作系统文件系统的例子来理解组合模式。

// component.go 组件接口
package main

type Component interface {
	search(string)
}

// folder.go 具体组件
package main

import "fmt"

type Folder struct {
	components []Component
	name       string
}

func (f *Folder) search(keyword string) {
	fmt.Printf("Serching recursively for keyword %s in folder %s\n", keyword, f.name)
	for _, composite := range f.components {
		composite.search(keyword)
	}
}

func (f *Folder) add(c Component) {
	f.components = append(f.components, c)
}

// file.go 叶子组件
package main

import "fmt"

type File struct {
	name string
}

func (f *File) search(keyword string) {
	fmt.Printf("Searching for keyword %s in file %s\n", keyword, f.name)
}

func (f *File) getName() string {
	return f.name
}

// main.go 客户端
package main

func main() {
	file1 := &File{name: "File1"}
	file2 := &File{name: "File2"}
	file3 := &File{name: "File3"}

	folder1 := &Folder{
		name: "Folder1",
	}

	folder1.add(file1)

	folder2 := &Folder{
		name: "Folder2",
	}
	folder2.add(file2)
	folder2.add(file3)
	folder2.add(folder1)

	folder2.search("rose")
}

output:

Serching recursively for keyword rose in folder Folder2
Searching for keyword rose in file File2
Searching for keyword rose in file File3
Serching recursively for keyword rose in folder Folder1
Searching for keyword rose in file File1