RxSwift的使用详解

RxSwift的使用详解

一. RxSwift简介

• 推荐: RxSwift官方文档

• 中文: RxSwift官方文档的中文翻译

• RxSwift是Swift函数响应式编程的一个开源库，由Github的ReactiveX组织开发、维护

• 其他语言像C#, Java 和 JS 也有，Rx.Net、RxJava、rxjs

• RxSwift的目的是让数据/事件流和异步任务能够更方便的序列化处理，能够使用Swift进行响应式编程

1. RxSwift做了什么

• RxSwift把我们程序中每一个操作都看成一个事件
• 比如一个TextField中的文本改变，一个按钮被点击，或者一个网络请求结束等，每一个事件源就可以看成一个管道，也就是sequence
• 比如TextField，当我们改变里面的文本的时候，这个TextField就会不断的发出事件，从他的这个sequence中不断的流出，我们只需要监听这个sequence，每流出一个事件就做相应的处理。
• 同理，Button也是一个sequence，每点击一次就流出一个事件。

2.1 RxSwift的核心思想是 Observable

• sequence，Observable表示可监听或者可观察，也就是说RxSwift的核心思想是可监听的序列。

• 并且，Observable sequence可以接受异步信号，也就是说，信号是可以异步给监听者的

  • Observable(ObservableType) 和 SequenceType类似
  • ObservableType.subscribe 和 SequenceType.generate类似
  • 由于RxSwift支持异步获得信号，所以用ObservableType.subscribe，这和indexGenerator.next()类似

• 其中SequenceType是Swift(2.3以前版本,之后的版本没有该协议)中的一个协议，比如Swift中的Array就遵循这个协议，通过这个协议，你可以这样的去操作一个Array

let array = [1,2,3,4,5]let array2 = array.filter({$0 > 1}).map({$0 * 2})//4 6 8 10var indexGenerator = array2.generate()let fisrt = indexGenerator.next() // 4let seoncd = indexGenerator.next() //6 复制代码

2.2 RxSwift中，ObservableType.subscribe的回调（新的信号到来）一共有三

