RxSwift学习(一) -- RxSwift初探

作者: Q海龙 | 来源:发表于2019-07-26 11:10 被阅读0次

一、关于Swift

苹果公司有两种开发语言，大儿子Objective-C，这几年已经很久没更新过新东西了，小儿子Swift，虽然前几个版本不太稳定，但一直是重点培养的对象，在 2019 年的 WWDC 大会之前，Swift 5 正式发布了，更让大家激动的是这一版本的 ABI 稳定了！以后可以尽情的用Swift挥霍了，至于Swift与Objective-C对比的优势，百度一下就会有很多介绍。除此之外，用Swift还可以开发服务器，这对于一个iOSer想做全栈的人来说，无疑是一个爆炸性的消息，目前用Swift开发服务器，常用的框架有Vapor、Perfect、Kitura和Zewo，有兴趣的小伙伴可以去Github上搜一搜，这里就不多说了。
使用Objective-C开发的人应该都听过RAC，函数响应式编程是有多么的强大，而在Swift中也同样存在着这么一个强大的开发利器，那就是RxSwift。

二、RxSwift介绍

RxSwift全称ReactiveX for Swift，是一个简化异步编程的框架，实现了函数响应式编程，事件与对象紧密联系，业务流清晰，便于管理。在RxSwift中，所有异步操作（事件）和数据流均被抽象为可观察序列的概念。流程：

创建序列 -> 订阅序列 -> 发送信号 -> 信号接收

下面就简单用几个常用的小例子来感觉一下RxSwift的用起来是有多么爽

三、RxSwift简单应用

1.button的点击事件

