我们经常遇到这种情况，就是一个应用中有某些变量可能需要经常被改变，而很多其他模块都需要用到这个变量，我们希望在这个变量被改变时，使用者能够及时知晓并进行更新（执行例如 UI 刷新、重载等操作）。传统一点的做法我们可能会去使用NSNotificationCenter这个类，它确实非常实用，可以轻松做到类似 PubSub 的功能，但是如果有许多变量，我们岂不是要声明许多 Notification？这显然是低效且不现实。
本文将利用 Swift 的语言特效一步步打造一个十分好用的观察者模式。
石器时代
使用泛型封装变量，然后给出一个闭包数组，当变量变化时遍历闭包数组，把新值传过去：
import Foundation
class UZObservable<T> {
var value: T? {
set(newValue) {
self._value = newValue
self.notify()
}
get {
return self._value
}
}
typealias Observer = T? -> Void
private var _value: T?
private var observers = [Observer]()
func notify() {
self.observers.forEach { $0(self.value) }
}
func bindObserver(observer: Observer) {
self.observers.append(observer)
}
}
很简单，没什么可解释的。注意一点，闭包需要用 typealias 指派一个类型，不然编译器不认...
随手撸一个测试界面，我们来看看效果。
然后是使用代码：
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view.
message.bindObserver({ [weak self] (message: String?) in
self?.label.text = message
})
}
不出意外的，我们初步实现了观察者模式。
铁器时代
但是，但是。随着我们的项目越来越大，一个变量的观察者列表会越来越庞大，然而有许多观察者实际已经被释放了，所以我们必须要有一个方法来处理冗余的观察者。于是，我们可以使用 Dictionary，也就是一个键对应一个观察者闭包，当观察者被释放的时候把相应的键移除掉。
于是代码变成这样：
import Foundation
class UZObservable<T> {
var value: T? {
set(newValue) {
self._value = newValue
self.notify()
}
get {
return self._value
}
}
typealias Observer = T? -> Void
private var _value: T?
private var observers = [String:Observer]()
func notify() {
for (_, observer) in self.observers {
observer(self.value)
}
}
func bindObserver(observer: Observer, forKey key: String) {
self.observers[key] = observer
}
func removeObserverForKey(key: String) {
self.observers.removeValueForKey(key)
}
}
看起来也蛮简单，但是问题又产生了...字符串化的 key 是十分容易碰撞的，好了，这个方法显然也是不行的。
信息化时代
看来我们需要对观察者进行一番修改了，为何不用一个引用对象当做 key 呢？也就是说当一个对象需要观察这个变量，这个对象就把 weak 的 self但做 key 添加到观察者列表中，然后我们定期检测这个对象是否为nil，如果是就把它剔除掉。这显然更加完美，因为我们再不用绞尽脑汁地去想各种奇怪的 key 了。
实现如下：
import Foundation
class UZObserver<T> {
var closure: (T? -> Void)!
weak var reference: AnyObject?
}
class UZObservable<T> {
var value: T? {
set(newValue) {
self._value = newValue
self.notify()
}
get {
return self._value
}
}
private var _value: T?
private var observers = [UZObserver<T>]()
func notify() {
observers.forEach { if $0.reference != nil { $0.closure(self.value) } }
}
func bindObserver(observer: AnyObject, closure: T? -> Void) {
self.clean()
let _observer = UZObserver<T>()
_observer.closure = closure
_observer.reference = observer
self.observers.append(_observer)
}
func clean() {
self.observers = self.observers.filter {
return $0.reference != nil
}
}
}
这里，每次添加新观察者时都清理一遍无效的观察者，这样就可以保证可观的内存使用。
上面这段代码十分稳定，大家可以放心地在项目中去使用😄
