Swift 访问控制：从入门到精通，附丰富代码实例

1. 引言

访问控制（Access Control）是 Swift 语言中一项核心特性，它决定了代码中实体（类、结构体、枚举、属性、方法等）的可访问范围。合理的访问控制能够封装实现细节，提供清晰的 API 边界，是构建模块化、可维护和安全 Swift 代码的基石。本文将深入解析 Swift 的访问控制模型，通过丰富的代码实例，帮助你掌握从基础到高级的应用技巧。

2. 访问级别概览

Swift 提供了五种主要的访问级别，从最开放到最严格依次为：

• open 和 public：用于模块的对外接口。
• internal：默认级别，模块内可访问。
• fileprivate：文件内可访问。
• private：最严格的封装，仅在当前作用域内可访问。

3. 基础访问控制实战

3.1 定义不同访问级别的实体

// 模块 `NetworkModule` 中
public class NetworkManager {
    public init() {}
    public func fetchData(from url: String) -> Data? {
        // 公开的获取数据方法
        return nil
    }
    
    internal var configuration: NetworkConfig // 模块内可访问
    fileprivate let sessionID = UUID() // 文件内可访问
    private var cache: [String: Data] = [:] // 仅类内可访问
}

internal struct NetworkConfig {
    var timeout: TimeInterval = 30.0
    var enableLogging = true
}

fileprivate func logSessionStart(_ id: UUID) {
    print("Session started: \(id)")
}

3.2 访问级别的使用规则

实体的访问级别不能高于其依赖类型的访问级别。例如，一个 public 函数的参数类型不能是 internal 的。

// 错误示例：public 函数使用了 internal 类型
internal struct InternalType {}

// public func publicFunction(param: InternalType) {} // 编译错误

// 正确示例：将类型也设为 public
public struct PublicType {
    public var value: Int
}

public func publicFunction(param: PublicType) -> Int {
    return param.value
}

4. 高级特性与模式

4.1 子类化与访问控制

open 和 public 的关键区别在于子类化权限。只有标记为 open 的类才能被其他模块继承，其方法才能被重写。

// 在框架模块中定义
open class BaseViewController {
    open func viewDidLoad() {
        print("Base view loaded")
    }
    
    public final func setupUI() { // final 防止被重写
        print("UI setup")
    }
}

// 在应用模块中可以继承和重写
class CustomViewController: BaseViewController {
    override open func viewDidLoad() {
        super.viewDidLoad()
        print("Custom view loaded")
    }
    
    // override func setupUI() {} // 错误：无法重写 final 方法
}

4.2 属性的 Getter 和 Setter

可以为属性的 getter 和 setter 分别指定访问级别，setter 的级别可以低于 getter，以实现“只读”对外暴露。

public struct TemperatureSensor {
    // 内部可读写，外部只读
    public private(set) var currentTemperature: Double = 20.0
    
    internal func updateTemperature(_ newValue: Double) {
        // 一些内部校准逻辑
        currentTemperature = newValue
    }
}

// 使用示例
let sensor = TemperatureSensor()
print(sensor.currentTemperature) // 可以读取
// sensor.currentTemperature = 25.0 // 错误：setter 是 private 的

4.3 扩展中的访问控制

扩展可以为其成员指定新的访问级别，但不能高于原类型的访问级别。扩展还可以通过添加协议一致性来增强类型功能。

public protocol DataEncodable {
    func encode() -> Data?
}

internal struct User {
    var name: String
    var id: Int
}

// 为 internal 类型添加 public 协议扩展
extension User: DataEncodable {
    public func encode() -> Data? {
        return "\(name):\(id)".data(using: .utf8)
    }
}

// 文件私有扩展，添加辅助方法
fileprivate extension User {
    func debugDescription() -> String {
        return "User(\(name), #\(id))"
    }
}

5. 实战：构建一个安全的缓存系统

下面我们综合运用各种访问控制级别，构建一个线程安全的缓存系统。

import Foundation

public final class SafeCache<Key: Hashable, Value> {
    // 存储字典，私有以确保线程安全
    private var storage: [Key: Value] = [:]
    // 读写锁（使用 DispatchQueue 模拟）
    private let queue = DispatchQueue(label: "com.example.SafeCache.queue", attributes: .concurrent)
    
    public init() {}
    
    // 公开的存取接口
    public func setValue(_ value: Value, forKey key: Key) {
        queue.async(flags: .barrier) {
            self.storage[key] = value
        }
    }
    
    public func value(forKey key: Key) -> Value? {
        var result: Value?
        queue.sync {
            result = storage[key]
        }
        return result
    }
    
    // 内部清理方法
    internal func clearExpired(using isExpired: (Key, Value) -> Bool) {
        queue.async(flags: .barrier) {
            self.storage = self.storage.filter { !isExpired($0.key, $0.value) }
        }
    }
    
    // 文件私有的调试方法
    fileprivate func debugSnapshot() -> [Key: Value] {
        return queue.sync {
            return self.storage
        }
    }
}

// 使用示例
let cache = SafeCache<String, Int>()
cache.setValue(42, forKey: "answer")
if let value = cache.value(forKey: "answer") {
    print("The answer is \(value)") // 输出: The answer is 42
}

6. 常见陷阱与最佳实践

6.1 单元测试中的访问控制

测试目标模块时，需要访问其 internal 实体。可以通过 @testable import ModuleName 来提升测试中的访问级别。

// 在测试文件中
@testable import MyAppModule

func testInternalFunction() {
    let processor = DataProcessor() // DataProcessor 是 internal 的
    XCTAssertNotNil(processor)
}

6.2 协议要求的访问级别

协议中声明的需求自动接收与协议本身相同的访问级别。实现该协议的类型，其实现方法的访问级别不能低于协议要求。

public protocol Serializable {
    func serialize() -> String
}

internal class Document: Serializable {
    // 必须使用 public，因为协议是 public 的
    public func serialize() -> String {
        return "Document serialized"
    }
}

6.3 最佳实践总结

• 最小权限原则：默认使用 private 或 fileprivate，仅当需要时才提升级别。
• 明确 API 边界：使用 public 和 open 清晰地定义模块对外接口。
• 利用 private(set)：创建对外只读、对内可写的属性，增强封装性。
• 为测试而设计：合理使用 internal 和 @testable，避免为了测试而破坏封装。

7. 总结

Swift 的访问控制系统提供了精细的代码封装能力。从限制类型和方法的可见性，到控制属性的读写权限，再到管理模块间的依赖关系，合理的访问控制是编写健壮、可维护 Swift 代码的关键。通过本文的详细讲解和丰富实例，希望你能在实际项目中灵活运用这些特性，构建出更清晰、更安全的代码架构。