private func test() -> Void {
    //正常写法
    let button = UIButton(type: .custom)
    button.addTarget(self, action: #selector(btnTap(_:)), for: .touchUpInside)
}
@objc private func btnTap(_ btn: UIButton) -> Void {
        
}

//Rx写法
private func test() -> Void {
    let button = UIButton(type: .custom)
    button.rx.tap
        .subscribe(onNext: { () in
            //按扭被点击后的逻辑        
        })
        .disposed(by: disposeBag)
}

2.添加手势点击事件

//正常写法
private func test() -> Void {
    self.view.isUserInteractionEnabled = true
    let tap = UITapGestureRecognizer(target: self, action: #selector(viewTap(_:)))
    self.view.addGestureRecognizer(tap)
}
@objc private func viewTap(_ tap: UITapGestureRecognizer) -> Void {
        
}

//Rx写法
private func test() -> Void {
    self.view.isUserInteractionEnabled = true
    let tap = UITapGestureRecognizer(target: self, action: #selector(viewTap(_:)))
    self.view.addGestureRecognizer(tap)
    tap.rx.event
        .subscribe(onNext: { (gesture) in
                
        })
        .disposed(by: disposeBag)

3.UITextField监听文本变化

正常的写法我就不写了，太麻烦，还得写代理方法，Rx这里有两种方式

//1.通过文本变化
private func test() -> Void {
    let textField = UITextField()
    textField.rx.text.orEmpty.changed
        .subscribe(onNext: { (text) in
                
        })
        .disposed(by: disposeBag)
    }
//2.通过事件，像我们监听键盘点击了retuen事件，也是通过这个方式，换成editingDidEndOnExit即可
private func test() -> Void {
    let textField = UITextField()
    textField.rx.controlEvent(.editingChanged)
        .subscribe(onNext: { (text) in
                
        })
        .disposed(by: disposeBag)
    }

4.将UITextField内容绑定到UILabel上

正常我们想写此功能，我们需要使用KVO或者写UITextField的代理方法，然后再往UILabel上赋值，然而用Rx就很便利了

_ = textField.rx.text.bind(to: label.rx.text)

5.KVO监听

self.person.rx.observeWeakly(String.self, "name").subscribe(onNext: { (value) in
    //处理事件
}).disposed(by: disposeBag)

6.滑动时监听contentoffset

scrollview.rx.contentOffset.subscribe(onNext: { [weak self] (content) in
    let y = content.y
    print(content.y)
    //处理事件 ……
}).disposed(by: disposeBag)

7.定时器

let timer = Observable<Int>.interval(.seconds(1), scheduler: MainScheduler.instance)
timer.subscribe(onNext: { (time) in
    print("\(time)")
})
.disposed(by: disposeBag)
//或者写到一起
Observable<Int>.interval(.seconds(1), scheduler: MainScheduler.instance)
    .subscribe(onNext: { (time) in
                
    })
    .disposed(by: disposeBag)

8.通知（键盘弹出）

NotificationCenter.default.rx.notification(UIResponder.keyboardWillShowNotification)
    .subscribe(onNext: { (notification) in
                
    })
    .disposed(by: disposeBag)

9.网络请求

//正常写法
let url = URL(string: "https://www.baidu.com")
URLSession.shared.dataTask(with: url!) { (data, response, error) in
            
}.resume()
//Rx写法
URLSession.shared.rx.response(request: URLRequest(url: url!))
    .subscribe(onNext: { (response, data) in
                
    }, onError: { (error) in
                
    }, onCompleted: {
                
    })
    .disposed(by: disposeBag)

四、RxSwift核心原理

1.Observable<T>

Observable<T> 这个类就是Rx框架的基础，可以称它为可观察序列。它的作用就是可以异步地产生一系列的 Event（事件），即一个 Observable<T> 对象会随着时间推移不定期地发出 event(element : T) 这样一个东西。
而且这些 Event 还可以携带数据，它的泛型 <T> 就是用来指定这个Event携带的数据的类型。
有了可观察序列，我们还需要有一个Observer（订阅者）来订阅它，这样这个订阅者才能收到 Observable<T> 不时发出的 Event。

2.Event

/// Represents a sequence event.
///
/// Sequence grammar: 
/// **next\* (error | completed)**
public enum Event<Element> {
    /// Next element is produced.
    case next(Element)

    /// Sequence terminated with an error.
    case error(Swift.Error)

    /// Sequence completed successfully.
    case completed
}

由上代码可知，Observable可以产生三种Event事件

next：next事件就是那个可以携带数据 <T> 的事件
error：error事件表示一个错误，它可以携带具体的错误内容，一旦 Observable 发出了error Event，则这个 Observable 就等于终止了，以后它再也不会发出 Event 事件了。
completed：completed 事件表示Observable 发出的事件正常地结束了，跟 error 一样，一旦 Observable 发出了 completed Event，则这个 Observable就等于终止了，以后它再也不会发出 event 事件了。

3.Observable 与 Sequence比较

为更好地理解，我们可以把每一个 Observable 的实例想象成于一个 Swift 中的 Sequence：

即一个 Observable（ObservableType）相当于一个序列Sequence（SequenceType）。
ObservableType.subscribe(_:)方法其实就相当于 SequenceType.generate()

但它们之间还是有许多区别的：

Swift 中的 SequenceType 是同步的循环，而 Observable是异步的。
Observable 对象会在有任何 Event 时候，自动将Event作为一个参数通过ObservableType.subscribe(_:)发出，并不需要使用next方法。

五、创建 Observable 序列

我们可以通过如下几种方法来创建一个Observable序列

1.just() 方法

该方法通过传入一个默认值来初始化。即指定了这个 Observable所发出的事件携带的数据类型必须是指定的类型。

let observable = Observable<Int>.just(5)

2.of() 方法

该方法可以接受可变数量的参数（必需要是同类型的）,Swift 也会自动推断类型。

let observable = Observable.of("A", "B", "C")

3.from() 方法

该方法需要一个数组参数。

let observable = Observable.from(["A", "B", "C"])

4.empty() 方法

该方法创建一个空内容的 Observable 序列。

let observable = Observable<Int>.empty()

5.never() 方法

该方法创建一个永远不会发出 Event（也不会终止）的 Observable 序列。

let observable = Observable<Int>.never()

6.error() 方法

该方法创建一个不做任何操作，而是直接发送一个错误的 Observable 序列。

enum MyError: Error {
    case A
    case B
}
         
let observable = Observable<Int>.error(MyError.A)

7.range() 方法

该方法通过指定起始和结束数值，创建一个以这个范围内所有值作为初始值的Observable序列。

//两种方法创建的 Observable 序列都是一样的。
//使用range()
let observable = Observable.range(start: 1, count: 5)
 
//使用of()
let observable = Observable.of(1, 2, 3 ,4 ,5)

8.repeatElement() 方法

该方法创建一个可以无限发出给定元素的Event的Observable序列（永不终止）。

let observable = Observable.repeatElement(1)

9.generate() 方法

该方法创建一个只有当提供的所有的判断条件都为 true 的时候，才会给出动作的 Observable 序列。

//两种方法创建的 Observable 序列都是一样的。
//使用generate()方法
let observable = Observable.generate(
    initialState: 0,
    condition: { $0 <= 10 },
    iterate: { $0 + 2 }
)
//使用of()方法
let observable = Observable.of(0, 2, 4, 6, 8, 10)

10.create() 方法

该方法接受一个 block 形式的参数，任务是对每一个过来的订阅进行处理。

//这个block有一个回调参数observer就是订阅这个Observable对象的订阅者
//当一个订阅者订阅这个Observable对象的时候，就会将订阅者作为参数传入这个block来执行一些内容
let ob = Observable<String>.create { (observer) -> Disposable in
    observer.onNext("abc")
    return Disposables.create()
}
        
ob.subscribe(onNext: { (text) in
    print(text)
}, onError: { (error) in
            
}, onCompleted: {
            
})
.disposed(by: disposeBag)

11.deferred() 方法

该个方法相当于是创建一个 Observable 工厂，通过传入一个 block 来执行延迟 Observable序列创建的行为，而这个 block 里就是真正的实例化序列对象的地方。

//用于标记是奇数、还是偶数
var isOdd = true
 
//使用deferred()方法延迟Observable序列的初始化，通过传入的block来实现Observable序列的初始化并且返回。
let factory : Observable<Int> = Observable.deferred {
     
    //让每次执行这个block时候都会让奇、偶数进行交替
    isOdd = !isOdd
     
    //根据isOdd参数，决定创建并返回的是奇数Observable、还是偶数Observable
    if isOdd {
        return Observable.of(1, 3, 5 ,7)
    }else {
        return Observable.of(2, 4, 6, 8)
    }
}
 
//第1次订阅测试
_ = factory.subscribe { event in
    print("\(isOdd)", event)
}
 
//第2次订阅测试
_ = factory.subscribe { event in
    print("\(isOdd)", event)
}

12.interval() 方法

这个方法创建的 Observable 序列每隔一段设定的时间，会发出一个索引数的元素。而且它会一直发送下去。这就像是我们常用的定时器一样

//每 1 秒发送一次，并且是在主线程（MainScheduler）发送。
Observable<Int>.interval(.seconds(1), scheduler: MainScheduler.instance)
    .subscribe(onNext: { (time) in
                
    })
    .disposed(by: disposeBag)

另一种是创建的 Observable 序列在经过设定的一段时间后，每隔一段时间产生一个元素。

Observable<Int>.timer(.seconds(5), period: .seconds(1), scheduler: MainScheduler.instance)
    .subscribe(onNext: { (time) in
                
    })
    .disposed(by: disposeBag)

六、关于Observable的执行逻辑

先写一个简单的小例子

//创建一个序列
let ob = Observable<Any>.create { (observer) -> Disposable in
    //发送内容
    observer.onNext("abc")
    //发送错误
    observer.onError(NSError(domain: "error", code: 10086, userInfo: nil))
    //发送完成
    observer.onCompleted()
    return Disposables.create()
}
        
//订阅序列
ob.subscribe(onNext: { (any) in
    print("订阅到\(any)")
}, onError: { (error) in
    print("订阅到错误\(error)")
}, onCompleted: {
    print("订阅到完成")
})
.disposed(by: disposeBag)

执行结果为：
订阅到abc
订阅到错误Error Domain=error Code=10086 "(null)"
因为error event与completed event是互斥的，所以不论先执行哪个，另一个也不会执行

1.Observable的逻辑大致可以归纳为以下几点：

在创建Observable类的ob对象时，调用的create方法，实际上是保存了我们的create实现的闭包。
在ob调用subscribe时，已经把订阅的实现逻辑封装到了闭包内，并且把这个闭包封装成了一个叫observer的临时变量，然后调用了AnonymousObservable的subscribe方法。
AnonymousObservable的subscribe方法，默认创建了AnonymousObservableSink类，并把observer保存成自己属性，又通过该类的run方法调用了第一步里保存的闭包，并把自己作为参数穿进去，用以让第一步保存的闭包成功获得这个observer。
这样就保证了订阅方法subscribe能获得onNext里的数据。因为subscribe已经持有了Observable创建时声明的闭包。

在subscribe订阅后，获取到对应的Event对应事件处理：

在AnonymousObservable类调用subscribe时，实际上是创建了一个sink对象。* 在这个sink类调用我们保存的闭包的时候，也把闭包内的onNext方法方法作为event事件做了持有操作。并在调用observer对象时，把event做为参数传了进来。
AnonymousObserver类根据传进来的event，调用不同的实现闭包。

image.png