本文大部分内容翻译至《Pro Design Pattern In Swift》By Adam Freeman，一些地方做了些许修改，并将代码升级到了Swift2.0,翻译不当之处望多包涵。
观察者模式(The Observer Pattern)
观察者设计模式定义了对象间的一种一对多的依赖关系，以便一个对象的状态发生变化时，所有依赖于它的对象都得到通知并自动刷新。
示例工程
OS X Command Line Tool工程：
SystemComponents.swift
class ActivityLog {
func logActivity(activity:String) {
print("Log: \\(activity)")
}
}
class FileCache {
func loadFiles(user:String) {
print("Load files for \\(user)")
}
}
class AttackMonitor {
var monitorSuspiciousActivity: Bool = false {
didSet {
print("Monitoring for attack: \\(monitorSuspiciousActivity)")
}
}
}
ActivityLog类代表系统的事件日志输出；FileCache类代表一个给定的用户的文件加载；AttackMonitor类代表可疑事件发生时的安全服务。
Authentication.swift
class AuthenticationManager {
private let log = ActivityLog()
private let cache = FileCache()
private let monitor = AttackMonitor()
func authenticate(user:String, pass:String) -> Bool {
var result = false
if (user == "bob" && pass == "secret") {
result = true
print("User \\(user) is authenticated")
// call system components
log.logActivity("Authenticated \\(user)")
cache.loadFiles(user)
monitor.monitorSuspiciousActivity = false
} else {
print("Failed authentication attempt")
// call system components
log.logActivity("Failed authentication: \\(user)")
monitor.monitorSuspiciousActivity = true
}
return result
}
}
AuthenticationManager类代表用密码来认证用户的服务类。可以看出认证成功后会输出成功日志并加载用户的文件，失败后会输出失败日志并输出受攻击的警告。
main.swift
let authM = AuthenticationManager()
authM.authenticate("bob", pass: "secret")
print("--------------")
authM.authenticate("joe", pass: "shhh")
运行程序：
User bob is authenticated
Log: Authenticated bob
Load files for bob
Monitoring for attack: false
--------------
Failed authentication attempt
Log: Failed authentication: joe
Monitoring for attack: true
理解观察者模式解决的问题
示例中的代码结构在真正的项目中十分常见，一个事件的发生引起了一系列的其它事件的发生。
问题发生在操作初始事件的类里(本例中就是AuthenticationManager类)，它必须知道触发的其它事件的详细和它们是如何操作的。如果其中的一个触发类做一些修改，那么相应的初始事件类中也要做相应的修改。
理解观察者模式
观察者模式通过将它们分成被观察者和观察者来改变这种关系。被观察者持有观察者的集合，当发生改变时就通知它们。
实现观察者模式
实现观察者模式的关键是用协议定义观察者和被观察者的协议。
Observer.swift
protocol Observer : class {
func notify(user:String, success:Bool)
}
protocol Subject {
func addObservers(observers:Observer...)
func removeObserver(observer:Observer)
}
注意到Observer协议的class关键字， 这样做的原因是我们后面要进行对象的比较。
创建被观察者基类
我们知道被观察类持有观察者类的集合，所以同时需要GCD并发保护。
Observer.swift
import Foundation
protocol Observer : class {
func notify(user:String, success:Bool)
}
protocol Subject {
func addObservers(observers:Observer...)
func removeObserver(observer:Observer)
}
class SubjectBase : Subject {
private var observers = [Observer]()
private var collectionQueue = dispatch_queue_create("colQ",DISPATCH_QUEUE_CONCURRENT)
func addObservers(observers: Observer...) {
dispatch_barrier_sync(self.collectionQueue){[weak self] in
for newOb in observers {
self!.observers.append(newOb)
}
}
}
func removeObserver(observer: Observer) {
dispatch_barrier_sync(self.collectionQueue){[weak self] in
self!.observers = self!.observers.filter(){
$0 !== observer
}
}
}
func sendNotification(user:String, success:Bool) {
dispatch_sync(self.collectionQueue){ [weak self] in
for ob in self!.observers {
ob.notify(user, success: success)
}
}
}
}
实现被观察者协议
Authentication.swift
class AuthenticationManager : SubjectBase {
func authenticate(user:String, pass:String) -> Bool {
var result = false
if (user == "bob" && pass == "secret") {
result = true
print("User \\(user) is authenticated")
} else {
print("Failed authentication attempt")
}
sendNotification(user, success: result)
return result
}
}
实现观察者协议
SystemComponents.swift
class ActivityLog : Observer {
func notify(user: String, success: Bool) {
print("Auth request for \\(user). Success: \\(success)")
}
func logActivity(activity:String) {
print("Log: \\(activity)")
}
}
class FileCache : Observer {
func notify(user: String, success: Bool) {
if (success) {
loadFiles(user)
}
}
func loadFiles(user:String) {
print("Load files for \\(user)")
}
}
class AttackMonitor : Observer {
func notify(user: String, success: Bool) {
monitorSuspiciousActivity = !success
}
var monitorSuspiciousActivity: Bool = false {
didSet {
print("Monitoring for attack: \\(monitorSuspiciousActivity)")
}
}
}
最后我们再看main.swift：
let log = ActivityLog()
let cache = FileCache()
let monitor = AttackMonitor()
let authM = AuthenticationManager()
authM.addObservers(log, cache, monitor)
authM.authenticate("bob", pass: "secret")
print("-----")
authM.authenticate("joe", pass: "shhh")
运行程序：
User bob is authenticated
Auth request for bob. Success: true
Load files for bob
Monitoring for attack: false
-----
Failed authentication attempt
Auth request for joe. Success: false
Monitoring for attack: true
我们再添加观察者就显得很容易了，只要实现观察者协议然后调用addOberservers方法添加观察者就行了。
观察者模式的变形
泛化通知类型
示例中的notify 方法只能接收认证的通知，这其实是很糟糕的一种设计。
...
func notify(user:String, success:Bool)
...
下面我们做一些修改，使得它所接受的数据类型和通知类型都可以多样化。
Observer.swift
import Foundation
enum NotificationTypes : String {
case AUTH_SUCCESS = "AUTH_SUCCESS"
case AUTH_FAIL = "AUTH_FAIL"
}
struct Notification {
let type:NotificationTypes
let data:Any?
}
protocol Observer : class {
func notify(notification:Notification)
}
......
func sendNotification(notification:Notification) {
dispatch_sync(self.collectionQueue){ [weak self] in
for ob in self!.observers {
ob.notify(notification)
}
}
}
.......
接着我们修改SystemComponents.swift ：
class ActivityLog : Observer {
func notify(notification:Notification) {
print("Auth request for \\(notification.type.rawValue) " + "Success: \\(notification.data!)")
}
func logActivity(activity:String) {
print("Log: \\(activity)")
}
}
class FileCache : Observer {
func notify(notification:Notification) {
if (notification.type == NotificationTypes.AUTH_SUCCESS) {
loadFiles(notification.data! as! String)
}
}
func loadFiles(user:String) {
print("Load files for \\(user)");
}
}
class AttackMonitor : Observer {
func notify(notification: Notification) {
monitorSuspiciousActivity = (notification.type == NotificationTypes.AUTH_FAIL)
}
var monitorSuspiciousActivity: Bool = false {
didSet {
print("Monitoring for attack: \\(monitorSuspiciousActivity)");
}
}
}
最后是AuthenticationManager.swift:
class AuthenticationManager : SubjectBase {
func authenticate(user:String, pass:String) -> Bool {
var nType = NotificationTypes.AUTH_FAIL
if (user == "bob" && pass == "secret") {
nType = NotificationTypes.AUTH_SUCCESS
print("User \\(user) is authenticated")
} else {
print("Failed authentication attempt")
}
sendNotification(Notification(type: nType, data: user))
return nType == NotificationTypes.AUTH_SUCCESS
}
}
运行程序：
p.p1 {margin: 0.0px 0.0px 0.0px 0.0px; font: 18.0px Menlo; color: #ffffff}span.s1 {font-variant-ligatures: no-common-ligatures}
User bob is authenticated
Auth request for AUTH_SUCCESS Success: bob
Load files for bob
Monitoring for attack: false
-----
Failed authentication attempt
Auth request for AUTH_FAIL Success: joe
Monitoring for attack: true
