Swift观察者模式(发布-订阅模式)

定义

观察者模式（又被称为发布-订阅（Publish/Subscribe）模式，属于行为型模式的一种，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己

观察者模式结构图

观察者模式角色

• Observer：抽象观察者，是观察者者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。
• ConcrereObserver：具体观察者，实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。
• Subject：抽象主题（抽象被观察者），抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
• ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。

观察者模式简单代码实现

• 观察者

   /// 观察者模式

// 抽象观察者（Observer）
protocol Observer {
    var id: Int { get }
    func update<T>(with newValue: T)
}

// 具体观察者
class ConcreateObserver: Observer {
    var id: Int {
        get {
            return self._id
        }
    }
    private var _id: Int = 0
    
    init(id: Int) {
        self._id = id
    }
    
    func update<T>(with newValue: T) {
        print("Whoaa , observer \(self.id) update with new value :",newValue)
    }
}
复制代码

• 被观察者

// 抽象被观察者（Subject）
protocol Subject {
    func addObserver(observer: Observer)
    func removeObserver(observer: Observer)
    func notifyAllObservers<T>(with newValue: T)
}
// 具体被观察者（ConcrereObserver）
class ConCreateSubject<T>: Subject {
   
    
    var _value: T! = nil
    
    var _observers: [Observer] = []
    
    var value: T {
        get {
            return self._value
        }
        
        set {
            self._value = newValue
        }
    }
    
    var observers: [Observer] {
        set {
            self._observers = newValue
        }
        get {
            return self._observers
        }
    }
    
    func addObserver(observer: Observer) {
        observers.append(observer)
    }
    
    func removeObserver(observer: Observer) {
        observers = observers.filter{$0.id != observer.id }
    }
    
    func notifyAllObservers<T>(with newValue: T) {
        for observer in observers {
            observer.update(with: newValue)
        }
    }
    
}
复制代码

• 调用

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        
        let obs1 = ConcreateObserver(id: 1)
        let obs2 = ConcreateObserver(id: 2)
        let subject = ConCreateSubject<String>()
        
        subject.addObserver(observer: obs1)
        subject.addObserver(observer: obs2)
        subject.value = "Surprise! New Feeds update."
        subject.notifyAllObservers(with: subject.value)
        subject.removeObserver(observer: obs1)
        subject.value = "Obs1 removed, yey"
        subject.notifyAllObservers(with: subject.value)

    }

}
复制代码

• 打印结果

1. Whoaa , observer 1 update with new value : Surprise! New Feeds update.
2. Whoaa , observer 2 update with new value : Surprise! New Feeds update.
3. Whoaa , observer 2 update with new value : Obs1 removed, yey

可以看到有两个id分别为1和2的观察者，一个subject的被观察主题者，然后被观察主题者添加监听addObserver 这两个观察者id=1,id=2，然后被观察主题者通知观察者，我的状态变化了，此时添加的全部监听者，都能收到通知，分别执行update的闭包，
然后移除掉id为1的观察者，只有id为2的观察者再监听，被观察者发生改变，只能通知id为2的监听者，执行update的闭包，故只执行id为2的update闭包