RxSwift

为什么要学习RxSwift

使用RxSwift可以统一的处理Delegate、KVO、Notification，可以绑定UI，方便网络请求的处理等。

RxSwift可以再单向的数据流的各个阶段都发挥作用，从而让Data的处理和流动更加的简洁和清晰。

1:通过对RxCocoa的各种回调进行统一的处理，方便了interact的处理。

2:通过对Observable的transform和composite,方便了Action的生成。

3:通过对网络请求以及其他异步数据的获取进行Observable的封装，方便了异步数据的处理。

4:通过 RxCocoa 的 binding，方便了数据的渲染。

什么是RxSwift

在说RxSwift之前，先来说下Rx，ReactiveX是一种编程模型，最初由微软开发，结合了观察者模式、迭代器模式、函数式编程的精华，来更方便地处理异步数据流。其中最重要的一个概念是Observable。

举一个简单的例子，当别人在跟你讲话时，你就是那个观察者，别人就是那个observable,它有几个特点：

1:可能会不断的跟你说话。(onNext:)

2:可能会说错话。(onError:)

3:结束会说话。(onCompleted:)

在听别人说的话后，也可以有几种反应：

1:根据说的话，做相应的事。（subscribe）

2:把对方说的话，加工下再传达给其他人。(map:)

3:参考其他人说的话再做处理。(zip:)

RxSwift  Workflow

大致分为这么几个阶段：先把Native Object变成Observable,再通过Observable内置的各种强大的转换和组合能力变成新的Observable,最后消费新的Observable的数据。

Native Object -> Observable

.rx extension

假设需要处理点击事件，正常的做法是给Tab Gesture添加一个Target-Action,然后在那里实现具体的逻辑，这样的问题在于需要重新取名字，而且丢失了上下文。RxSwift(确切的说是RxCocoa) 给系统的诸多原生控件（包括像URLSession）提供了rx扩展，所以点击的处理变成了这样：

let  tapBackground = UITapGestureRecognizer()

tapBackground.rx.event.subscribe(onNext:{[weakself]_in  

       self?.view.endEditing(true)

}).addDisposableTo(disposeBag)

view.addGestureRecognizer(tapBackground)

Observable.create

通过这个方法，可以将Native的object包装成Observable

public  func   response(_  param: Sring) -> Observable<Data>{

         return Observable.create{ observer in 

                  let task = self.dataTask(param){ (data) 

                         observer.on(.next(data))

                         observer.on(.completed)

                 }

                 task.resume()

                 return Disposables.create{

                          task.cancel()

                 }

         }

}

调用：

let disposeBag = DisposeBag()

response("ceshi").subscribe(onNext:{ data in

        print(data)

}).addDisposableTo(disposeBag)

详解：

1:Observerable返回的是一个Disposable，当执行dealloc时，会顺便执行一下Disposable.dispose()，之前创建Disposable时申请的资源就会被一并释放掉。

2:如果有多个subscriberl来subscribe（订阅）response（）那么会创建多个请求，来一个observer就创建一个task,然后执行。如何让多个subscriber共享一个结果？看下文。。

Variable()

Variable(value)可以把value变成一个Observable，不过前提是使用新的赋值方式

aVariable.value = newValue

letmagicNumber=42

letmagicNumberVariable=Variable(magicNumber)

magicNumberVariable.asObservable().subscribe(onNext:{

print("magic number is\($0)")

})

magicNumberVariable.value=73

// magic number is 42

// magic number is 73

跟进去看了下，发现是通过subject来做的，大意是把value存到一个内部变量_value里，当调用value方法时，先更新_value值，然后调用内部的_subject.on(.next(newValue))方法告知 subscriber。

Subject

Subject简单来说是一个可以主动发射数据的Observable,多了onNext(value),onError(error),onCompleted()方法。

let disposeBag=DisposeBag()

let subject=PublishSubject()

subject.addObserver("1").addDisposableTo(disposeBag)

subject.onNext("🐶")

subject.onNext("🐱")

subject.addObserver("2").addDisposableTo(disposeBag)

subject.onNext("🅰️")

subject.onNext("🅱️")

在RAC时代，subject是一个不太推荐使用的功能，因为过于强大，容易失控。虽然RxSwift里没有提及太多，但还是少用为佳。

Observable -> New Observable

Observable的强大不仅在于它能实时更新value,还在于它能够被修改、过滤、组合等。这样就可以灵活的构造自己想要的数据，还不用担心数据发生变化了却不知道的情况。

combine就是把多个Observable组合起来使用，比如zip,zip对应现实的例子就是拉链，拉链需要两个元素才可以拉上去。只有当两个Observable都有了新的值时，subscribe才会被触发。

let stringSubject=PublishSubject()

let intSubject=PublishSubject()

Observable.zip(stringSubject,intSubject){stringElement,intElement in

"\(stringElement)\(intElement)"

}.subscribe(onNext:{print($0)

}).addDisposableTo(disposeBag)

stringSubject.onNext("🅰️")

stringSubject.onNext("🅱️")

intSubject.onNext(1)

intSubject.onNext(2)

// output

//// 🅰️ 1

// 🅱️ 2

如果intSubject始终没有执行onNext,那么将不会有输出，就像拉链少了一边的拉链就拉不上去了。

除了zip，还有其他的combine的方式，比如combineLatest/switchLatest等。

Transform:这是最常见的操作了，对一个Observable的数值做一些小改动，然后产出新的值，依旧是一个Observable。

let disposeBag = DisposeBag()

Observable.of(1,2,3).map{$0*$0}.subscribe(onNext:{

print($0)

}).addDisposableTo(disposeBag)

接受一个 transform 闭包，然后返回一个Observable，因为接下来使用者将会对myMap的结果进行 subscribe，所以需要在 create 内部 subscribe 一下，不然最开始的那个Observable就是个Cold Observable，一个Cold Observable是不会产生新的数据的。

Filter:是对Observable传过来的数据进行过滤，只有符合条件的才有资格被 subscribe。

Connect：在之前介绍Observable.create时有提到过，一个Observable被多次 subscribe 就会被多次触发，如果一个网络请求只想被触发一次，同时支持多个 subscriber，就可以使用publish+connect的组合。

当一个Observable使用了publish()方法后，正常的 subscribe 就不会触发它了，除非connect()方法被调用。而且每次 subscribe 不会导致Observable重新针对 observer 处理一遍。

Subscription 为什么要 Dispose？

因为有了Subscriber所以Observable被激活，然后内部就会使用各种变量来保存资源，如果不dispose的话，这些资源就会一直被 keep，很容易造成内存泄漏。

同时手动 dispose 又嫌麻烦，所以就有了DisposeBag，当这个 Bag 被回收时，Bag 里面的 subscription 会自动被 dispose，相当于从 MRC 变成了 ARC。