Subject 基本介绍

Subject即使观察者，也是可观察序列，因为都遵循了这两天协议Observable、ObserverType

RxSwift中Subject一种有三种，分别是PublishSubject、BehaviorSubject、ReplaySubject，他们既有各自的特点，也有相同之点：

• 都是Observable，他们的订阅者都能收到他们发出的Event
• 直到Subject发出complete 或者 error 事件后，该Subject便终结了，不会再发出next事件
• 对于那些在Subject 终结后再订阅它的订阅者，也能收到subject发出的一条complete或error的事件，告诉新的订阅者它已经终结了
• 他们之间最大的区别是在于： 当一个新的订阅者刚订阅它的时候，能不能收到Subject以前发出的事件，如果能的话又能收到多少个

subject常用的方法
func onNext(_ element: Self.Element)：发出Event事件
func onCompleted()： 发出complete事件
func onError(_ error: Error) ： 发出error事件

PublishSubject

PublishSubject 创建不需要初始值
PublishSubject 的订阅者从它们开始订阅的时间点开始，可以收到订阅后Subject发出的Event，而不会收到他们在订阅之前发出的Event

let publishSubject = PublishSubject<Int>()

/// 不能接受订阅之前的发出的Event
publishSubject.onNext(1)
publishSubject.onNext(2)

publishSubject.asObserver().subscribe(onNext:{
    print($0)
})
.disposed(by: bag)

publishSubject.onNext(3)
publishSubject.onCompleted()
/// Subject已发出Complete的，则不能再发出onNext事件
publishSubject.onNext(4)

/// Subject 结束之后，再订阅
/// 只会收到complete或error事件
publishSubject.asObserver()
    .subscribe { (event) in
        if let value = event.element {
            print(value)
        }else{
            print(event)
        }
    }.disposed(by: bag)

/// 打印结果：
3
completed

BehaviorSubject

创建时需要一个默认的初始值
当一个订阅者来订阅它的时候，这个订阅者会立即收到BehaviorSubject上一个发出的event，之后就跟正常的情况一样，它会接收到BehaviorSubject之后发出的Event

备注：与PublishSubject不同的是创建需要一个初始值，并且对于新的订阅者，会接收到上一次发出的Event

let behaviorSubject = BehaviorSubject(value: 0)
behaviorSubject.onNext(1)
behaviorSubject.onNext(2)

/// 对于新的订阅者，会先收到上一次发出的Event，即2
behaviorSubject.asObserver().subscribe(onNext:{
    print($0)
})
.disposed(by: bag)

behaviorSubject.onNext(3)
behaviorSubject.onCompleted()
behaviorSubject.onNext(4)

/// Subject 结束之后，再订阅
/// 只会收到complete或error事件
behaviorSubject.asObserver()
    .subscribe { (event) in
        if let value = event.element {
            print(value)
        }else{
            print(event)
        }
    }.disposed(by: bag)

/// 打印结果：
2
3
completed

ReplaySubject

在创建的时候需要设置一个bufferSize，表示它对发送过的Event的缓存个数
如果一个subject订阅已经结束的ReplaySubject，除了会收到缓存的event事件，还会收到complete或者error事件

/// 创建的时候，要设置一个bufferSize: ，Event缓存个数
let replaySubject = ReplaySubject<Int>.create(bufferSize: 2)
replaySubject.onNext(1)
replaySubject.onNext(2)

/// 能够收到订阅时，前两个缓存的Event事件
replaySubject.asObserver().subscribe(onNext:{
    print($0)
})
.disposed(by: bag)

replaySubject.onNext(3)
replaySubject.onCompleted()
/// Subject结束之后，发出的onNext 事件，并不会缓存，因为发不出去
replaySubject.onNext(4)

/// Subject 结束之后，再订阅
/// 会收到Subject结束之前缓存的Event事件
/// 并且还会收到complete或者error事件
replaySubject.asObserver()
    .subscribe { (event) in
        if let value = event.element {
            print(value)
        }else{
            print(event)
        }
    }.disposed(by: bag)

/// 打印结果：
1
2
3
2
3
completed

特别：BehaviorRelay

BehaviorReplay是Swift5 替换 Swift4 中的 Variable

了解这个新出的类，首先请看下列源码

public final class BehaviorRelay<Element>: ObservableType {
    private let subject: BehaviorSubject<Element>

    /// Accepts `event` and emits it to subscribers
    public func accept(_ event: Element) {
        self.subject.onNext(event)
    }

    /// Current value of behavior subject
    public var value: Element {
        // this try! is ok because subject can't error out or be disposed
        return try! self.subject.value()
    }

    /// Initializes behavior relay with initial value.
    public init(value: Element) {
        self.subject = BehaviorSubject(value: value)
    }

    /// Subscribes observer
    public func subscribe<Observer: ObserverType>(_ observer: Observer) -> Disposable where Observer.Element == Element {
        self.subject.subscribe(observer)
    }

    /// - returns: Canonical interface for push style sequence
    public func asObservable() -> Observable<Element> {
        self.subject.asObservable()
    }
}

第一： 可以明确的是它不是Subject类型，因为它只是一个可观察序列，但是它又包含Subject对象（私有的BehaviorSubject）
第二：初始化的时候也需要一个初始值
第三：既然它不是一个订阅者，那么就不能发出onNext:、complete和error事件
第四：只能通过accept发出event

总结：BehaviorRelay 跟 BehaviorSubject 很像，只是不是发出complete、error事件

let behaviorSubject = BehaviorRelay(value: 0)
behaviorSubject.accept(1)
behaviorSubject.accept(2)

behaviorSubject.asObservable().subscribe(onNext:{
    print($0)
})
.disposed(by: bag)

behaviorSubject.accept(3)
behaviorSubject.accept(4)

/// 打印结果：
2
3
4