第8章：协议的高级用法

8.4 协议在设计模式中的高级应用

设计模式是解决常见编程问题的成熟方案，而 Swift 的协议化编程（POP）通过其灵活性和抽象能力，为实现这些模式提供了独特的方式。结合协议的高级特性（如继承、组合和泛型集成），我们可以以类型安全和解耦的方式实现经典设计模式，如工厂模式、观察者模式和策略模式。本节将探讨协议在设计模式中的高级应用，分析其实现方法，并通过示例展示其优势。

协议与设计模式的关系

  • 抽象接口：协议定义行为契约，天然适合模式中的角色抽象。
  • 依赖注入：通过协议注入实现，增强解耦性。
  • 高级特性：继承、组合和泛型支持复杂模式实现。

示例 1：工厂模式

工厂模式用于创建对象，协议可以通过关联类型和泛型实现类型安全的工厂。

实现
protocol Product {
    func use()
}

protocol Factory {
    associatedtype ProductType: Product
    func create() -> ProductType
}

struct Chair: Product {
    func use() {
        print("Sitting on a chair")
    }
}

struct Table: Product {
    func use() {
        print("Placing items on a table")
    }
}

struct ChairFactory: Factory {
    typealias ProductType = Chair
    func create() -> Chair {
        Chair()
    }
}

func produce<T: Factory>(_ factory: T) {
    let product = factory.create()
    product.use()
}

let chairFactory = ChairFactory()
produce(chairFactory) // 输出: Sitting on a chair
  • Factory 使用关联类型确保产品类型安全。
  • 泛型函数 produce 适配任意工厂。

优势：类型安全，扩展只需新增工厂和产品，无需修改核心逻辑。

示例 2：观察者模式

观察者模式支持事件广播，协议可以定义观察者和被观察者的接口。

实现
protocol Observer {
    func update(event: String, data: Any)
}

protocol Observable {
    mutating func addObserver(_ observer: Observer)
    func notifyObservers(event: String, data: Any)
}

struct EventManager: Observable {
    private var observers: [Observer] = []
    
    mutating func addObserver(_ observer: Observer) {
        observers.append(observer)
    }
    
    func notifyObservers(event: String, data: Any) {
        observers.forEach { $0.update(event: event, data: data) }
    }
    
    func triggerEvent(_ event: String, with data: Any) {
        notifyObservers(event: event, data: data)
    }
}

struct Logger: Observer {
    func update(event: String, data: Any) {
        print("Log: \(event) - \(data)")
    }
}

var manager = EventManager()
let logger = Logger()
manager.addObserver(logger)
manager.triggerEvent("start", with: "App launched")
// 输出: Log: start - App launched
  • Observer 和 Observable 定义松耦合的通信接口。
  • 可动态添加观察者，支持一对多通知。

优势：解耦观察者和被观察者，易于扩展新观察者。

示例 3：策略模式

策略模式允许动态切换算法，协议通过泛型和组合实现灵活策略。

实现
protocol Strategy {
    func execute(_ value: Int) -> Int
}

struct DoubleStrategy: Strategy {
    func execute(_ value: Int) -> Int {
        value * 2
    }
}

struct SquareStrategy: Strategy {
    func execute(_ value: Int) -> Int {
        value * value
    }
}

struct Calculator {
    private let strategy: Strategy
    
    init(strategy: Strategy) {
        self.strategy = strategy
    }
    
    func calculate(_ input: Int) -> Int {
        strategy.execute(input)
    }
}

let doubleCalc = Calculator(strategy: DoubleStrategy())
print(doubleCalc.calculate(5)) // 输出: 10

let squareCalc = Calculator(strategy: SquareStrategy())
print(squareCalc.calculate(5)) // 输出: 25
  • Strategy 定义算法接口，Calculator 通过注入切换策略。
  • 类型安全且易于添加新策略。

优势：运行时动态切换行为，符合开闭原则。

高级应用：组合模式

结合协议继承和泛型，实现复杂的组合模式（如树形结构）。

实现
protocol Component {
    func operation()
}

protocol Composite: Component {
    mutating func add(_ component: any Component)
    var children: [any Component] { get }
}

struct Leaf: Component {
    let name: String
    func operation() {
        print("Leaf \(name) operated")
    }
}

struct Branch: Composite {
    private var _children: [any Component] = []
    
    var children: [any Component] { _children }
    
    mutating func add(_ component: any Component) {
        _children.append(component)
    }
    
    func operation() {
        print("Branch operating")
        _children.forEach { $0.operation() }
    }
}

var branch = Branch()
branch.add(Leaf(name: "A"))
branch.add(Leaf(name: "B"))
branch.operation()
// 输出:
// Branch operating
// Leaf A operated
// Leaf B operated
  • Component 和 Composite 定义树形结构。
  • any Component 使用存在类型，支持异构集合。

优势：协议继承实现层次结构，泛型支持动态组合。

测试设计模式

为策略模式添加测试：

struct MockStrategy: Strategy {
    let result: Int
    func execute(_ value: Int) -> Int { result }
}

import XCTest
class CalculatorTests: XCTestCase {
    func testCalculate() {
        let calc = Calculator(strategy: MockStrategy(result: 42))
        let result = calc.calculate(10)
        XCTAssertEqual(result, 42)
    }
}
  • Mock 对象验证策略切换，隔离核心逻辑。

协议在设计模式中的优势

  1. 类型安全：
    • 编译时检查确保模式实现正确。
  2. 解耦性：
    • 协议接口隔离角色，依赖注入降低耦合。
  3. 灵活性：
    • 继承、组合和泛型支持动态扩展。
  4. 复用性：
    • 抽象行为可跨场景重用。

注意事项

  • 复杂度：复杂模式可能增加设计开销，需权衡。
  • 性能：动态分派可能影响效率，可优化为静态调用。
  • 一致性：协议定义需清晰，避免实现歧义。

小结

协议在设计模式中的高级应用通过工厂、观察者、策略和组合等示例，展示了其在抽象、解耦和扩展性上的能力。结合 Swift 的高级特性，这些模式实现更加优雅和健壮。本章下一节将通过实战案例整合这些知识，构建复杂系统。

Last Updated::