1. 观察者模式在iOS开发中的核心价值

观察者模式（Observer Pattern）作为23种经典设计模式之一，在iOS开发中扮演着消息传递中枢的角色。这种一对多的依赖关系设计，允许一个对象（被观察者）的状态变化自动通知所有依赖它的对象（观察者），而无需知道具体有哪些观察者存在。

在iOS生态中，观察者模式的应用几乎无处不在：

• UI控件状态管理：当UISlider的值发生变化时自动更新关联的UILabel
• 数据绑定：Core Data的NSManagedObjectContext对象状态变化通知
• 系统事件响应：键盘弹出/隐藏事件、应用前后台切换通知
• 自定义业务逻辑：用户登录状态变化触发多模块界面更新

实际开发中，我曾遇到一个典型场景：电商App的商品详情页需要同时更新收藏按钮状态、库存显示和价格变化，使用观察者模式可以让这些UI元素自动响应数据变化，避免手动维护复杂的更新逻辑。

2. iOS中观察者模式的三种实现方式

2.1 NotificationCenter：系统级消息总线

NotificationCenter是iOS提供的内置观察者模式实现，采用中央调度器设计：

// 注册观察者 NotificationCenter.default.addObserver( self, selector: #selector(handleNotification(_:)), name: .userDidLogin, object: nil ) // 发送通知 NotificationCenter.default.post( name: .userDidLogin, object: nil, userInfo: ["username": "john"] ) // 处理通知 @objc func handleNotification(_ notification: Notification) { guard let userInfo = notification.userInfo else { return } print("User logged in: \(userInfo["username"] ?? "")") } // 记得移除观察者 deinit { NotificationCenter.default.removeObserver(self) }

适用场景：

• 跨模块的全局事件通知
• 系统事件的监听（如键盘、内存警告）
• 不需要强类型安全校验的简单消息传递

性能陷阱：

• 大量高频通知会导致主线程卡顿
• 忘记移除观察者可能引起内存泄漏
• userInfo字典的编解码存在额外开销

2.2 KVO：键值观察的利器

Key-Value Observing通过运行时动态创建子类实现属性监听：

class User: NSObject { @objc dynamic var name: String = "" } let user = User() var observation: NSKeyValueObservation? observation = user.observe(\.name, options: [.new]) { (object, change) in print("Name changed to: \(change.newValue ?? "")") } user.name = "Alice" // 触发回调

最佳实践：

1. 被观察属性必须标记为@objc dynamic
2. 使用Swift 4+的NSKeyValueObservation代替传统方法
3. 观察者生命周期管理至关重要

我在金融类App中曾用KVO实现实时汇率更新，但需要注意：频繁更新的数值型属性可能因精度微调导致不必要的回调触发。

2.3 自定义观察者协议

对于复杂业务场景，可以设计类型安全的观察者模式：

protocol StockObserver: AnyObject { func stockPriceDidChange(_ stock: Stock, newPrice: Decimal) } class Stock { private var observers = [StockObserver]() private var price: Decimal = 0 func addObserver(_ observer: StockObserver) { observers.append(observer) } func removeObserver(_ observer: StockObserver) { observers.removeAll { $0 === observer } } func updatePrice(_ newPrice: Decimal) { price = newPrice observers.forEach { $0.stockPriceDidChange(self, newPrice: newPrice) } } }

优势对比：

3. 观察者模式的高级应用技巧

3.1 线程安全改造方案

默认实现大多不是线程安全的，需要额外处理：

class ThreadSafeStock { private let queue = DispatchQueue(label: "com.observer.serial") private var _observers = [StockObserver]() var observers: [StockObserver] { queue.sync { _observers } } func addObserver(_ observer: StockObserver) { queue.async(flags: .barrier) { [weak self] in self?._observers.append(observer) } } }

3.2 Combine框架的现代实现

iOS 13+推荐使用响应式编程框架：

import Combine class ViewModel { @Published var searchText: String = "" private var cancellables = Set<AnyCancellable>() func setupBinding() { $searchText .debounce(for: .milliseconds(300), scheduler: RunLoop.main) .sink { [weak self] text in self?.performSearch(text) } .store(in: &cancellables) } }

3.3 性能优化策略

1. 批量更新：对高频变化属性实现缓冲机制

private var pendingUpdates = [Decimal]() private let updateThreshold = 5 func receivePriceUpdate(_ price: Decimal) { pendingUpdates.append(price) guard pendingUpdates.count >= updateThreshold else { return } let average = pendingUpdates.reduce(0, +) / Decimal(pendingUpdates.count) notifyObservers(average) pendingUpdates.removeAll() }

2. 差异化通知：只通知真正关心特定变化的观察者

enum StockEvent { case priceChange case volumeChange case dividendUpdate } protocol SmartStockObserver { func stockDidChange(_ stock: Stock, event: StockEvent) }

4. 实战中的典型问题与解决方案

4.1 循环引用破解之道

// 错误示例：导致内存泄漏 notificationCenter.addObserver( self, selector: #selector(updateUI), name: .dataUpdated, object: dataModel ) // 正确方案：使用weak捕获 var observer: Any? observer = notificationCenter.addObserver( forName: .dataUpdated, object: nil, queue: nil ) { [weak self] _ in self?.updateUI() }

4.2 重复通知过滤技巧

private var lastUpdateTime = Date.distantPast private let updateInterval: TimeInterval = 0.5 func didReceiveUpdate() { let now = Date() guard now.timeIntervalSince(lastUpdateTime) > updateInterval else { return } lastUpdateTime = now // 执行实际更新... }

4.3 多线程通知同步

func notifyObservers() { let currentObservers: [StockObserver] queue.sync { currentObservers = _observers } DispatchQueue.main.async { currentObservers.forEach { observer in observer.stockPriceDidChange(...) } } }

5. 设计模式组合实践

5.1 观察者+工厂模式

创建可订阅的事件源工厂：

protocol EventSourceFactory { func createEventSource(for type: EventType) -> EventSource } class ObservableEventSource: EventSource { private var handlers = [(Event) -> Void]() func subscribe(_ handler: @escaping (Event) -> Void) -> Subscription { handlers.append(handler) return Subscription { [weak self] in self?.handlers.removeAll { $0 === handler } } } }

5.2 观察者+状态模式

实现状态变化的自动通知：

class Order { private var state: OrderState = DraftState() { didSet { notifyObservers() } } func proceedToNextState() { state = state.nextState() } }

在最近开发的社交App中，我采用这种组合模式处理用户关系状态变化，当用户从"陌生人"变为"好友"时，自动触发聊天界面解锁和动态流更新。