观察者模式定义
定义：定义了一种一对多的依赖关系，让一个或者多个观察者对象监听其所关心的主题对象。这个主题对象在自身状态发生改变时，会给所有观察者对象发送通知。 使用观察者模式，可以让大量多组对象在较少依赖的情况下实现合作，因此被广泛使用。
观察者模式应用场景
当一个对象需要在不依赖另一个对象的情况下，接收到另一个对象发生变化的通知时，即可使用此模式。
观察者模式-角色划分
角色一：被观察者（目标对象）
角色二：具体被观察者
角色三：观察者（抽象）
角色四：具体观察者
示例程序一
/// 观察者模式 角色一： 观察者对象（抽象观察者）
protocol ObserverProtocol : class {
func notify(user:String,success:Bool);
}
/// 观察者模式 角色二： 具体观察者（所有具体观察者 都会实现抽象观察者的协议，当被观察对象发生改变时，会调用协议内部的方法）
class ActivityLog: ObserverProtocol {
func notify(user: String, success: Bool) {
print("Auth request for\(user),is success: \(success)")
}
func logActivity(active:String) {
print("long : \(active)")
}
}
/// 观察者模式： 角色二,具体观察者，必须实现抽象观察者的协议，当被观察者对象发生改变时，通过协议的方法通知
class FileCacheObserver: ObserverProtocol {
func notify(user: String, success: Bool) {
if success {
loadFiles(user: user)
}
}
func loadFiles(user:String) {
print("Load files for \(user)")
}
}
/// 观察者模式：角色二，具体观察者
class AttackMonitorObserver: ObserverProtocol {
func notify(user: String, success: Bool) {
print("user\(user) islogin success? \(success)")
}
}
/// 观察者模式 角色三： 抽象被观察者（实际上也是被观察的主题对象）
protocol SubjectProtocol {
func addObservers(observers:ObserverProtocol...);
func removeObserver(observer:ObserverProtocol);
}
注释
在观察者模式中，由主题对象负责管理其观察者，为避免重复编写和创建管理观察者对象的代码，可以创建一个基类用于管理观察者。
/// 观察者模式： 角色四，具体被观察者（基类），也就是被观察主题对象
class SubjectBase: SubjectProtocol {
private var observers = [ObserverProtocol]()
let serialQueue = DispatchQueue(label: "serialQueue", attributes: .init(rawValue: 0))
func addObservers(observers: ObserverProtocol...) {
for newOb in observers {
self.observers.append(newOb)
}
}
func removeObserver(observer: ObserverProtocol) {
//self.observers = self.observers.filter{$0 != observer}
self.observers = self.observers.filter{$0 !== observer}
}
func sendNotifyCation(user:String,success:Bool) {
for ob in self.observers {
ob.notify(user: user, success: success)
}
}
}
/// 具体观察者
class AuthenticationManager: SubjectBase {
func authenticate(user:String, pass:String) -> Bool {
var result = false
if(user == "bob"&&pass == "sss"){
result = true;
print("登录成功 --- ")
} else {
print("登录失败 ---- ")
}
sendNotifyCation(user: user, success: result)
return result
}
}
// 观察者 对象
let log = ActivityLog()
let cache = FileCacheObserver()
let monitor = AttackMonitorObserver()
// 观察者 对象
let authM = AuthenticationManager()
authM.addObservers(observers: log,cache,monitor)
let bobSuccess = authM.authenticate(user: "bob", pass: "sss")
let aoaSuccess = authM.authenticate(user: "aoa", pass: "mmm")
print("bobSuccess is \(bobSuccess),aoaSuccess is \(aoaSuccess)")
示例程序二
//角色一：抽象被观察者
protocol Observable {
func addObserver(observer:Observer)
func removeObserver(observer:Observer)
func notifyObserver()
func notifyObserver(msg:Any?)
func countObserver() -> Int
func setChanged()
func clearChanged()
func hasChanged() -> Bool
}
//角色二：具体被观察者->NSLog同学(抽象出来->统一管理)(万能)
class DefaultObserable: Observable {
private var obs = Array<Observer>()
private var changed:Bool = false
func addObserver(observer:Observer){
self.obs.append(observer)
}
func removeObserver(observer:Observer){
//指定删除
self.obs.removeLast()
}
func notifyObserver(){
notifyObserver(msg: nil)
}
func notifyObserver(msg:Any?){
if !self.changed {
//更新数据->消息
return
}
//修改状态
self.clearChanged()
//循环通知->语法
self.obs.forEach { (o) in
o.update(obserable: self, msg: msg)
}
}
func countObserver() -> Int{
return self.obs.count
}
func setChanged(){
self.changed = true
}
func clearChanged(){
self.changed = false
}
func hasChanged() -> Bool {
return self.changed
}
}
//角色三：抽象观察者
protocol Observer {
func update(obserable:Observable, msg:Any?)
}
//角色四：具体观察者(新闻)
class NewsObserver: NSObject, Observer {
func update(obserable: Observable, msg: Any?) {
print("NSLog同学收到了新闻消息: \(String(describing: msg))")
}
}
//外部调用
let observer = NewsObserver()
let defaultOb = DefaultObserable()
//线程安全你也可以优化
defaultOb.setChanged()
defaultOb.addObserver(observer: self)
defaultOb.addObserver(observer: observer)
defaultOb.notifyObserver(msg: "海南的妹子比较漂亮...可以去看看...")
//观察者模式实现->系统类似的实现
//其他语言观察者模式->差不多
