组合模式的核心是将单个对象和组合对象统一对待，让客户端可以一致地处理树形结构中的所有节点，无需区分叶子节点和容器节点。在Golang中，我们可以通过接口定义统一的行为，再分别实现叶子节点和组合节点的逻辑，最终构建出可灵活操作的对象树。
组合模式的核心角色
在Golang实现组合模式时，通常会包含以下几个核心角色：
- 组件接口：定义所有节点（叶子节点和组合节点）的统一行为，比如获取名称、添加子节点、执行操作等。
- 叶子节点：实现组件接口，代表树形结构中的最末端节点，没有子节点，通常只实现自身的操作逻辑。
- 组合节点：也实现组件接口，内部维护一个子节点列表，既可以执行自身的操作，也可以递归调用子节点的操作。
- 客户端：通过组件接口操作整个对象树，无需关心当前操作的是叶子节点还是组合节点。
基础组件接口定义
首先我们定义一个统一的组件接口，所有节点都需要实现这个接口的方法：
// Component 定义组合模式的统一组件接口
type Component interface {
// GetName 获取节点名称
GetName() string
// Add 添加子节点，叶子节点可以不实现该方法，或者返回错误
Add(c Component) error
// Remove 移除子节点，叶子节点可以不实现该方法，或者返回错误
Remove(c Component) error
// GetChildren 获取所有子节点，叶子节点返回空列表
GetChildren() []Component
// Operation 执行节点的具体操作
Operation() string
}叶子节点实现
叶子节点是最基础的节点，没有子节点，只需要实现自身的操作逻辑即可：
// Leaf 叶子节点结构体
type Leaf struct {
name string
}
// NewLeaf 创建新的叶子节点
func NewLeaf(name string) *Leaf {
return &Leaf{name: name}
}
// GetName 实现Component接口的GetName方法
func (l *Leaf) GetName() string {
return l.name
}
// Add 叶子节点不支持添加子节点，返回错误
func (l *Leaf) Add(c Component) error {
return fmt.Errorf("叶子节点 %s 不支持添加子节点", l.name)
}
// Remove 叶子节点不支持移除子节点，返回错误
func (l *Leaf) Remove(c Component) error {
return fmt.Errorf("叶子节点 %s 不支持移除子节点", l.name)
}
// GetChildren 叶子节点没有子节点，返回空切片
func (l *Leaf) GetChildren() []Component {
return []Component{}
}
// Operation 叶子节点的具体操作逻辑
func (l *Leaf) Operation() string {
return fmt.Sprintf("叶子节点 %s 执行了操作", l.name)
}组合节点实现
组合节点需要维护子节点列表，同时实现添加、移除子节点以及递归执行操作的逻辑：
// Composite 组合节点结构体
type Composite struct {
name string
children []Component
}
// NewComposite 创建新的组合节点
func NewComposite(name string) *Composite {
return &Composite{
name: name,
children: make([]Component, 0),
}
}
// GetName 实现Component接口的GetName方法
func (c *Composite) GetName() string {
return c.name
}
// Add 向组合节点添加子节点
func (c *Composite) Add(comp Component) error {
c.children = append(c.children, comp)
return nil
}
// Remove 从组合节点移除指定的子节点
func (c *Composite) Remove(comp Component) error {
for i, child := range c.children {
if child.GetName() == comp.GetName() {
c.children = append(c.children[:i], c.children[i+1:]...)
return nil
}
}
return fmt.Errorf("子节点 %s 不存在于组合节点 %s 中", comp.GetName(), c.name)
}
// GetChildren 获取组合节点的所有子节点
func (c *Composite) GetChildren() []Component {
return c.children
}
// Operation 组合节点的操作：先执行自身操作，再递归执行所有子节点的操作
func (c *Composite) Operation() string {
result := fmt.Sprintf("组合节点 %s 执行了操作\n", c.name)
for _, child := range c.children {
result += child.Operation() + "\n"
}
return result
}完整使用示例
下面我们构建一个简单的对象树，演示如何使用上述实现来管理对象树：
package main
import "fmt"
func main() {
// 创建叶子节点
leaf1 := NewLeaf("叶子节点1")
leaf2 := NewLeaf("叶子节点2")
leaf3 := NewLeaf("叶子节点3")
// 创建组合节点
composite1 := NewComposite("组合节点1")
composite2 := NewComposite("组合节点2")
// 构建对象树结构
// composite2 包含 leaf2 和 leaf3
composite2.Add(leaf2)
composite2.Add(leaf3)
// composite1 包含 leaf1 和 composite2
composite1.Add(leaf1)
composite1.Add(composite2)
// 统一调用操作，无需区分叶子节点和组合节点
fmt.Println("执行整个对象树的操作：")
fmt.Println(composite1.Operation())
// 移除子节点演示
composite2.Remove(leaf2)
fmt.Println("移除叶子节点2后，执行对象树操作：")
fmt.Println(composite1.Operation())
}注意事项
在实际使用Golang实现组合模式管理对象树时，需要注意以下几点：
- 如果叶子节点不需要支持添加、移除子节点的操作，可以在接口定义时将这些方法设为可选，或者在叶子节点实现时返回明确的错误，避免客户端误调用。
- 组合节点的子节点列表如果是并发场景使用，需要添加对应的并发控制逻辑，比如使用互斥锁保护子节点的增删操作。
- 递归操作对象树时，需要注意树形结构的深度，避免出现栈溢出的情况，如果树的层级过深，可以考虑改用迭代的方式实现操作逻辑。
- 组件接口的方法定义需要根据实际业务场景调整，不需要完全照搬示例中的方法，只需要保证叶子节点和组合节点有统一的行为入口即可。
适用场景
这种实现方式适合所有需要管理树形对象结构的场景，比如：
- 文件系统的目录和文件管理，目录是组合节点，文件是叶子节点。
- 企业组织架构管理，部门是组合节点，员工是叶子节点。
- 前端菜单配置管理，父菜单是组合节点，子菜单或者功能项是叶子节点。
- 规则引擎的层级规则管理，规则组是组合节点，单个规则是叶子节点。