Swift 设计模式解析：行为型模式详解

原创于 2025-06-02 09:15:55 发布 · 258 阅读

CC 4.0 BY-SA版权

Swift 设计模式解析：行为型模式详解

Design-Patterns-In-Swift 📖 Design Patterns implemented in Swift 5.0 项目地址: https://gitcode.com/gh_mirrors/de/Design-Patterns-In-Swift

前言

行为型设计模式是软件开发中用于管理对象间交互和职责分配的重要模式类别。本文将深入探讨 Swift 语言中实现的各种行为型设计模式，通过实际代码示例帮助开发者理解这些模式的原理和应用场景。

责任链模式 (Chain of Responsibility)

责任链模式允许你将请求沿着处理链传递，直到有一个对象能够处理它为止。

实现解析

在 ATM 取款机的示例中，我们创建了不同面值的钞票堆（MoneyPile），每个钞票堆都知道如何处理自己能处理的金额部分，并将剩余部分传递给下一个处理者：

protocol Withdrawing {
    func withdraw(amount: Int) -> Bool
}

final class MoneyPile: Withdrawing {
    let value: Int  // 钞票面值
    var quantity: Int  // 数量
    var next: Withdrawing?  // 下一个处理者
    
    func withdraw(amount: Int) -> Bool {
        // 处理逻辑...
    }
}

实际应用场景

事件处理系统
审批流程
异常处理链

命令模式 (Command)

命令模式将请求封装为对象，使你可以参数化客户端请求，队列或记录请求，并支持可撤销操作。

实现解析

门控系统示例展示了如何将开门和关门操作封装为命令对象：

protocol DoorCommand {
    func execute() -> String
}

final class OpenCommand: DoorCommand {
    func execute() -> String {
        return "Opened \(doors)"
    }
}

优势

解耦调用者和接收者
支持命令队列
实现撤销/重做功能

解释器模式 (Interpreter)

解释器模式定义了一种语言的文法表示，并提供一个解释器来处理这种语言。

实现解析

我们实现了一个简单的变量和加法表达式解释器：

protocol IntegerExpression {
    func evaluate(_ context: IntegerContext) -> Int
}

final class AddExpression: IntegerExpression {
    func evaluate(_ context: IntegerContext) -> Int {
        return operand1.evaluate(context) + operand2.evaluate(context)
    }
}

适用场景

需要解释特定领域语言的场景
SQL 解析
正则表达式处理

迭代器模式 (Iterator)

迭代器模式提供一种方法顺序访问聚合对象中的各个元素，而不暴露其内部表示。

Swift 实现特点

Swift 通过 IteratorProtocol 和 Sequence 协议原生支持迭代器模式：

struct NovellasIterator: IteratorProtocol {
    mutating func next() -> Novella? {
        // 实现迭代逻辑
    }
}

extension Novellas: Sequence {
    func makeIterator() -> NovellasIterator {
        return NovellasIterator(novellas: novellas)
    }
}

中介者模式 (Mediator)

中介者模式通过引入中介对象来减少对象间的直接耦合。

消息中介示例

程序员之间的消息传递通过中介者进行管理：

protocol Sender {
    func send(message: MessageType)
}

final class MessageMediator: Sender {
    func send(message: String) {
        recipients.forEach { $0.receive(message: message) }
    }
}

备忘录模式 (Memento)

备忘录模式在不破坏封装性的前提下捕获并外部化对象的内部状态。

游戏状态保存示例

protocol MementoConvertible {
    var memento: Memento { get }
    init?(memento: Memento)
}

struct GameState: MementoConvertible {
    var memento: Memento {
        return [Keys.chapter: chapter, Keys.weapon: weapon]
    }
}

观察者模式 (Observer)

观察者模式定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会得到通知。

属性观察实现

protocol PropertyObserver : class {
    func willChange(propertyName: String, newPropertyValue: Any?)
    func didChange(propertyName: String, oldPropertyValue: Any?)
}

class TestChambers {
    var testChamberNumber: Int = 0 {
        willSet { observer?.willChange(...) }
        didSet { observer?.didChange(...) }
    }
}

状态模式 (State)

状态模式允许对象在内部状态改变时改变其行为。

授权状态管理

protocol State {
    func isAuthorized(context: Context) -> Bool
    func userId(context: Context) -> String?
}

class AuthorizedState: State {
    // 实现授权状态行为
}

策略模式 (Strategy)

策略模式定义一系列算法，将每个算法封装起来并使它们可以互相替换。

仿生人测试示例

protocol RealnessTesting: AnyObject {
    func testRealness(_ testSubject: TestSubject) -> Bool
}

struct BladeRunner {
    private let strategy: RealnessTesting
    // 使用策略进行测试
}

模板方法模式 (Template Method)

模板方法模式在父类中定义算法框架，允许子类重写特定步骤。

花园准备示例

protocol Garden {
    func prepareSoil()
    func plantSeeds()
    func waterPlants()
    func prepareGarden()
}

extension Garden {
    func prepareGarden() {  // 模板方法
        prepareSoil()
        plantSeeds()
        waterPlants()
    }
}

访问者模式 (Visitor)

访问者模式将算法与对象结构分离，允许在不修改结构的情况下添加新操作。

行星访问示例

protocol PlanetVisitor {
    func visit(planet: PlanetAlderaan)
    // 其他visit方法...
}

protocol Planet {
    func accept(visitor: PlanetVisitor)
}

class NameVisitor: PlanetVisitor {
    // 实现各个visit方法...
}