App 架构进阶：用组合模式让你的文件/菜单/权限树“无限生长”

在日常开发中，移动端常见的目录管理、菜单组织、权限体系、UI层级、甚至复杂配置的管理等，都天然拥有“树状结构”。如何用简洁、灵活、可扩展的方式优雅实现这些递归层级？这就是**组合模式（Composite Pattern）**的威力所在。

本篇文章结合 Swift 和 Kotlin 代码示例，通俗讲透组合模式的设计思想，深入剖析其在文件系统目录树等实际场景下的最佳落地方法，字数详实，内容完整，助你一步迈入工程架构高手行列。

一、为什么需要组合模式？文件目录结构的痛点

在文件系统、导航菜单、图层树、组织架构等业务里，“节点”既可以是单个对象，也可以是“包含其他节点”的容器。比如目录树：

• o 目录可以包含子目录和文件
• o 文件是叶子节点，目录是容器节点
• o 目录和文件都可以被统一处理（递归遍历、删除、重命名等）

传统做法问题：

• o 目录和文件是两套逻辑，调用代码很难统一
• o 递归遍历、增删改等操作极为繁琐，易出错
• o 新增类型节点时，维护和扩展成本高

二、组合模式的核心思想与结构

组合模式本质上是将对象组合成树形结构，使客户端对单个对象和组合对象的使用保持一致。不管你是“文件”还是“目录”，都实现同一个接口，外部无需区分。

2.1 UML 结构图

• o Component（抽象组件）：声明所有叶子和容器节点的统一接口。
• o Leaf（叶子节点）：具体实现，如文件。
• o Composite（组合节点）：可以包含其他 Component（如目录），并递归实现接口。

三、Swift 实现：文件系统目录树

3.1 基本协议设计

    
    
    
  protocol FileSystemNode {
    var name: String { get }
    func display(indentation: String)
}

3.2 文件节点（叶子）

    
    
    
  class File: FileSystemNode {
    let name: String
    init(name: String) { self.name = name }
    
    func display(indentation: String = "") {
        print("\(indentation) \(name)")
    }
}

3.3 目录节点（组合）

    
    
    
  class Directory: FileSystemNode {
    let name: String
    private var children: [FileSystemNode] = []
    
    init(name: String) { self.name = name }
    
    func add(_ node: FileSystemNode) { children.append(node) }
    
    func remove(_ node: FileSystemNode) {
        children.removeAll { $0 === node }
    }
    
    func display(indentation: String = "") {
        print("\(indentation) \(name)")
        for child in children {
            child.display(indentation: indentation + "    ")
        }
    }
}

3.4 构建与递归遍历

    
    
    
  let root = Directory(name: "root")
let documents = Directory(name: "Documents")
let photos = Directory(name: "Photos")
let file1 = File(name: "Resume.pdf")
let file2 = File(name: "Photo.jpg")

root.add(documents)
root.add(photos)
documents.add(file1)
photos.add(file2)

// 递归打印目录树
root.display()

输出效果：

    
    
    
   root
     Documents
         Resume.pdf
     Photos
         Photo.jpg

四、Kotlin 实现：递归文件树

4.1 接口定义

    
    
    
  interface FileSystemNode {
    val name: String
    fun display(indentation: String = "")
}

4.2 文件节点（叶子）

    
    
    
  class File(override val name: String) : FileSystemNode {
    override fun display(indentation: String) {
        println("$indentation $name")
    }
}

4.3 目录节点（组合）

    
    
    
  class Directory(override val name: String) : FileSystemNode {
    private val children = mutableListOf<FileSystemNode>()
    
    fun add(node: FileSystemNode) { children.add(node) }
    fun remove(node: FileSystemNode) { children.remove(node) }
    
    override fun display(indentation: String) {
        println("$indentation $name")
        children.forEach { it.display(indentation + "    ") }
    }
}

4.4 构建与遍历

    
    
    
  fun main() {
    val root = Directory("root")
    val docs = Directory("Docs")
    val pics = Directory("Pics")
    val file1 = File("Readme.md")
    val file2 = File("pic1.png")
    
    root.add(docs)
    root.add(pics)
    docs.add(file1)
    pics.add(file2)
    
    root.display()
}

五、递归遍历与增删查改的优雅实现

5.1 递归遍历（打印、查找）

通过协议统一接口，无论是文件还是目录，都可以直接递归调用 display 方法，无需区分类型。实际工程里还可以加上查找、统计等递归功能：

    
    
    
  extension Directory {
    func findFile(named target: String) -> File? {
        for child in children {
            if let file = child as? File, file.name == target { return file }
            if let dir = child as? Directory, let found = dir.findFile(named: target) { return found }
        }
        return nil
    }
}

    
    
    
  fun Directory.findFile(target: String): File? {
    children.forEach { 
        when (it) {
            is File -> if (it.name == target) return it
            is Directory -> it.findFile(target)?.let { return it }
        }
    }
    return null
}

5.2 删除节点

Swift 和 Kotlin 的 Directory 节点都支持 remove，自动递归调整树结构。

5.3 动态添加新类型节点

如果未来业务扩展要加“快捷方式”“标签”等新节点，只需实现 FileSystemNode 协议即可，无需修改 Directory 逻辑。

六、组合模式的工程优势

• o 递归遍历天然优雅：所有节点都实现统一接口，递归天然简洁。
• o 新增节点类型无侵入：新需求支持更简单，维护无痛。
• o 支持复杂结构变化：目录可以嵌套无限层级，兼容超大树结构。
• o 客户端代码最简化：无需判断节点类型，所有操作都是“多态递归”。
• o 易于结合 UI 展示：如 SwiftUI 列表、RecyclerView/Compose 列表，配合组合模式直接递归渲染。

七、移动端工程实战扩展

7.1 导航菜单、权限树

• o App 菜单/侧边栏、功能权限体系（如角色/组织权限树）都可以用组合模式递归建模、渲染和管理。

7.2 UI 组件树

• o SwiftUI View/Android Compose 都是天然的“组合模式”，递归组合组件构建界面，最大程度减少代码重复。

7.3 复杂数据模型

• o 配置管理、分组表单、产品规格、商城多级分类等都可直接采用组合模式灵活建模。

八、设计注意事项与优化建议

1. 1. 避免循环引用：Swift 推荐 Directory 的 children 用弱引用（如 weak var，避免内存泄漏）。
2. 2. 性能优化：超大树结构需结合惰性加载、分批遍历，避免内存暴涨。
3. 3. 协议/接口与类型安全：协议/接口为未来扩展做好准备，减少类型判断。
4. 4. 结合依赖注入、事件机制：节点可扩展事件分发，满足高阶业务需求。

九、结语

组合模式是处理树形、层级、递归结构的“终极武器”。在文件系统、菜单管理、UI 组件树等移动端场景下，结合 Swift、Kotlin 等现代语言的强类型特性，不仅能极大提升代码的灵活性与可维护性，还能让你的业务结构自带无限扩展的“进化力”。

希望本篇详解能帮你彻底掌握组合模式的精髓，并在自己的项目中写出更优雅、更专业的树状管理代码！