RxSwift学习(一) -- RxSwift初探

一、关于Swift

苹果公司有两种开发语言,大儿子Objective-C,这几年已经很久没更新过新东西了,小儿子Swift,虽然前几个版本不太稳定,但一直是重点培养的对象,在 2019 年的 WWDC 大会之前,Swift 5 正式发布了,更让大家激动的是这一版本的 ABI 稳定了!以后可以尽情的用Swift挥霍了,至于Swift与Objective-C对比的优势,百度一下就会有很多介绍。除此之外,用Swift还可以开发服务器,这对于一个iOSer想做全栈的人来说,无疑是一个爆炸性的消息,目前用Swift开发服务器,常用的框架有VaporPerfectKituraZewo,有兴趣的小伙伴可以去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.interval(.seconds(1), scheduler: MainScheduler.instance)
timer.subscribe(onNext: { (time) in
    print("\(time)")
})
.disposed(by: disposeBag)
//或者写到一起
Observable.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

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

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

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

    /// Sequence completed successfully.
    case completed
}

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

  • nextnext事件就是那个可以携带数据 的事件
  • errorerror事件表示一个错误,它可以携带具体的错误内容,一旦 Observable 发出了error Event,则这个 Observable 就等于终止了,以后它再也不会发出 Event 事件了。
  • completedcompleted 事件表示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.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.empty()
5.never() 方法

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

let observable = Observable.never()
6.error() 方法

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

enum MyError: Error {
    case A
    case B
}
         
let observable = Observable.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() 方法

该方法创建一个可以无限发出给定元素的EventObservable序列(永不终止)。

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.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 = 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.interval(.seconds(1), scheduler: MainScheduler.instance)
    .subscribe(onNext: { (time) in
                
    })
    .disposed(by: disposeBag)

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

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

六、关于Observable的执行逻辑

先写一个简单的小例子

//创建一个序列
let ob = Observable.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,调用不同的实现闭包。
RxSwift学习(一) -- RxSwift初探_第1张图片
image.png

你可能感兴趣的:(RxSwift学习(一) -- RxSwift初探)