RxSwift（一）Creating and Subscribing to Observables 创建和订阅观察者

发表于 | 分类于 | | 阅读次数

Observable

在ReactiveX中，一个观察者(Observer)订阅一个可观察对象(Observable)。观察者对 Observable发射的数据或数据序列作出响应。这种模式可以极大地简化并发操作，因为它创建了一个处于待命状态的观察者哨兵，在未来某个时刻响应Observable的通知，不需要阻塞 等待Observable发射数据。

Observable

初始化playground

  • 初始化项目工程，pod引入RxSwift
  • 创建playground
  • 在playground\Sources下创建 support.swift文件 填写下面代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import Foundation
public func exampleOf(description:String, action:  @escaping ()->Void)  {
    
    print("\n------exampleOf:\(description)------")
    
    action()
    
}
import PlaygroundSupport
public func playgroundShouldContinueIndefinitely() {
    PlaygroundPage.current.needsIndefiniteExecution = true
}
  • 在playground中导入RxSwift,RxCocoa

never

创建一个不发射任何数据的Observable

1
2
3
4
5
6
7
8
9
10
11
12
13
exampleOf(description:"never"){
    let disposeBag = DisposeBag()
    
    let neverSequence = Observable<String>.never()
    
    neverSequence.subscribe{ _ in
    
        print("永远不会执行")
        
    }.disposed(by: disposeBag)
}

empty

创建一个什么都不做直接通知完成的Observable.它只发送 .Completed 消息。

1
2
3
4
5
6
7
8
9
exampleOf(description: "empty"){
    Observable<Int>.empty()
        .subscribe{ event in
            
            print(event)
            
    }.disposed(by: DisposeBag())
}

just:

将一个或多个对象转换成发射这个或这些对象的一个Observable,just 是只包含一个元素的序列，它会先发送 .Next(value) ，然后发送 .Completed 。

1
2
3
4
5
6
7
8
9
exampleOf(description: "just"){
    Observable.just("我是对象")
        .subscribe{ event in
            
    
            print(event)
    }.addDisposableTo(DisposeBag())
}

of

可以把一系列元素转换成事件序列

1
2
3
4
5
6
7
8
9
10
11
12
13
exampleOf(description: "of"){
    Observable.of(1,2,3)
    .subscribe(onNext: { (event) in
        print(event)
    }, onError: { (error) in
        print(error)
    }, onCompleted: {
        print("信号完成")
    }, onDisposed: { 
        print("信号序列释放")
    }).disposed(by: DisposeBag())
}

from

from 是通过 asObservable() 方法把 Swift 中的序列 (SequenceType) 转换成事件序列。例如:将一个数组转换成一个Observable

1
2
3
4
5
6
7
8
9
10
exampleOf(description: "from"){
    Observable.from(["lily","lilei","sb"])
    .subscribe(onNext: {
        
        print($0)
        
    }).disposed(by: DisposeBag())
    
}

create

使用一个函数闭包从头创建一个Observable,通过 .on(e: Event) 添加事件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
exampleOf(description: "create"){
    
    let myJust = { (element:String) -> Observable<String> in
    
        return Observable.create{ observable in
            
            observable.on(.next(element))
            
            observable.on(.completed)
            
            return Disposables.create()
        }
    }
    
    myJust("🍎")
        .subscribe{
    
            print($0)
    }.disposed(by: DisposeBag())
}

range

创建一个发射特定整数序列的Observable

1
2
3
4
5
6
7
8
exampleOf(description: "range"){
    Observable.range(start: 1,count:10)
        .subscribe{
    
            print($0)
    }.disposed(by: DisposeBag())
}

repeatElement

创建一个重复发射指定数据或数据序列的Observable，

1
2
3
4
5
6
7
exampleOf(description: "repeatElement" ){
    Observable.repeatElement("🐩")
        .take(3)//只发射3次
        .subscribe{print($0)}
        .disposed(by: DisposeBag())
}

generate

发射所有条件为真的值的响应序列

1
2
3
4
5
6
7
8
9
10
11
12
exampleOf(description: "generate"){
    Observable.generate(initialState: 0, condition: { (T) -> Bool in
        
        T < 3
        
    }, iterate: {  $0 + 1})
        .subscribe{
    
          print($0)
    }.addDisposableTo(DisposeBag())
}

deferred

deferred 会等到有订阅者的时候再通过工厂方法创建 Observable 对象，每个订阅者订阅的对象都是内容相同而完全独立的序列。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
exampleOf(description: "deferred"){
    var count = 1
    
    let disposeBag = DisposeBag()
    
    let deferredSequence = Observable.deferred({ () -> Observable<String> in
        
        print("creat---\(count)")
        
        return Observable.create{ observable in
        
            print("发射~~~~...")
            observable.onNext("🐶")
            observable.onNext("🐱")
            observable.onNext("🐵")
            return Disposables.create()
        }
    })
    
    //第一个订阅者
    
    deferredSequence.subscribe{
    
        print("第一个订阅者--------")
        print($0)
    }.disposed(by: disposeBag)
    
    
    //第二个订阅者
    deferredSequence.subscribe{
    
        print("第二个订阅者")
        print($0)
    }.disposed(by: disposeBag)
}

error

创建一个什么都不做直接通知错误的Observable

1
2
3
4
5
6
7
8
9
10
11
12
exampleOf(description: "error"){
    enum testError:Error{
    
        case bigError
    }
    
    Observable<Int>.error(testError.bigError).subscribe{
    
        print($0)
    }
}

doOn

doOn 可以监听事件，并且在事件发生之前调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
exampleOf(description: "doOn") { 
    
    Observable.of(1,2,3,4).do(onNext: { (event) in
        print(event)
    }, onError: { (error) in
        print(error)
    }, onCompleted: {
        print("完成")
    }, onSubscribe: {
        print("订阅")
    }, onDispose: { 
        print("释放")
    }).subscribe{
        
        print($0)
    }.disposed(by: DisposeBag())
}