为了提高代码的聚合, 用swift 写的一个事件订阅分发器.
链接: https://github.com/Xianlau/SwiftObservation
- 支持cocoapods
pod 'SwiftObservation'
用法案例:
import UIKit
import SwiftObservation
class ViewController: UIViewController {
let disposebag: DisposeBag = DisposeBag()
override func viewDidLoad() {
super.viewDidLoad()
//名称事件有更新
ObserverManager.nameEvent.subscribe { (name) in
print(name)
}.dispose(by: disposebag)
//年龄事件有更新
ObserverManager.ageEvent.subscribe { (age) in
print(age)
}.dispose(by: disposebag)
//更改名称
ObserverManager.publishNameEvent(value: "liuweixiang")
//更改年龄
ObserverManager.publishAgeEvent(value: 18)
}
}
被观察的对象: ObserverManager
import Foundation
import SwiftObservation
class ObserverManager {
static let shared = ObserverManager.init()
///名称subject 用来发布事件
private let nameSubject = BehaviorSubject<String>(value: "zhangsan") {
print("我被销毁啦")
}
///年龄subject 用来发布事件
private let ageSubject = BehaviorSubject<UInt>(value: 15)
///名称获取
public static var name : String {
return shared.nameSubject.value
}
///年龄获取
public static var age : UInt {
return shared.ageSubject.value
}
///名称可监听实例 用来给外界监听
public static var nameEvent: Observable<String> {
return shared.nameSubject.asObservable()
}
///年龄可监听实例 用来给外界监听
public static var ageEvent: Observable<UInt> {
return shared.ageSubject.asObservable()
}
///发布名称改变的事件
public static func publishNameEvent(value: String) {
if value != shared.nameSubject.value {
shared.nameSubject.publish(value)
}
}
///发布年龄改变的事件
public static func publishAgeEvent(value: UInt) {
if value != shared.ageSubject.value {
shared.ageSubject.publish(value)
}
}
}
整个观察器的逻辑
- 负责分布事件的Subject
import Foundation
/// 只发布内容，但不缓存内容
public class PublishSubject<Value>: Observable<Value> {
///转成可观察对象
public func asObservable() -> Observable<Value> {
return self
}
///发布新事件
public func publish(_ value: Value) {
notifyObserverArr(value)
}
}
/// 发布内容，同时也缓存最新内容
public class BehaviorSubject<Value>: PublishSubject<Value> {
private var _value: Value
public var value: Value {
return _value
}
///初始化, onDispose: 销毁的时候执行的闭包
public init(value: Value, onDispose: @escaping () -> Void = {}) {
_value = value
super.init(onDispose)
}
///发布新事件
public override func publish(_ value: Value) {
_value = value
super.publish(_value)
}
}
- 可观察对象实例
/*
*一个可以观察的对象
*
*/
public class Observable<Value> {
///观察者, 就是一个闭包, 事件发布的时候触发
public typealias Observer = (Value) -> Void
//序列的迭代器
private var uniqueId = (0...).makeIterator()
//递归锁
private let lock = NSRecursiveLock()
//销毁的时候执行的闭包
private var onDispose: () -> Void
//观察者数组
fileprivate var observerArr: [Int : (Observer, DispatchQueue)] = [:]
// onDispose: 销毁的时候执行的闭包
init(_ onDispose: @escaping () -> Void = {}) {
self.onDispose = onDispose
}
/*
* 事件的订阅函数, 返回一个可以销毁的对象
* - observer: 观察者, 就是一个闭包, 事件发布的时候触发
* - queue: 在指定的线程里面执行闭包
*/
public func subscribe(observer: @escaping Observer, on queue: DispatchQueue = .main) -> Disposable {
lock.lock()
defer {
lock.unlock()
}
let id = uniqueId.next()!
observerArr[id] = (observer, queue)
//订阅执行完后, 返回一个销毁的对象, 用来销毁自身的观察者, 以及执行销毁后的闭包
let disposable = Disposable.init { [weak self] in
self?.observerArr[id] = nil
self?.onDispose()
}
return disposable
}
}
extension Observable {
//有新的事件, 通知所有观察者
func notifyObserverArr(_ value: Value) {
observerArr.forEach {
let observer = $0.value.0
let queue = $0.value.1
if isCurrentQueue(queue) {
observer(value)
} else {
queue.async { observer(value) }
}
}
}
//判断是否当前线程
private func isCurrentQueue(_ queue: DispatchQueue) -> Bool {
let key = DispatchSpecificKey<UInt32>()
queue.setSpecific(key: key, value: arc4random())
defer { queue.setSpecific(key: key, value: nil) }
return DispatchQueue.getSpecific(key: key) != nil
}
}
- 提供销毁资源的实例
import Foundation
/*
*一个用于提供销毁资源的实例.
*把自身添加到DisposeBag里, DisposeBag在销毁的时候, 会顺便把此对象销毁.
*/
public final class Disposable {
///销毁后执行的闭包
let dispose: () -> Void
public init(_ dispose: @escaping () -> Void) {
self.dispose = dispose
}
deinit {
dispose()
}
///把自身添加到DisposeBag里, DisposeBag在销毁的时候, 会顺便把此对象销毁
public func dispose(by disposeBag: DisposeBag) {
disposeBag.add(self)
}
}
/*
*管理'disposableArr'的销毁, 自身销毁后, 所有的'disposableArr'也会销毁
*
*/
public final class DisposeBag {
private let lock: NSRecursiveLock = NSRecursiveLock()
private var disposableArr: [Disposable] = [Disposable]()
private var isDisposed = false
public init() {
}
deinit {
dispose()
}
/// 添加一个需要销毁的资源
public func add(_ disposable: Disposable) {
lock.lock()
defer { lock.unlock() }
if isDisposed { return }
disposableArr.append(disposable)
}
//移除所有Disposable
private func removeDisposableArr() -> [Disposable] {
lock.lock()
defer { lock.unlock() }
let disposableARR = self.disposableArr
self.disposableArr.removeAll(keepingCapacity: false)
self.isDisposed = true
return disposableARR
}
//销毁所有的Disable对象
private func dispose() {
let disposableARR = removeDisposableArr()
//执行每个Disable销毁前的闭包
for disposable in disposableARR {
disposable.dispose()
}
}
}