enum Event  {    case Next(Element)      // 新的信号到来    case Error(ErrorType)   // 信号发生错误，序列不会再产生信号    case Completed          // 序列发送信号完成，不会再产生新的信号}protocol ObserverType {    func on(event: Event) //监听所有的信号}复制代码

2.3 取消监听

Observable分为两种

• 在有限的时间内会自动结束（Completed/Error）,比如一个网络请求当作一个序列，当网络请求完成的时候，Observable自动结束，资源会被释放
• 信号不会自己结束，最简单的比如一个Timer，每隔一段时间发送一个新的信号过来，这时候需要手动取消监听，来释放相应的资源
• 比如一个label.rx.text是一个Obserable，通常需要这样调用addDisposableTo(disposeBag)来让其在deinit，也就是所有者要释放的时候，自动取消监听

class Observable {    func subscribe(observer: Observer) -> Disposable //调用Disposable的方法来取消 }复制代码

当然，除了手动释放，RxSwift提供了一些操作符，比如 takeUntil来根据条件取消

sequence    .takeUntil(self.rx_deallocated) //当对象要释放的时候，取消监听    .subscribe {        print($0)    }复制代码

二. RxSwift简单体验

• 首先创建deinit属性，也就是所有者要释放的时候，自动取消监听

fileprivate lazy var bag = DisposeBag()复制代码

1. RxSwift监听按钮的点击

• 传统方式:

button1.addTarget(self, action: #selector(btn1Click(_:)), for: .touchUpInside)复制代码

• RxSwift方式

button1.rx.tap.subscribe { (event) in    self.button1.setTitle("按钮1", for: .normal)    print("button1")}.addDisposableTo(bag)        button2.rx.tap.subscribe { (event) in    self.textField2.text = "按钮2被点击了"}.addDisposableTo(bag)复制代码

2. RxSwift监听UITextField的文字改变

• 传统做法,设置textField2.delegate = self
• RxSwift方式

2-1. 用on方法实现

subscribe(<#T##on: (Event) -> Void##(Event) -> Void#>)复制代码

textField1.rx.text.subscribe { (event: Event) in    //将UITextField文字改变的内容显示在Label中    self.label1.text = event.element!        print(event.element!!)}.addDisposableTo(bag)        textField2.rx.text.subscribe { (event: Event) in    print(event.element)//报警告    //输出: Optional(Optional("jun"))}.addDisposableTo(bag)复制代码

2-2. 用onNext方法实现

subscribe(on: (Event) -> Void)复制代码

textField1.rx.text.subscribe(onNext: { (str: String?) in    self.label1.text = str!}).addDisposableTo(bag)复制代码

3. RxSwift改变Label中文字

label1.rx.observe(String.self, "text").subscribe(onNext: { (str: String?) in    print(str!)}).addDisposableTo(bag)        label2.rx.observe(CGRect.self, "frame").subscribe(onNext: { (rect: CGRect?) in    print(rect!.width)}).addDisposableTo(bag)复制代码

4. RxSwift监听UIScrollView的滚动

scrollView.contentSize = CGSize(width: 1000, height: 0)scrollView.rx.contentOffset            .subscribe(onNext: { (point : CGPoint) in                print(point)            }).addDisposableTo(bag)  复制代码

三. RxSwift常见操作

• addDisposableTo(disposeBag)方法是让其deinit，也就是所有者要释放的时候，自动取消监听

//创建baglet bag = DisposeBag()复制代码

1. never

• never就是创建一个sequence,但是不发出任何事件信号

let neverSqu = Observable.never()neverSqu.subscribe { (_) in    //该语句不会执行    print("This will never be printed")}.addDisposableTo(bag)//调用Disposable的方法来取消 复制代码

2. empty

• empty就是创建一个空的sequence,只能发出一个complected事件

Observable.empty().subscribe { (event) in    //该语句只会执行一次    //输出: completed    print(event)}.addDisposableTo(bag)复制代码

3. just

• just是创建一个sequence只能发出一种特定的事件，能正常结束

Observable.just(3).subscribe { (event) in    print(event)    /*该语句只会执行两次,分别输出     1) next(3),语句结果     2) completed, 结束事件    */}.addDisposableTo(bag)        Observable.just("jun").subscribe { (event) in    print(event)    /*该语句只会执行两次,分别输出     1) next(jun),语句结果     2) completed, 结束事件    */}.addDisposableTo(bag)复制代码

4.of

• of是创建一个sequence能发出很多种事件信号

Observable.of("a", "b", "2", "5.3")    .subscribe(onNext: { print($0) })    .addDisposableTo(bag)    //会分别输出 "a", "b", "2", "5.3" Observable.of("a", "b", "2", "5.3").subscribe(onNext: { (event) in    print(event)    /*该语句只会执行4次,分别输出     1) next(a),语句结果     2) next(b),语句结果     3) next(2),语句结果     4) next(3.5),语句结果     */}, onError: nil, onCompleted: nil, onDisposed: nil).addDisposableTo(bag)   //每一个闭包都设置设置了 一个默认值,故可以省略复制代码

5. from

• from就是从数组中创建sequence

Observable.from(["a", "b", "2", "5.3"]).subscribe { (event) in    print(event)    /*该语句只会执行5次,分别输出     1) next(a),语句结果     2) next(b),语句结果     3) next(2),语句结果     4) next(3.5),语句结果     5) completed, 结束事件     */}.addDisposableTo(bag)复制代码

6. create

• 我们也可以自定义可观察的sequence，那就是使用create
• create操作符传入一个观察者observer，然后调用observer的onNext，onCompleted和onError方法。返回一个可观察的obserable序列

1) 自定义方法创建observable的creat

6-1 无参创建creat

fileprivate func myobserable() -> Observable {    return Observable.create({ (observal: AnyObserver) -> Disposable in        observal.onNext("abc")        observal.onNext("12")        observal.onCompleted()        return Disposables.create()    })}复制代码

6-2 添加参数创建creat

fileprivate func myJunst(element: String) -> Observable {    return Observable.create({ (observal: AnyObserver) -> Disposable in        observal.onNext(element)        observal.onCompleted()        return Disposables.create()    })}复制代码

2) 在函数内调用自定义方法

myobserable().subscribe(onNext: { print($0) }).addDisposableTo(bag)//该语句只会执行2次,分别输出"abc", "12"         myJunst(element: "jun").subscribe(onNext: { print($0) }).addDisposableTo(bag)//该语句只会执行2次,分别输出"jun" 复制代码

7. range(给定范围, 依次显示)

• range就是创建一个sequence，他会发出这个范围中的从开始到结束的所有事件
• Observable,必须指定数据类型

Observable.range(start: 1, count: 4).subscribe { (event: Event) in    print(event)    /*该语句只会执行5次,分别输出     1) next(1),语句结果     2) next(2),语句结果     3) next(3),语句结果     4) next(4),语句结果     5) completed, 结束事件     */}.addDisposableTo(bag)复制代码

8. repeatElement(重复执行)

创建一个sequence，发出特定的事件n次

Observable.repeatElement("quanjun")    .take(3)    .subscribe(onNext: { print($0) })    .addDisposableTo(bag)    //该语句只会执行3次,每次都输出"quanjun"  复制代码

9. generate(类似于for循环)

• generate是创建一个可观察sequence，当初始化的条件为true的时候，他就会发出所对应的事件

let generate = Observable.generate(initialState: 0, condition: { $0 < 5 }, iterate: { $0 + 2 })generate.subscribe({ print($0) }).addDisposableTo(bag)                /*1> 输出顺序:         next(0)         next(2)         next(4)         completed                  2> 以上代码可以理解为for循环处理逻辑        for (Int i = 0; i < 5; i++) {            print(i)        }        */复制代码

10. error(发出错误信号)

• 创建一个可观察序列，但不发出任何正常的事件，只发出error事件并结束

 let error = NSError(domain: "错误", code: 10, userInfo: nil) as Error Observable.error(error)            .subscribe({ print($0) })            .addDisposableTo(bag)        //输出: error(Error Domain=错误 Code=10 "(null)")复制代码

四. RxSwift中Subjects

• Subjects是什么?

  • Subjet是observable和Observer之间的桥梁，一个Subject既是一个Obserable也是一个Observer，他既可以发出事件，也可以监听事件

1. PublishSubject

• 当你订阅PublishSubject的时候，你只能接收到订阅他之后发生的事件。subject.onNext()发出onNext事件，对应的还有onError()和onCompleted()事件

let pSubject = PublishSubject()pSubject.subscribe { (event: Event) in        print("2--", event)    }.addDisposableTo(bag)print("1--------------")        pSubject.onNext("T")pSubject.onNext("Q")        pSubject.subscribe { (event: Event) in         print("3--", event)    }.addDisposableTo(bag)pSubject.onNext("J")            /*输出顺序为:         1--------------         2-- next(T)         2-- next(Q)         2-- next(J)         3-- next(J)     */ 复制代码

2. ReplaySubject

• 当你订阅ReplaySubject的时候，你可以接收到订阅他之后的事件，但也可以接受订阅他之前发出的事件，接受几个事件取决与bufferSize的大小

• createUnbounded()表示接受所有事件

• create(bufferSize: 4) 表示可接受到的订阅他之前的事件的个数,但是订阅他之后的事件一定会触发

2-1. createUnbounded()表示接受所有事件

let rSubject = ReplaySubject.createUnbounded()rSubject.onNext("T")rSubject.onNext("Q")rSubject.subscribe { (event: Event) in         print("0--", event)    }.addDisposableTo(bag)        rSubject.onNext("J") /*输出顺序为:     0-- next(T)     0-- next(Q)     0-- next(J)  */复制代码

2-2. create(bufferSize: 4) 表示可接受到的订阅他之前的事件的个数

let rSubject1 = ReplaySubject.create(bufferSize: 1)rSubject1.onNext("T")rSubject1.onNext("Q")rSubject1.subscribe { (event: Event) in            print("4--", event)        }.addDisposableTo(bag)        rSubject1.onNext("J") /*输出顺序为:     4-- next(Q)     4-- next(J)  */  复制代码

3. BehaviorSubject

• 当你订阅了BehaviorSubject，你会接受到订阅之前的最后一个事件,订阅之后的事件一定会触发

let bSubject = BehaviorSubject(value: "G")bSubject.subscribe { (event: Event) in        print("5--", event)    }.addDisposableTo(bag)        bSubject.onNext("Y")bSubject.onNext("Q")        bSubject.subscribe { (event: Event) in        print("6--", event)    }.addDisposableTo(bag)        bSubject.onNext("J") /*输出顺序为:         5-- next(G)         5-- next(Y)         5-- next(Q)         6-- next(Q)         5-- next(J)         6-- next(J) */ 复制代码

4. Variable

Variable是BehaviorSubject一个包装箱，就像是一个箱子一样，使用的时候需要调用asObservable()拆箱，里面的value是一个BehaviorSubject，他不会发出error事件，但是会自动发出completed事件。

• 1> 相当于对BehaviorSubject进行装箱
• 2> 如果想将Variable当成Obserable, 让订阅者进行订阅时, 需要调用asObserable拆箱转成Obserable
• 3> 如果Variable打算发出事件, 直接修改对象的value即可
• 4> 当事件结束时,Variable会自动发出completed事件

let variable = Variable("S")variable.asObservable().subscribe { (event) in        print("7--", event)    }.addDisposableTo(bag)        variable.value = "D"variable.value = "Q"        variable.asObservable().subscribe { (event) in        print("8--", event)    }.addDisposableTo(bag)        variable.value = "j" /*输出顺序为:         7-- next(S)         7-- next(D)         7-- next(Q)         8-- next(Q)         7-- next(j)         8-- next(j)         7-- completed         8-- completed  */ 复制代码