17370845950

Go中的组合模式是通过接口统一节点行为、用值/指针组合实现树形结构多态，而非结构嵌套；区别在于组合模式要求所有节点实现同一接口（如Component），而嵌套结构（如Folder含[]Folder）无行为契约，无法统一操作。

什么是 Go 中的组合模式，它和嵌套结构有什么区别

Go 没有类继承，所以“组合模式”不是靠 extends 或 interface{} 实现的抽象父类那一套，而是靠接口 + 值/指针组合来模拟树形节点统一行为。关键在于：所有节点（叶子和容器）都实现同一个接口，让调用方无需判断类型就能递归操作。

容易混淆的是把 struct 嵌套当成组合模式——比如 type Folder struct { Children []Folder } 这只是数据结构嵌套，没提供统一行为契约，无法实现“对任意节点调用 Print() 就自动展开子树”这种能力。

• 真正组合模式必须定义一个接口（如 Component），并让 Leaf 和 Composite 都实现它
• 所有操作方法（Add、Remove、Operation）都在接口中声明，由具体类型各自实现逻辑
• Composite 类型内部持有 []Component，而不是具体类型切片，这是多态的关键

如何定义 Component 接口与两个具体类型

接口要精简，只包含树形结构真正共用的行为。常见错误是把 Add 和 Remove 强加给 Leaf，结果只能返回错误或 panic —— 更合理的方式是让接口只声明可安全通用的方法（如 GetName()、GetSize()、Accept(Visitor)），而增删操作放在 Composite 上单独提供。

type Component interface {
	GetName() string
	GetSize() int64
	Accept(v Visitor)
}

type Leaf struct {
	name string
	size int64
}

func (l *Leaf) GetName() string { return l.name }
func (l *Leaf) GetSize() int64  { return l.size }
func (l *Leaf) Accept(v Visitor) { v.VisitLeaf(l) }

type Composite struct {
	name     string
	children []Component
}

func (c *Composite) GetName() string { return c.name }
func (c *Composite) GetSize() int64 {
	total := int64(0)
	for _, ch := range c.children {
		total += ch.GetSize()
	}
	return total
}
func (c *Composite) Accept(v Visitor) { v.VisitComposite(c) }

func (c *Composite) Add(child Component) {
	c.children = append(c.children, child)
}

func (c *Composite) GetChildren() []Component {
	return c.children
}

为什么需要 Visitor 模式配合组合模式

纯组合接口如果只暴露 GetName() 和 GetSize()，就很难做差异化遍历（比如“只统计文件数量，跳过目录大小”或“生成带缩进的树状文本”）。这时直接在 Component 加一堆方法会让接口膨胀，且违背单一职责。

Visitor 是解耦的好办法：把不同遍历逻辑抽成独立结构体，通过 Accept 方法触发双分派，让每个节点自己决定怎么被访问。

• Visitor 是个接口，定义 VisitLeaf 和 VisitComposite 方法
• 每个具体 Visitor（如 TreePrinter、SizeCounter）实现该接口，封装自己的逻辑
• 节点的 Accept 方法里调用 visitor 对应的 Visit 方法，不关心 visitor 内部怎么处理

type Visitor interface {
	VisitLeaf(*Leaf)
	VisitComposite(*Composite)
}

type TreePrinter struct {
	indent string
}

func (t *TreePrinter) VisitLeaf(l *Leaf) {
	fmt.Printf("%s? %s (%d bytes)\n", t.indent, l.GetName(), l.GetSize())
}

func (t *TreePrinter) VisitComposite(c *Composite) {
	fmt.Printf("%s? %s\n", t.indent, c.GetName())
	newIndent := t.indent + "  "
	for _, ch := range c.GetChildren() {
		ch.Accept(&TreePrinter{indent: newIndent})
	}
}

实际使用时最容易踩的三个坑

组合模式在 Go 里写起来简洁，但运行时容易出隐性问题：

• 忘记用指针接收方法：如果 Composite.Add 是值接收，append 修改的是副本，原结构的

  

  children 不会变 —— 必须用 func (c *Composite) Add(...)
• 递归调用没终止条件：比如 Composite.Accept 里又调用子节点 Accept，但某个子节点被误设为自身，就会无限递归栈溢出
• 混用值和指针类型导致接口实现丢失：定义 var c Component = Leaf{"a", 100} 没问题，但 var c Component = &Leaf{"a", 100} 是另一个类型；若接口方法是值接收，两者都满足；若用了指针接收，只有后者能赋值给 Component

最常被忽略的是：组合模式本身不解决线程安全。如果多个 goroutine 同时调用 Composite.Add 或遍历，需自行加锁 —— sync.RWMutex 放在 Composite 结构体里是最直接的做法。