RxSwift 下代理转可观察序列的源码解析

2023-11-16 00:35:55

今天我们来聊聊 RxSwift 下代理转可观察序列的源码解析。代理是一种设计模式，它允许一个对象（委托方）将责任委托给另一个对象（代理方）。在 RxSwift 中，代理可以很容易地转换为可观察序列，这使得我们可以使用 RxSwift 的强大操作符来处理代理事件。

一、新建封装代理类

1、WSLProtocol 类

protocol WSLProtocol {
    func doSomething()
}

2、WSLClass 类

class WSLClass: WSLProtocol {
    func doSomething() {
        print("doSomething")
    }
}

3、RxWSLDele 代理

class RxWSLDele: NSObject, WSLProtocol {
    let doSomething = PublishSubject<Void>()
    
    func doSomething() {
        doSomething.onNext(())
    }
}

二、将代理转换为可观察序列

1、Observable.create

我们可以使用 Observable.create 方法将代理转换为可观察序列。Observable.create 方法接收一个参数，这个参数是一个闭包，闭包的第一个参数是观察者，第二个参数是可销毁的对象。在闭包中，我们可以使用观察者来发出事件，也可以使用可销毁的对象来控制观察者的生命周期。

let observable = Observable.create { (observer) -> Disposable in
    let delegate = RxWSLDele()
    delegate.doSomething.subscribe(onNext: {
        observer.onNext(())
    }, onError: { (error) in
        observer.onError(error)
    }, onCompleted: {
        observer.onCompleted()
    })
    
    return Disposables.create {
        delegate.doSomething.onCompleted()
    }
}

2、delegate 方法

代理方法也是一种将代理转换为可观察序列的方法。delegate 方法接收一个参数，这个参数是一个代理对象。在 delegate 方法中，我们可以使用代理对象来发出事件。

extension RxWSLDele: DelegateProxy {
    public static func registerKnownImplementations() {
        self.register { (parent: RxWSLDele) -> Observable<Void> in
            parent.doSomething.asObservable()
        }
    }
}

三、使用可观察序列

一旦我们将代理转换为可观察序列，我们就可以使用 RxSwift 的强大操作符来处理代理事件。例如，我们可以使用 filter 操作符来过滤代理事件，也可以使用 map 操作符来转换代理事件。

observable.filter { (value) -> Bool in
    return value == true
}
.map { (value) -> String in
    return "doSomething: \(value)"
}
.subscribe(onNext: { (value) in
    print(value)
}, onError: { (error) in
    print(error)
}, onCompleted: {
    print("completed")
})