组合模式通过统一接口处理文件与文件夹，支持权限控制、避免循环引用及性能优化。
组合模式在Golang中，特别适合处理像文件系统这种树形结构，它允许你以统一的方式处理单个对象和对象组合。核心思想是把单个文件和文件夹都看作是“组件”，文件夹可以包含其他组件（文件或文件夹），而客户端代码不需要区分它们，统一调用。
实现的关键在于定义一个接口，让文件和文件夹都实现这个接口。然后，文件夹类维护一个组件列表，负责管理子组件。
package main
import "fmt"
// Component 接口
type Component interface {
GetName() string
GetSize() int
Search(string)
Add(Component)
Remove(Component)
}
// File 文件结构体
type File struct {
name string
size int
}
func (f *File) GetName() string {
return f.name
}
func (f *File) GetSize() int {
return f.size
}
func (f *File) Search(keyword string) {
if f.name == keyword {
fmt.Printf("File found: %s\n", f.name)
}
}
func (f *File) Add(Component) {
// 文件不能添加子组件，空实现或者返回错误
}
func (f *File) Remove(Component) {
// 文件不能移除子组件，空实现或者返回错误
}
// Directory 文件夹结构体
type Directory struct {
name string
children []Component
}
func (d *Directory) GetName() string {
return d.name
}
func (d *Directory) GetSize() int {
size := 0
for _, child := range d.children {
size += child.GetSize()
}
return size
}
func (d *Directory) Search(keyword string) {
if d.name == keyword {
fmt.Printf("Directory found: %s\n", d.name)
}
for _, child := range d.children {
child.Search(keyword)
}
}
func (d *Directory) Add(c Component) {
d.children = append(d.children, c)
}
func (d *Directory) Remove(c Component) {
for i, child := range d.children {
if child.GetName() == c.GetName() {
d.children = append(d.children[:i], d.children[i+1:]...)
return
}
}
}
func main() {
root := &Directory{name: "Root"}
dir1 := &Directory{name: "Dir1"}
file1 := &File{name: "File1.txt", size: 1024}
file2 := &File{name: "File2.txt", size: 2048}
root.Add(dir1)
root.Add(file1)
dir1.Add(file2)
fmt.Printf("Total size of Root: %d\n", root.GetSize()) // 输出: Total size of Root: 3072
root.Search("File2.txt") // 输出: File found: File2.txt
}如何优雅地处理文件或目录的权限问题？
在组合模式中，权限控制可以加到
Component接口层面。比如，可以添加一个
CanRead()和
CanWrite()方法。 然后在
File和
Directory的实现中，根据用户的角色和权限进行判断。 如果用户没有权限，则可以返回错误或者直接阻止操作。 另一种方式是引入装饰器模式，对组件进行包装，增加权限校验的逻辑。
如何避免循环引用导致堆栈溢出？
循环引用在树形结构中是个常见问题。如果目录A包含目录B，而目录B又包含目录A，那么在遍历时就会陷入无限循环。 解决方法是使用一个
visited集合来记录已经访问过的组件。 在遍历之前，先检查组件是否在
visited集合中，如果在，则跳过该组件。 这需要在
Directory的
GetSize()和
Search()方法中加入判断逻辑。 另外，可以考虑限制树的深度，超过一定深度就停止遍历。
立即学习“go语言免费学习笔记（深入）”；
如何优化组合模式的性能，避免遍历整个树？
组合模式在处理大型文件系统时，性能会成为瓶颈。 每次调用
GetSize()都可能需要遍历整个树。 为了优化性能，可以采用以下策略：
-
缓存: 在
Directory
中缓存子树的大小。 当子组件的大小发生变化时，更新缓存。 这样，在调用GetSize()
时，可以直接返回缓存的值，而不需要重新遍历。 - 惰性加载: 只有在需要时才加载子组件。 可以使用代理模式来实现惰性加载。 当第一次访问子组件时，才从磁盘加载。
- 并行处理: 可以使用 Goroutine 并行处理子树。 将大目录分割成小目录，每个 Goroutine 处理一个目录。 最后，将结果汇总。
- 使用迭代器模式： 通过迭代器模式，可以实现对树形结构的非递归遍历，避免深度过大导致的栈溢出问题，同时也可以在遍历过程中进行过滤和处理，提高效率。
// 迭代器接口
type Iterator interface {
HasNext() bool
Next() Component
}
// 具体迭代器，用于遍历目录
type DirectoryIterator struct {
directory *Directory
index int
}
func (di *DirectoryIterator) HasNext() bool {
return di.index < len(di.directory.children)
}
func (di *DirectoryIterator) Next() Component {
if di.HasNext() {
component := di.directory.children[di.index]
di.index++
return component
}
return nil
}
// 在Directory结构体中添加创建迭代器的方法
func (d *Directory) CreateIterator() Iterator {
return &DirectoryIterator{directory: d, index: 0}
}
// 使用迭代器进行遍历
func main() {
root := &Directory{name: "Root"}
dir1 := &Directory{name: "Dir1"}
file1 := &File{name: "File1.txt", size: 1024}
file2 := &File{name: "File2.txt", size: 2048}
root.Add(dir1)
root.Add(file1)
dir1.Add(file2)
iterator := root.CreateIterator()
for iterator.HasNext() {
component := iterator.Next()
fmt.Println(component.GetName())
}
} 
