观察者模式

观察者模式定义

定义：定义了一种一对多的依赖关系，让一个或者多个观察者对象监听其所关心的主题对象。这个主题对象在自身状态发生改变时，会给所有观察者对象发送通知。 使用观察者模式，可以让大量多组对象在较少依赖的情况下实现合作，因此被广泛使用。

观察者模式应用场景

当一个对象需要在不依赖另一个对象的情况下，接收到另一个对象发生变化的通知时，即可使用此模式。

观察者模式-角色划分

角色一：被观察者（目标对象）
角色二：具体被观察者
角色三：观察者（抽象）
角色四：具体观察者

示例程序一

/// 观察者模式 角色一： 观察者对象（抽象观察者）
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: "海南的妹子比较漂亮...可以去看看...")
        //观察者模式实现->系统类似的实现
        //其他语言观察者模式->差不多