平常我们使用 RxSwift 的时候，一般不会去直接使用 delegate，譬如要处理 tableView 的点击事件，我们会这样：tableView.rx.itemSelected.subscribe(onNext: handleSelectedIndexPath)，这跟先设置一个 delegate，然后在 delegate 的tableView(_:didSelectRowAt:)方法中调用handleSelectedIndexPath的效果是一样的。那这个过程到底是如何进行的呢？我们进入 RxCocoa 的 UITableView+Rx.swift 文件来一探究竟，这个文件中不仅有itemSelected，还有诸如itemDeselected、itemAccessoryButtonTapped、itemInserted、itemDeleted、itemMoved等等一系列对应 tableView delegate 的包装方法，本文就以itemSelected为例，其他的都是相同的原理。为便于理解，我会给源码加一点中文注释，：
/**
Reactive wrapper for `delegate` message `tableView:didSelectRowAtIndexPath:`.
*/
public var itemSelected: ControlEvent<IndexPath> {
// delegate: PublishSubject<[AnyObject]>，[AnyObject]表示 selector 的参数列表
let source = self.delegate.observe(#selector(UITableViewDelegate.tableView(_:didSelectRowAt:)))
.map { a in
// 转化第二个参数的类型为 IndexPath
return try castOrThrow(IndexPath.self, a[1])
}
// 包装成一个 ControlEvent 返回，ControlEvent 其实只是在 source 外套了层壳，保证操作会在主线程进行而已
return ControlEvent(events: source)
}
这个方法是写在extension Reactive where Base: UITableView里的，想必大家应该清楚这只是为了给扩展加一个命名空间，Reactive<Base>是一个范型 struct，它有一个 base 属性，Reactive 对外暴露的方法实际上都会转发给 base。这块如果大家不清楚的话可以看一下 Reactive.swift 文件，由于不是本文的重点就不细说了，可以理解为extension Reactive where Base: UITableView中的方法其实就是给UITableView加的扩展方法。
DelegateProxy
几个关键的地方我都加了中文注释，大家应该能明白。值得注意的是，这个方法里出现的self.delegate属性并不在本文件中，那我们推测应该是在别的 Reactive extension 中，跳到 UIScrollView+Rx.swift 看一下，果不其然：
extension Reactive where Base: UIScrollView {
// ...
public var delegate: DelegateProxy {
return RxScrollViewDelegateProxy.proxyForObject(base)
}
// ...
原来 delegate 啊是一个 DelegateProxy 类型（代理的代理^ ^）……这个proxyForObject方法显然是接收一个对象（本文中这个对象是个 tableView 实例），然后返回其代理。那我们看一下 RxScrollViewDelegateProxy 这个类，却并没有发现proxyForObject这个方法，这时我看了眼它的类声明：
/**
For more information take a look at `DelegateProxyType`.
*/
public class RxScrollViewDelegateProxy
: DelegateProxy
, UIScrollViewDelegate
, DelegateProxyType {
注释上写着 “For more information take a look at DelegateProxyType.”，想必我们能从 DelegateProxyType 这个协议里发现点什么，嗯，果然在这个协议的 extension 里发现了proxyForObject：
extension DelegateProxyType {
/**
Returns existing proxy for object or installs new instance of delegate proxy.
- parameter object: Target object on which to install delegate proxy.
- returns: Installed instance of delegate proxy.
*/
public static func proxyForObject(_ object: AnyObject) -> Self {
MainScheduler.ensureExecutingOnScheduler()
let maybeProxy = Self.assignedProxyFor(object) as? Self
let proxy: Self
if let existingProxy = maybeProxy {
proxy = existingProxy
}
else {
proxy = Self.createProxyForObject(object) as! Self
Self.assignProxy(proxy, toObject: object)
assert(Self.assignedProxyFor(object) === proxy)
}
let currentDelegate: AnyObject? = Self.currentDelegateFor(object)
if currentDelegate !== proxy {
proxy.setForwardToDelegate(currentDelegate, retainDelegate: false)
assert(proxy.forwardToDelegate() === currentDelegate)
Self.setCurrentDelegate(proxy, toObject: object)
assert(Self.currentDelegateFor(object) === proxy)
assert(proxy.forwardToDelegate() === currentDelegate)
}
return proxy
}
这个方法看着很长，其核心是通过assignedProxyFor(object)去拿 tableView 实例的关联代理 proxy，如果没有的话，就先用createProxyForObject(object)创建一个代理，然后用assignProxy(proxy, toObject object)将 proxy 设置为 tableView 实例的关联对象。如果这个 tableView 实例还未设置 delegate，就调用setCurrentDelegate(proxy, toObject: object)将 tableView 的 delegate 设置为 proxy，最后返回 proxy。这里使用的几个方法并没有在协议扩展里实现，而是分别在DelegateProxy和RxScrollViewDelegateProxy中实现的，先看DelegateProxy中：
public class func createProxyForObject(_ object: AnyObject) -> AnyObject {
return self.init(parentObject: object)
}
public class func assignedProxyFor(_ object: AnyObject) -> AnyObject? {
// 得到关联代理
let maybeDelegate = objc_getAssociatedObject(object, self.delegateAssociatedObjectTag())
return castOptionalOrFatalError(maybeDelegate.map { $0 as AnyObject })
}
public class func assignProxy(_ proxy: AnyObject, toObject object: AnyObject) {
precondition(proxy.isKind(of: self.classForCoder()))
// 设置关联代理
objc_setAssociatedObject(object, self.delegateAssociatedObjectTag(), proxy, .OBJC_ASSOCIATION_RETAIN)
}
这些都很好理解，然后setCurrentDelegate的实现在RxScrollViewDelegateProxy中，值得一提的是，createProxyForObject在RxScrollViewDelegateProxy中也被重写了，我们来看一下：
public class RxScrollViewDelegateProxy
: DelegateProxy
, UIScrollViewDelegate
, DelegateProxyType {
// ...
public override class func createProxyForObject(_ object: AnyObject) -> AnyObject {
let scrollView = (object as! UIScrollView)
// 调用 UITableView 的 createRxDelegateProxy 方法，返回一个 RxTextViewDelegateProxy 实例
return castOrFatalError(scrollView.createRxDelegateProxy())
}
public class func setCurrentDelegate(_ delegate: AnyObject?, toObject object: AnyObject) {
let scrollView: UIScrollView = castOrFatalError(object)
scrollView.delegate = castOptionalOrFatalError(delegate)
}
// ...
}
extension UITableView {
public override func createRxDelegateProxy() -> RxScrollViewDelegateProxy {
return RxTableViewDelegateProxy(parentObject: self)
}
// ...
对于 tableView 来说，createProxyForObject返回的实际上是一个RxTableViewDelegateProxy，我们看一下它的声明：
public class RxTableViewDelegateProxy
: RxScrollViewDelegateProxy
, UITableViewDelegate
绑定 selector 和 subject
好的，现在我们已经知道开头itemSelected中出现的self.delegate是什么了，接下来看看self.delegate.observe又做了啥，我们回到DelegateProxy中：
open class DelegateProxy : _RXDelegateProxy {
private var subjectsForSelector = [Selector: PublishSubject<[AnyObject]>]()
// ...
// 将 selector(返回值是 void） 和一个 subject 关联，通过 subject 发送事件给 obsevers
public func observe(_ selector: Selector) -> Observable<[AnyObject]> {
if hasWiredImplementation(for: selector) {
print("Delegate proxy is already implementing `\(selector)`, a more performant way of registering might exist.")
}
if !self.responds(to: selector) {
rxFatalError("This class doesn't respond to selector \(selector)")
}
// 已经存在对应这个 selector 的 subject
let subject = subjectsForSelector[selector]
if let subject = subject {
return subject
}
else {
// 尚未创建该 selector 对应的 subject，先创建一个
let subject = PublishSubject<[AnyObject]>()
// 缓存到字典中
subjectsForSelector[selector] = subject
return subject
}
}
// ...
注释已经写清楚了，这个方法第一次会把 selector 和一个新建的 subject 绑定，缓存到字典中，之后就通过 selector 来取对应的 subject。接着我在这个方法的下面看到了另一个方法：
// 父类 _RXDelegateProxy 重写了 forwardInvocation 方法，forwardInvocation 中会调用本方法
open override func interceptedSelector(_ selector: Selector, withArguments arguments: [Any]) {
// selector 对应的 subject 发送一个包含 selector 参数列表的事件
subjectsForSelector[selector]?.on(.next(arguments as [AnyObject]))
}
这个方法接收一个 selector 和其参数列表，以 selector 为 key 找到对应的 subject，subject 发射一个包含 selector 参数列表的 next 事件。显然这个方法的调用时机是个关键，这里就用到了 Runtime 的消息转发（Runtime 相关的东西网上有很多资料，也不是本文的重点，我就不细说了），我在注释里也写了，DelegateProxy的父类_RXDelegateProxy重写了forwardInvocation方法，在里面调用了interceptedSelector方法。这样一来，当某个 selector 要被调用时，由于 proxy 对象没有对应实现，最后会走 forwardInvocation 把消息转发给 interceptedSelector，对应的 subject 发送包含参数列表的事件给所有 observer，整个过程就走通了。
小结
我在文中讲述了自己阅读源码的心路历程，如何按图索骥，一步步理清整个过程，兴许对那些想要阅读源码却不知如何入手的朋友会有帮助。
水平有限，如有错漏，欢迎指出～
