在這篇文章中，我們會先分析一下 RxJava2 中的 Subject ；然後，我們會使用 Subject 製作一個類似於 EventBus 的全域性的通訊工具。
在瞭解本篇文章的內容之前，你需要先了解 RxJava2 中的一些基本的用法，比如 Observable 以及背壓的概念，你可以參考我的其他兩篇文章來獲取這部分內容：《RxJava2 系列 （1）：一篇的比較全面的 RxJava2 方法總結》和《RxJava2 系列 （2）：背壓和Flowable》。
1、Subject
1.1 Subject 的兩個特性
Subject 可以同時代表 Observer 和 Observable，允許從資料來源中多次傳送結果給多個觀察者。除了 onSubscribe(), onNext(), onError() 和 onComplete() 之外，所有的方法都是執行緒安全的。此外，你還可以使用 toSerialized() 方法，也就是轉換成序列的，將這些方法設定成執行緒安全的。
如果你已經瞭解了 Observable 和 Observer ，那麼也許直接看 Subject 的原始碼定義會更容易理解：
public abstract class Subject<T> extends Observable<T> implements Observer<T> {
// ...
}
複製程式碼從上面看出，Subject 同時繼承了 Observable 和 Observer 兩個介面，說明它既是被觀察的物件，同時又是觀察物件，也就是可以生產、可以消費、也可以自己生產自己消費。所以，我們可以項下面這樣來使用它。這裡我們用到的是該介面的一個實現 PublishSubject ：
public static void main(String...args) {
PublishSubject<Integer> subject = PublishSubject.create();
subject.subscribe(System.out::println);
Executor executor = Executors.newFixedThreadPool(5);
Disposable disposable = Observable.range(1, 5).subscribe(i ->
executor.execute(() -> {
try {
Thread.sleep(i * 200);
subject.onNext(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}));
}
複製程式碼根據程式的執行結果，程式在第200, 400, 600, 800, 1000毫秒依次輸出了1到5的數字。
在這裡，我們用 PublishSubject 建立了一個主題並對其監聽，然後線上程當中又通知該主題內容變化，整個過程我們都只操作了 PublishSubject 一個物件。顯然，使用 Subject 我們可以達到對一個指定型別的值的結果進行監聽的目的——我們把值改變之後對應的邏輯寫在 subscribe() 方法中，然後每次呼叫 onNext() 等方法通知結果之後就可以自動呼叫 subscribe() 方法進行更新操作。
同時，因為 Subject 實現了 Observer 介面，並且在 Observable 等的 subscribe() 方法中存在一個以 Observer 作為引數的方法（如下），所以，Subject 也是可以作為消費者來對事件進行消費的。
public final void subscribe(Observer<? super T> observer)
複製程式碼以上就是 Subject 的兩個主要的特性。
1.2 Subject 的實現類
在 RxJava2 ，Subject 有幾個預設的實現，下面我們對它們之間的區別做簡單的說明：
-
AsyncSubject:只有當 Subject 呼叫 onComplete 方法時，才會將 Subject 中的最後一個事件傳遞給所有的 Observer。比如，在下面的例子中，雖然在傳送 "two" 的時候，observer 就進行了訂閱，但是隻有當 subject 呼叫了 onComplete() 方法的時候，observer 才收到了 "three" 這一個事件：AsyncSubject<String> subject = AsyncSubject.create(); subject.onNext("one"); subject.onNext("two"); subject.subscribe(observer); subject.onNext("three"); subject.onComplete(); 複製程式碼 -
BehaviorSubject:在建立 BehaviorSuject 的時候可以通過靜態的工廠方法指定一個預設值數，也可以不指定。當一個 Observer 使用了 subscribe() 方法對其進行訂閱的時候，它只能收到在訂閱之前傳送出的最後一個結果（或者說最新的值），在這之前的結果是無法被接收到的。比如，下面的例子中，新註冊的 observer 只能接收到 "one", "two" 和 "three"，但是無法接收到 "zero"：BehaviorSubject<Object> subject = BehaviorSubject.create(); subject.onNext("zero"); subject.onNext("one"); subject.subscribe(observer); subject.onNext("two"); subject.onNext("three"); 複製程式碼 -
PublishSubject:不會改變事件的傳送順序；在已經傳送了一部分事件之後註冊的 Observer 不會收到之前傳送的事件。比如，在下面的程式碼中，observer1 會收到所有的 onNext() 和 onComplete() 發出的結果，但是 observer2 只能收到 "three" 和最終的 onComplete()：PublishSubject<Object> subject = PublishSubject.create(); // observer1 進行訂閱 subject.subscribe(observer1); subject.onNext("one"); subject.onNext("two"); // observer2 進行訂閱 subject.subscribe(observer2); subject.onNext("three"); subject.onComplete(); 複製程式碼 -
ReplaySubject:無論什麼時候註冊 Observer 都可以接收到任何時候通過該 Observable 發射的事件。比如，在下面的程式碼中，observer1 和 observer2 可以收到在它們進行訂閱之前的所有的 onNext() 和 onCompete() 事件：ReplaySubject<Object> subject = ReplaySubject.create(); subject.onNext("one"); subject.onNext("two"); subject.onNext("three"); subject.onComplete(); // observer1 和 observer2 進行訂閱 subject.subscribe(observer1); subject.subscribe(observer2); 複製程式碼 -
UnicastSubject:只允許一個 Observer 進行監聽，在該 Observer 註冊之前會將發射的所有的事件放進一個佇列中，並在 Observer 註冊的時候一起通知給它。比如，在下面的例子中，當 observer1 進行訂閱的時候，會將 "one" "two" "three" 依次傳送給 observer1，而當 observer2 進行訂閱的時候會丟擲一個異常，因為只能有一個觀察者可以訂閱：UnicastSubject<String> subject = UnicastSubject.create(); subject.onNext("one"); subject.onNext("two"); subject.onNext("three"); subject.subscribe(observer1); subject.subscribe(observer2); 複製程式碼
對比 PublishSubject 和 ReplaySubject，它們的區別在於新註冊的 Observer 是否能夠收到在它註冊之前傳送的事件。這個類似於 EventBus 中的 StickyEvent 即黏性事件，為了說明這一點，我們準備了下面兩段程式碼：
private static void testPublishSubject() throws InterruptedException {
PublishSubject<Integer> subject = PublishSubject.create();
subject.subscribe(i -> System.out.print("(1: " + i + ") "));
Executor executor = Executors.newFixedThreadPool(5);
Disposable disposable = Observable.range(1, 5).subscribe(i -> executor.execute(() -> {
try {
Thread.sleep(i * 200);
subject.onNext(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}));
Thread.sleep(500);
subject.subscribe(i -> System.out.print("(2: " + i + ") "));
Observable.timer(2, TimeUnit.SECONDS).subscribe(i -> ((ExecutorService) executor).shutdown());
}
private static void testReplaySubject() throws InterruptedException {
ReplaySubject<Integer> subject = ReplaySubject.create();
subject.subscribe(i -> System.out.print("(1: " + i + ") "));
Executor executor = Executors.newFixedThreadPool(5);
Disposable disposable = Observable.range(1, 5).subscribe(i -> executor.execute(() -> {
try {
Thread.sleep(i * 200);
subject.onNext(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}));
Thread.sleep(500);
subject.subscribe(i -> System.out.print("(2: " + i + ") "));
Observable.timer(2, TimeUnit.SECONDS).subscribe(i -> ((ExecutorService) executor).shutdown());
}
複製程式碼它們的輸出結果依次是
PublishSubject的結果：(1: 1) (1: 2) (1: 3) (2: 3) (1: 4) (2: 4) (1: 5) (2: 5)
ReplaySubject的結果： (1: 1) (1: 2) (2: 1) (2: 2) (1: 3) (2: 3) (1: 4) (2: 4) (1: 5) (2: 5)
複製程式碼從上面的結果對比中，我們可以看出前者與後者的區別在於新註冊的 Observer 並沒有收到在它註冊之前傳送的事件。試驗的結果與上面的敘述是一致的。
其他的測試程式碼這不一併給出了，詳細的程式碼可以參考Github - Java Advanced。
2、用 RxJava 打造 EventBus
2.1 打造 EventBus
清楚了 Subject 的概念之後，讓我們來做一個實踐——用 RxJava 打造 EventBus。
我們先考慮用一個全域性的 PublishSubject 來解決這個問題，當然，這意味著我們傳送的事件不是黏性事件。不過，沒關係，只要這種實現方式搞懂了，用 ReplaySubject 做一個傳送黏性事件的 EventBus 也非難事。
考慮一下，如果要實現這個功能我們需要做哪些準備：
- 我們需要傳送事件並能夠正確地接收到事件。 要實現這個目的並不難，因為 Subject 本身就具有傳送和接收兩個能力，作為全域性的之後就具有了全域性的註冊和通知的能力。因此，不論你在什麼位置傳送了事件，任何訂閱的地方都能收到該事件。
- 首先，我們要在合適的位置對事件進行監聽，並在合適的位置取消事件的監聽。如果我們沒有在適當的時機釋放事件，會不會造成記憶體洩漏呢？這還是有可能的。 所以，我們需要對註冊監聽的觀察者進行記錄，並提供註冊和取消註冊的方法，給它們在指定的生命週期中進行呼叫。
好了，首先是全域性的 Subject 的問題，我們可以實現一個靜態的或者單例的 Subject。這裡我們選擇使用後者，所以，我們需要一個單例的方式來使用 Subject：
public class RxBus {
private static volatile RxBus rxBus;
private final Subject<Object> subject = PublishSubject.create().toSerialized();
public static RxBus getRxBus() {
if (rxBus == null) {
synchronized (RxBus.class) {
if(rxBus == null) {
rxBus = new RxBus();
}
}
}
return rxBus;
}
複製程式碼}
這裡我們應用了 DCL 的單例模式提供一個單例的 RxBus，對應一個唯一的 Subject. 這裡我們用到了 Subject 的toSerialized()，我們上面已經提到過它的作用，就是用來保證 onNext() 等方法的執行緒安全性。
另外，因為 Observalbe 本身是不支援背壓的，所以，我們還需要將該 Observable 轉換成 Flowable 來實現背壓的效果：
public <T> Flowable<T> getObservable(Class<T> type){
return subject.toFlowable(BackpressureStrategy.BUFFER).ofType(type);
}
複製程式碼這裡我們用到的背壓的策略是BackpressureStrategy.BUFFER，它會快取發射結果，直到有消費者訂閱了它。而這裡的ofType()方法的作用是用來過濾發射的事件的型別，只有指定型別的事件會被髮布。
然後，我們需要記錄訂閱者的資訊以便在適當的時機取消訂閱，這裡我們用一個Map<String, CompositeDisposable>型別的雜湊表來解決。這裡的CompositeDisposable用來儲存 Disposable，從而達到一個訂閱者對應多個 Disposable 的目的。CompositeDisposable是一個 Disposable 的容器，聲稱可以達到 O(1) 的增、刪的複雜度。這裡的做法目的是使用註冊觀察之後的 Disposable 的 dispose() 方法來取消訂閱。所以，我們可以得到下面的這段程式碼：
public void addSubscription(Object o, Disposable disposable) {
String key = String.valueOf(o.hashCode());
if (disposableMap.get(key) != null) {
disposableMap.get(key).add(disposable);
} else {
CompositeDisposable disposables = new CompositeDisposable();
disposables.add(disposable);
disposableMap.put(key, disposables);
}
}
public void unSubscribe(Object o) {
String key = String.valueOf(o.hashCode());
if (!disposableMap.containsKey(key)){
return;
}
if (disposableMap.get(key) != null) {
disposableMap.get(key).dispose();
}
disposableMap.remove(key);
}
複製程式碼最後，對外提供一下 Subject 的訂閱和釋出方法，整個 EventBus 就製作完成了：
public void post(Object o){
subject.onNext(o);
}
public <T> Disposable doSubscribe(Class<T> type, Consumer<T> next, Consumer<Throwable> error){
return getObservable(type)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(next,error);
}
複製程式碼2.2 測試效果
我們只需要在最頂層的 Activity 基類中加入如下的程式碼。這樣，我們就不需要在各個 Activity 中取消註冊了。然後，就可以使用這些頂層的方法來進行操作了。
protected void postEvent(Object object) {
RxBus.getRxBus().post(object);
}
protected <M> void addSubscription(Class<M> eventType, Consumer<M> action) {
Disposable disposable = RxBus.getRxBus().doSubscribe(eventType, action, LogUtils::d);
RxBus.getRxBus().addSubscription(this, disposable);
}
protected <M> void addSubscription(Class<M> eventType, Consumer<M> action, Consumer<Throwable> error) {
Disposable disposable = RxBus.getRxBus().doSubscribe(eventType, action, error);
RxBus.getRxBus().addSubscription(this, disposable);
}
@Override
protected void onDestroy() {
super.onDestroy();
RxBus.getRxBus().unSubscribe(this);
}
複製程式碼在第一個 Activity 中我們對指定的型別的結果進行監聽：
addSubscription(RxMessage.class, rxMessage -> ToastUtils.makeToast(rxMessage.message));
複製程式碼然後，我們在另一個 Activity 中釋出事件：
postEvent(new RxMessage("Hello world!"));
複製程式碼這樣當第二個 Activity 中呼叫指定的傳送事件的方法之後，第一個 Activity 就可以接收到發射的事件了。
總結
好了，以上就是 Subject 的使用，如果要用一個詞來形容它的話，那麼只能是“自給自足”了。就是說，它同時做了 Observable 和 Observer 的工作，既可以發射事件又可以對事件進行消費，可謂身兼數職。它在那種想要對某個值進行監聽並處理的情形特別有用。因為它不需要你寫多個冗餘的類，只要它一個就完成了其他兩個類來完成的任務，因而程式碼更加簡潔。
RxJava 系列文章：
- 《RxJava2 系列-1：一篇的比較全面的 RxJava2 方法總結》
- 《RxJava2 系列-2：背壓和Flowable》
- 《RxJava2 系列-3：使用 Subject》
2018年10月26日修正
更正 RxBus 中的 addSubscription() 和 unSubscribe() 兩個方法，在之前的版本中使用傳入的 Object 的類名作為雜湊表的鍵，現改為使用 Object 的雜湊碼作為雜湊表的鍵：使用類名的時候存在一個問題，即如果在 Fragment 中使用 RxBus，並且同一型別的 Fragment 在多個地方使用，會導致其中一個 Fragment 取消訂閱的時候，所有同一型別的 Fragment 都取消訂閱。