我们在使用RxSwift进行响应式编程时，都会引入另一个库RxCocoa，RxCocoa是Rx对iOS的原生API中UIKit以及Foundation中的视图(UIView)、控制事件(Control Event)、键值观察（KVO）、通知（Notification）等的扩展，以便在开发时更方便的对系统的这些原生组件进行Rx应用。例如：
//registerButton是一个UIButton，通过.rx.tap能获取到该button的点击事件序列
_ = registerButton.rx.tap.shareReplay(1).subscribe {(_) in
//订阅者获取到按钮点击的事件，再做处理
}.disposed(by: disposeBag)
//nameTextField是一个UITextField控件，可以直接通过.rx.text获取到该控件中输入内容的String序列
_ = nameTextField.rx.text.shareReplay(1).subscribe {(text) in
//订阅者实时获取到text内容，再做处理
}.disposed(by: disposeBag)
上述例子中通过registerButton.rx.tap，我们可以获取该button的点击事件序列，而nameTextField.rx.text给我们提供了UITextField中的文本String的序列，这就像我们通过正常的编码方式获取到的一样：
//给registerButton添加Target和点击事件
registerButton.addTarget(self, action: #selector(registerButtonClick), for: .touchUpInside)
@objc func registerButtonClick(){
//注册按钮点击了
}
//nameTextField通过通知观察获得UITextField变化的文本
NotificationCenter.default.addObserver(self, selector: #selector(registerButtonClick), name: NSNotification.Name.UITextFieldTextDidChange, object: nil)
@objc func nameTextFieldValueChanged(){
//获取到UITextField的text
}
对比两者不难发现，系统原生的方法有种割裂感，而RxCocoa提供的被观察者以及订阅的模式更符合我们正常思考的模式，在事件发生变化后及时作出回应，而这正是RxSwift响应式编程的核心思想。要达到这种响应式编程的前提条件就是先得有一个可被观察的序列Observable，而RxCocoa中又是怎么将UIButton和UITextField这些继承于UIControl的控件的控制事件转化为一个个不同的Observable事件序列的呢，本篇文章就以UIButton和UITextField为例，探寻RxCocoa源码中的奥秘。
Observable的创建
RxSwift中，在Observable的扩展类里提供了一系列创建被观察对象的工厂化方法。例如通过never、empty、just、of等来创建不同的Observable序列，例如：
Observable.just("🔴")
.subscribe { event in
print(event)
}
.disposed(by: disposeBag)
Observable.of("🐶", "🐱", "🐭", "🐹")
.subscribe(onNext: { element in
print(element)
})
.disposed(by: disposeBag)
但如何将一个UIControl的Control Event（包括将来即将发生的点击事件、text变化等等）也转换成对应的序列呢，以上方法好像并不适用，这时就需要用到自定义创建Observable方法了，来看看官方示例：
let myJust = { (element: String) -> Observable<String> in
return Observable.create { observer in
observer.on(.next(element))
observer.on(.completed)
return Disposables.create()
}
}
myJust("🔴").subscribe {
print($0)
}.disposed(by: disposeBag)
通过Observable.create方法可以得到一个Observable<E>序列，E是一个泛型类型，在上述例子中E就是String类型
public static func create(_ subscribe: @escaping (AnyObserver<E>) -> Disposable) -> Observable<E> {
return AnonymousObservable(subscribe)
}
而要想达到持续发送事件的目的，只要在@escaping (AnyObserver<E>) -> Disposable) 这个闭包中进行observer.on(.next(element))操作就可以将由element构成的序列发送给订阅者了。
注意：此处的观察者AnyObserver<E>的观察类型E与你生成的被观察者类型Observable<E>的E要确保一致。而RxCocoa中正是在UIControl扩展中使用了自定义创建Observable.create方法来处理并转化对应的事件。
UIControl+Rx
下面分别以UIButton和UITextField为例，来探寻UIControl+Rx这个Reactive限定扩展中的秘密。（关于限定扩展可以看我上一篇文章）
先来看通过UIButton.rx.tap我们得到了一个什么东西：
extension Reactive where Base: UIButton {
/// Reactive wrapper for `TouchUpInside` control event.
public var tap: ControlEvent<Void> {
return controlEvent(.touchUpInside)
}
}
我们得到一个ControlEvent<Void>,而ControlEvent<Void>是什么呢
//ControlEvent<Void>遵循ControlEventType协议
public struct ControlEvent<PropertyType> : ControlEventType
//ControlEventType遵循ObservableType协议
public protocol ControlEventType : ObservableType
而我们知道，遵循ObservableType就可以当做一个Observable序列，所以通过对UIButton的.rx.tap我们得到了一个不含任何数据（即Void）的事件序列，再来进一步对源码分析，此处返回的ControlEvent<Void>是通过controlEvent(.touchUpInside)得到的，来看controlEvent方法：
extension Reactive where Base: UIControl {
/// - parameter controlEvents: Filter for observed event types.
///此处传入UIControlEvents控制事件类型，以上UIButton传入的是.touchUpInside点击事件
public func controlEvent(_ controlEvents: UIControlEvents) -> ControlEvent<Void> {
//通过Observable.create自定义创建一个Observable
let source: Observable<Void> = Observable.create { [weak control = self.base] observer in
MainScheduler.ensureExecutingOnScheduler()
guard let control = control else {
observer.on(.completed) // 如果self.base为空，则发送完成事件
return Disposables.create()
}
//通过控件control和事件controlEvents初始化一个ControlTarget类，
//在control触发controlEvents事件时，通过闭包回调回来（详见后面）
let controlTarget = ControlTarget(control: control, controlEvents: controlEvents) { control in
observer.on(.next()) //一旦有回调，就给订阅者发送事件
}
return Disposables.create(with: controlTarget.dispose)
}.takeUntil(deallocated)
//将自定义序列source包装成ControlEvent返回
return ControlEvent(events: source)
}
ControlTarget
以上源码中最关键是ControlTarget这个初始化方法，通过控件control（UIButton、UITextField等等）和事件controlEvents初始化一个ControlTarget类，在control触发controlEvents事件时，通过闭包回调回来
final class ControlTarget: RxTarget {
typealias Callback = (Control) -> Void
let selector: Selector = #selector(ControlTarget.eventHandler(_:))
weak var control: Control?
#if os(iOS) || os(tvOS)
let controlEvents: UIControlEvents
#endif
var callback: Callback?
#if os(iOS) || os(tvOS)
//传入控件control（UIButton、UITextField等等）和事件controlEvents
init(control: Control, controlEvents: UIControlEvents, callback: @escaping Callback) {
MainScheduler.ensureExecutingOnScheduler()
self.control = control
self.controlEvents = controlEvents
self.callback = callback //等待self.callback回调
super.init()
//将controlEvents事件添加到自己，响应selector方法
control.addTarget(self, action: selector, for: controlEvents)
let method = self.method(for: selector)
if method == nil {
rxFatalError("Can't find method")
}
}
该事件触发的方法为#selector(ControlTarget.eventHandler(_:))，eventHandler方法是怎么处理的呢，
let selector: Selector = #selector(ControlTarget.eventHandler(_:))
//控制事件controlEvents所需要触发的方法
func eventHandler(_ sender: Control!) {
if let callback = self.callback, let control = self.control {
callback(control) //在self.control和callback都不为空时 回调
}
}
一目了然，通过上面的callback(control) 我们就能在下面这个回调函数中给订阅者发送事件了
let controlTarget = ControlTarget(control: control, controlEvents:controlEvents) { control in
observer.on(.next()) //一旦有回调，就给订阅者发送事件
}
同理，我们再来看看UITextField.rx.text生成String可观察序列的代码：
extension Reactive where Base: UITextField {
/// Reactive wrapper for `text` property.
public var text: ControlProperty<String?> {
return value
}
/// Reactive wrapper for `text` property.
public var value: ControlProperty<String?> {
//UIControl.rx.value方法是关键
return UIControl.rx.value(
base,
getter: { textField in
textField.text
}, setter: { textField, value in
// This check is important because setting text value always clears control state
// including marked text selection which is imporant for proper input
// when IME input method is used.
if textField.text != value {
textField.text = value
}
}
)
}
}
接着看UIControl.rx.value这个方法的源码：
//参数为控件本身，其他分别为两个闭包，
//其中getter是用来获取UITextField的text值发送给订阅者，setter是设置数值
static func value<C: UIControl, T>(_ control: C, getter: @escaping (C) -> T, setter: @escaping (C, T) -> Void) -> ControlProperty<T> {
let source: Observable<T> = Observable.create { [weak weakControl = control] observer in
guard let control = weakControl else {
observer.on(.completed)
return Disposables.create()
}
observer.on(.next(getter(control))) //订阅后首次发送事件
//通过ControlTarget来监听UITextField所有跟编辑有关以及值修改的控制事件
let controlTarget = ControlTarget(control: control, controlEvents: [.allEditingEvents, .valueChanged]) { _ in
if let control = weakControl {
observer.on(.next(getter(control))) //一旦有变化就发送给订阅者
}
}
return Disposables.create(with: controlTarget.dispose)
}
.takeUntil((control as NSObject).rx.deallocated)
let bindingObserver = UIBindingObserver(UIElement: control, binding: setter)
return ControlProperty<T>(values: source, valueSink: bindingObserver)
}
通过ControlTarget来监听UITextField所有跟编辑有关以及value值发生改变的控制事件，最后生成一个ControlProperty类型的Observable可观察序列，然后发送给订阅者。
以上就是RxCocoa中如何通过自定义创建Observable，将UIControl控件的控制事件转化为Observable可观察序列的。
网友评论