我们会有这样的需求: 在搜索框中输入搜索关键字,然后发起请求，将请求的结果分别显示在2个不同的控件上。
这个需求需要满足以下条件:
1.输入框内容改变一次,需要请求一次网络获取结果。
2.结果绑定到UI,对于UI的操作需要在主线程执行。
3.处理错误,防止序列终止
实现方法一:
let result = inputTF.rx.text.skip(1)
.flatMap { [weak self](input) -> Observable<Any> in
return (self?.dealwithData(inputText:input ?? ""))!
.observeOn(MainScheduler())
.catchErrorJustReturn("检测到了错误事件")
}.share(replay: 1, scope: .whileConnected)
result.map{ "\($0 as! String)" }
.bind(to: textLabel.rx.text)
.disposed(by: disposeBag)
result.map{ "\($0 as! String)" }
.bind(to: btn.rx.title())
.disposed(by: disposeBag)
func dealwithData(inputText:String)-> Observable<Any>{
print("请求网络了 \(Thread.current)") // data
return Observable<Any>.create({ (ob) -> Disposable in
if inputText == "1234" {
ob.onError(NSError.init(domain: "xxx", code: 10086, userInfo: nil))
}
DispatchQueue.global().async {
print("发送之前看看: \(Thread.current)")
ob.onNext("已经输入:\(inputText)")
ob.onCompleted()
}
return Disposables.create()
})
}
这种方法虽然能实现这个需求,但是代码相对比较恶心,每一次都要指定主线程,指定请求共享等等。 对于这种实现方法,我们肯定是不会满意的。那么RxSwift有没有提供一套应对类似这样需求的方案呢? 答案是肯定的,那就是RxSwift-Driver。
RxSwift-Driver
1、Driver 可以说是最复杂的 trait，它的⽬标是提供一种简便的⽅式在 UI 层编写响应式代码。
2、如果我们的序列满⾜如下特征，就可以使用它:
(1)、不会产⽣ error 事件
(2)、一定在主线程监听(MainScheduler)
(3)、共享状态变化(shareReplayLatestWhileConnected)
3、为什要使⽤Driver?
(1)Driver 最常使⽤的场景应该就是需要⽤序列来驱动应用程序的情况了，⽐如:
• 通过 CoreData 模型驱动 UI
• 使用⼀个 UI 元素值(绑定)来驱动另⼀个 UI 元素值
(2)与普通的操作系统驱动程序⼀样，如果出现序列错误，应⽤程序将停⽌响应⽤户输入。
(3)在主线程上观察到这些元素也是极其重要的，因为 UI 元素和应用程序逻辑通常不是线程安全的。
(4)此外，使⽤构建 Driver 的可观察的序列，它是共享状态变化。
RxSwift-Driver的实现:
let result = inputTF.rx.text.orEmpty
.asDriver()
.flatMap {
return self.dealwithData(inputText: $0)
.asDriver(onErrorJustReturn: "检测到了错误事件")
}
result.map { "长度: \(($0 as! String).count)"}.drive(self.textLabel.rx.text)
result.map { "\($0 as! String)"}
.drive(self.btn.rx.title())
RxSwift-Driver源码分析
以asDriver作为源码分析切入点:
extension ControlProperty {
/// Converts `ControlProperty` to `Driver` trait.
///
/// `ControlProperty` already can't fail, so no special case needs to be handled.
public func asDriver() -> Driver<Element> {
return self.asDriver { _ -> Driver<Element> in
#if DEBUG
rxFatalError("Somehow driver received error from a source that shouldn't fail.")
#else
return Driver.empty()
#endif
}
}
}
进入self.asDriver
public func asDriver(onErrorRecover: @escaping (_ error: Swift.Error) -> Driver<Element>) -> Driver<Element> {
let source = self
.asObservable()
.observeOn(DriverSharingStrategy.scheduler)
.catchError { error in
onErrorRecover(error).asObservable()
}
return Driver(source)
}
返回是Driver(source),看看Driver
public typealias Driver<Element> = SharedSequence<DriverSharingStrategy, Element>
Driver并不是一个类，而是一个序列的别名。RxSwift的类都比较恶心,为了方便记忆，弄个别名也正常。
进入具体类型SharedSequence
public struct SharedSequence<SharingStrategy: SharingStrategyProtocol, Element> : SharedSequenceConvertibleType {
let _source: Observable<Element>
init(_ source: Observable<Element>) {
self._source = SharingStrategy.share(source)
}
进入share
public struct DriverSharingStrategy: SharingStrategyProtocol {
public static var scheduler: SchedulerType { return SharingScheduler.make() }
public static func share<Element>(_ source: Observable<Element>) -> Observable<Element> {
return source.share(replay: 1, scope: .whileConnected)
}
}
SharingStrategy是一个关联类型,它实际类型是DriverSharingStrategy。因此来到DriverSharingStrategy.share，DriverSharingStrategy.share中调用了source.share,就是方法一调用的.share(replay: 1, scope: .whileConnected)
接下来继续分析self.asDriver中的source
let source = self
.asObservable()
.observeOn(DriverSharingStrategy.scheduler)
.catchError { error in
onErrorRecover(error).asObservable()
}
1.调用了asObservable,说明是一个序列
2.指定调度者DriverSharingStrategy.scheduler
public static var scheduler: SchedulerType { return SharingScheduler.make() }
public enum SharingScheduler {
/// Default scheduler used in SharedSequence based traits.
public private(set) static var make: () -> SchedulerType = { MainScheduler() }
}
public final class MainScheduler : SerialDispatchQueueScheduler {
private let _mainQueue: DispatchQueue
/// Initializes new instance of `MainScheduler`.
public init() {
self._mainQueue = DispatchQueue.main
super.init(serialQueue: self._mainQueue)
}
}
使用了主队列,指定在主线程中执行.
3.catchError调用外部error处理,这里不再展开说明。
.drive(self.btn.rx.title()),使用drive将内容订阅到UI上,
public func drive<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
MainScheduler.ensureRunningOnMainThread(errorMessage: errorMessage)
return self.asSharedSequence().asObservable().subscribe(observer)
}
将self.btn.rx.title()作为观察者,订阅序列。
总结
RxSwift-Driver 其实就是对方法一的封装,将指定主线程执行、错误处理、共享状态变化共享状态变化进行封装, 外界只需要使用。
