我就不讲RxSwift的思想了，网上很多文章讲的都很好，我就不献丑了，咱们就直接进入正题，先看个栗子：
Observable<Int>.create { observe in
observe.onNext(1)
observe.onCompleted()
return Disposables.create()
}.subscribe(onNext: { res in
print(res)
}).disposed(by: disposeBag)
代码很简单，问大家一个问题，什么是可观察序列、什么是观察者，我们又是怎么创建的序列，怎么创建的观察者，哪部分是序列，哪部分又是观察者呢？ 带着这几个疑问，我们开始吧！
创建可观察序列 创建函数如下：
public static func create(_ subscribe: @escaping (AnyObserver<Element>) -> Disposable) -> Observable<Element> {
AnonymousObservable(subscribe)
}
creat返回了一个匿名的序列AnonymousObservable， 也就是说creat创建的就是一个序列，但是它有个内部有个AnyObserver，它才是发送数据的源。
继承链： AnonymousObservable -> Producer -> Observable -> ObservableType
ObservableType：是一个协议，有一个必须实现的订阅函数subscribe，也就是所有遵守自这个协议的类都要实现这个订阅函数。它还有一个asObservable默认实现函数，把'ObservableType'转换为'Observable'
Observable：是一个类型擦除的ObservableType，为了统一管理序列，所有的序列都继承自它，还有一个比较重要的功能就是计算订阅数，debug模式下方便处理Rx内存泄漏问题。
Producer：实现了subscribe函数，这个很重要一会再说。还有一个抽象函数run，所有继承自它的都需要实现run函数。子类并不要实现订阅函数，统一通过它处理
AnonymousObservable中有个闭包：subscribeHandler = (AnyObserver<Element>) -> Disposable，这个东西就是创建时候带进来的subscribe，还有个函数run，上面说过父类的run函数是抽象函数，
到此，creat函数 和 Producer中的subscribe函数都有了，来看看它具体是怎么传数据的。看个栗子：
开始的时候我们简要分析了creat函数，内部有发送数据的源AnyObserver，现在我们看看订阅函数subscribe函数做了什么，为什么有两个subscribe函数呢，接着往下看：
public func subscribe(
onNext: ((Element) -> Void)? = nil,
onError: ((Swift.Error) -> Void)? = nil,
onCompleted: (() -> Void)? = nil,
onDisposed: (() -> Void)? = nil
) -> Disposable {
let disposable: Disposable
if let disposed = onDisposed {
disposable = Disposables.create(with: disposed)
}
else {
disposable = Disposables.create()
}
let observer = AnonymousObserver<Element> { event in
switch event {
case .next(let value):
onNext?(value)
case .error(let error):
if let onError = onError {
onError(error)
}
disposable.dispose()
case .completed:
onCompleted?()
disposable.dispose()
}
}
return Disposables.create(
self.asObservable().subscribe(observer),
disposable
)
}
继承链： AnonymousObserver -> ObserverBase -> Disposable, ObserverType self.asObservable().subscribe(observer)执行Producer中的subscribe函数，可能有人会问这个self是哪个对象呢？看上面的creat函数，没错，就是AnonymousObservable，而self.asObservable()也什么都没做，就是返回了自己。此时就明白了为什么有两个subscribe函数，这是因为两个函数是顺序调用关系，那么也就可以理解为是一个函数。这个函数有个条件分支，用于线程问题上，一般会走else分支，所以直接看这里就行：
override func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
return CurrentThreadScheduler.instance.schedule(()) { _ in
let disposer = SinkDisposer()
let sinkAndSubscription = self.run(observer, cancel: disposer)
disposer.setSinkAndSubscription(sink: sinkAndSubscription.sink, subscription: sinkAndSubscription.subscription)
return disposer
}
}
先看一下ObserverType是什么，它是一个协议，有必须实现的函数func on(_ event: Event<Element>)，用于发送数据，函数还有三个默认实现函数：onNext、onCompleted、onError，分别用于发送event事件，event是一个枚举，如下：
enum Event<Element> {
case next(Element)
case error(Swift.Error)
case completed
}
没错，默认实现的函数分别发送就是这是三个事件。 这里有个self，它是谁呢？他就是creat创建的AnonymousObservable，简单的逻辑问题不要混了，调用的run函数，回到AnonymousObservable看看run函数做了什么：
let sink = AnonymousObservableSink(observer: observer, cancel: cancel)
let subscription = sink.run(self)
return (sink: sink, subscription: subscription)
继承链：AnonymousObservableSink -> Sink、ObserverType， Sink -> Disposable， 看一下AnonymousObservableSinkrun函数做了什么，实现如下：
func run(_ parent: Parent) -> Disposable {
parent.subscribeHandler(AnyObserver(self))
}
Sink中有个属性observer，它就是上面subscribe函数中用于接收数据的AnonymousObserver，还有一个final函数forwardOn。然后接着分析sink.run(self)干了什么，parent实际上就是AnonymousObservable，subscribeHandler这个闭包就是creat的闭包。AnyObserver(self) 这个玩意是啥呢？
上面也说过， subscribeHandler = (AnyObserver<Element>) -> Disposable，那就明白了呀，看上面的例子，发送事件 observe.onNext(1)和observe.onCompleted()，这个observe其实就是AnyObserver(self) ，那也就是说我们再把AnyObserver(self) 弄明白了，就一切真相大白了。先看看AnyObserver这个结构体里面有啥：
struct AnyObserver<Element> : ObserverType {
public typealias EventHandler = (Event<Element>) -> Void
private let observer: EventHandler
public init(eventHandler: @escaping EventHandler) {
self.observer = eventHandler
}
public init<Observer: ObserverType>(_ observer: Observer) where Observer.Element == Element {
self.observer = observer.on
}
public func on(_ event: Event<Element>) {
self.observer(event)
}
public func asObserver() -> AnyObserver<Element> {
self
}
}
我们可以知道AnyObserver(self) 中self是AnonymousObservableSink这个类。所以会执行这个：self.observer = observer.on，也就是说AnyObserver中的observer就是AnonymousObservableSink中的on函数，on函数之前也说过它是发送事件的函数。看一下实现：
func on(_ event: Event<Element>) {
switch event {
case .next:
self.forwardOn(event)
case .error, .completed:
if fetchOr(self.isStopped, 1) == 0 {
self.forwardOn(event)
self.dispose()
}
}
}
每个case分支都执行了forwardOn函数，再看一下它干了什么：
final func forwardOn(_ event: Event<Observer.Element>) {
if isFlagSet(self.disposed, 1) {
return
}
self.observer.on(event)
}
上面已经分析了Sink中的属性observer就是上面subscribe函数中的AnonymousObserver，我们进入类文件中一探究竟，有一个闭包：eventHandler = (Event<Element>) -> Void，还有一个onCore函数，没找到on函数，那再进入父类中看一下ObserverBase，😄一眼就看到了on函数：
func on(_ event: Event<Element>) {
switch event {
case .next:
self.onCore(event)
case .error, .completed:
self.onCore(event)
}
}
它还有一个抽象函数onCore，必须由子类实现，正好在AnonymousObserver类中重写了这个函数。我们再看看onCore干了什么：
override func onCore(_ event: Event<Element>) {
self.eventHandler(event)
}
那么你是否已经明白self.eventHandler(event)会执行到哪呢？，看subscrebe中创建的观察者：
let observer = AnonymousObserver<Element> { event in
switch event {
case .next(let value):
onNext?(value)
case .error(let error):
if let onError = onError {
onError(error)
}
disposable.dispose()
case .completed:
onCompleted?()
disposable.dispose()
}
}
这个大闭包就是eventHandler，self.eventHandler(event)发送的就是枚举事件。
终于捋顺了 创建、订阅、发送、接收的所有逻辑了。当然了，这个只是RxSwift基础中的一小部分，其他的我也会在之后的学习过程中记录下来。 如果哪说的有问题欢迎大家指正，不要让我一直错下去😄，还有我以前很少写文章，有什么不好的地方欢迎大家提意见或者建议。那么开头说的几个小问题你是否明白了呢？
总结： 我使用了RxSwift一年多了，以前也跟着网上的文章看了源码，但是这种方式我感觉对我没啥用，有点牵着鼻子走的感觉。过了一段时间又忘了，而且之后再看源码还是不知道从何下手。这次我完全不依赖文章，独立看源码，捋逻辑，感觉还行， RxSwift的源码并没有那么难懂，就是很绕，绕来绕去就懵了，还得从头捋，太难受了。
还有我要提醒一下大家，我最近面试了一个用RxSwift的公司，问的也不深，无奈自己没准备，RxSwift连基本的思想都忘了，其实也不觉得可惜，也是预料之中的事。我大约每隔两三个月就会面试一两次，一来看看机会，而来看看自己啥水平😄，不出所料，每次不复习，一些概念的东西都不记得，概念性质的东西总是忘，技术水平还是菜菜的😄。
话说回来，不管你这份工作怎么样，我都建议你每隔一段时间去中大厂面面。面试其实也是学习！各位加油！
