RxSwift_v1.0笔记——3 Subjects

RxSwift_v1.0笔记——3 Subjects

Subject——可以看做是一种代理和桥梁。它既是订阅者又是订阅源，这意味着它既可以订阅其他 Observable 对象，同时又可以对它的订阅者们发送事件。

开始 63

与PublishSubjects工作 64

当你订阅PublishSubject的时候，你只能接收到订阅他之后发生的事件

开始是空并且仅仅发射新元素给订阅中。

example(of: "PublishSubject") {
    let subject = PublishSubject<String>()
    subject.onNext("Is anyone listening?")
    
    let subscriptionOne = subject
        .subscribe(onNext: { string in
            print(string)
        })
    subject.on(.next("1"))
    subject.onNext("2")
    
    let subscriptionTwo = subject
        .subscribe { event in
            print("2)", event.element ?? event)
    }
    subject.onNext("3")
    subscriptionOne.dispose()
    subject.onNext("4")
    
    // 1
    subject.onCompleted()
    // 2
    subject.onNext("5")
    // 3
    subscriptionTwo.dispose()
    let disposeBag = DisposeBag()
    // 4
    subject
        .subscribe {
            print("3)", $0.element ?? $0)
        }
        .addDisposableTo(disposeBag)
    subject.onNext("?")
}
--- Example of: PublishSubject ---
1
2
3
2) 3
2) 4
2) completed
3) completed

与BehaviorSubjects工作 67

在新的订阅对象订阅的时候会发送最近发送的事件，如果没有则发送一个默认值。

开始有一个初始值，并且重复发送它（如果没有新元素）或发射最新的元素给订阅中。

// 1
enum MyError: Error {
    case anError
}
// 2
func print<T: CustomStringConvertible>(label: String, event: Event<T>) {
    print(label, event.element ?? event.error ?? event)
}
// 3
example(of: "BehaviorSubject") {
    // 4
    let subject = BehaviorSubject(value: "Initial value")
    let disposeBag = DisposeBag()
    subject
        .subscribe {
            print(label: "1)", event: $0)
        }
        .addDisposableTo(disposeBag)
    subject.onNext("X")
    // 1
    subject.onError(MyError.anError)
    // 2
    subject
        .subscribe {
            print(label: "2)", event: $0)
        }
        .addDisposableTo(disposeBag)
}
--- Example of: BehaviorSubject ---
1) Initial value
1) X
1) anError
2) anError

与ReplaySubject工作 69

在新的订阅对象订阅的时候会补发所有已经发送过的数据队列， bufferSize 是缓冲区的大小，决定了补发队列的最大值。如果 bufferSize 是1，那么新的订阅者出现的时候就会补发上一个事件，如果是2，则补两个，以此类推。

使用缓冲区大小初始化，将保持元素的缓冲区达到该大小，并将其重新发送它给新的订阅着。

example(of: "ReplaySubject") {
    // 1
    let subject = ReplaySubject<String>.create(bufferSize: 2)
    let disposeBag = DisposeBag()
    // 2
    subject.onNext("1")
    subject.onNext("2")
    subject.onNext("3")
    // 3
    subject
        .subscribe {
            print(label: "1)", event: $0)
        }
        .addDisposableTo(disposeBag)
    subject
        .subscribe {
            print(label: "2)", event: $0)
        }
        .addDisposableTo(disposeBag)
    subject.onNext("4")
    subject.onError(MyError.anError)
    subject.dispose()
    subject
        .subscribe {
            print(label: "3)", event: $0)
        }
        .addDisposableTo(disposeBag)
}
--- Example of: ReplaySubject ---
1) 2
1) 3
2) 2
2) 3
1) 4
2) 4
1) anError
2) anError
3) Object `RxSwift.(ReplayMany in _33052C2CE59F358A8740AFDD4371DD39)<Swift.String>` was already disposed.

与Variable工作 72

是基于 BehaviorSubject 的一层封装，它的优势是：不会被显式终结。即：不会收到 .Completed 和 .Error 这类的终结事件，它会主动在析构的时候发送 .Complete 。需要调用它自带的asObservable()方法进行转化后才能被订阅。

example(of: "Variable") {
    // 1
    var variable = Variable("Initial value")
    let disposeBag = DisposeBag()
    // 2
    variable.value = "New initial value"
    // 3
    variable.asObservable()
        .subscribe {
            print(label: "1)", event: $0)
        }
//        .addDisposableTo(disposeBag)
    // 1
    variable.value = "1"
    // 2
    variable.asObservable()
        .subscribe {
            print(label: "2)", event: $0)
        }
        .addDisposableTo(disposeBag)
    // 3
    variable.value = "2"
}
--- Example of: Variable ---
1) New initial value
1) 1
2) 1
1) 2
2) 2
1) completed