前言：
現在面試很多都會問RxJava的原始碼，直接講RxJava的原始碼，估計大家都不太會看下去，我們先看個小考題，然後再去看相關的原始碼。
正文：
問題一：
//物件類
class Data {
public String name;
public Data(String name) {
this.name = name;
}
}
//比如我們使用just操作符來傳送二個Data物件
Observable<Data> data = Observable.just(
new Data("aaaa"),
new Data( "bbbb")
);
//比如我們用一個Consumer物件來訂閱
data.subscribe(new Consumer<Data>() {
@Override
public void accept(Data data) throws Exception {
//裡面的內容是把Observable傳送過來的物件裡面的name屬性值改成cccc
data.name = "cccc";
}
});
//這時候我們在用一個新的Consumer來訂閱這個Observable
data.subscribe(new Consumer<Data>() {
@Override
public void accept(Data data) throws Exception {
//這時候列印data.name
Log.v("TAG",data.name);
}
});
複製程式碼問題：
我們用二個Customer分別去訂閱一個傳送物件的Observable,這時候我們的Log.v("TAG",data.name);輸出內容是什麼。
問題二：
Observable<Integer> data1 = Observable.just(
1,2
);
data1.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer d) throws Exception{
d++;
}
});
data1.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer d) throws Exception{
Log.v("TAG","d:"+d);
}
});
複製程式碼問題：
這時候我們的Log.v("TAG","d:"+d);輸出內容是什麼。
答案是： 第一個輸出是cccc,cccc;第二個是1,2。不知道大家做對了沒有。
如果沒有做對題目的，我們就來一起來分析程式碼。
問題分析：
我們先看第一個情形的程式碼：
Observable.just(
new Data("aaaa"),
new Data( "bbbb")
);
複製程式碼just原始碼 ：
public static <T> Observable<T> just(T item1, T item2) {
ObjectHelper.requireNonNull(item1, "The first item is null");
ObjectHelper.requireNonNull(item2, "The second item is null");
return fromArray(item1, item2);
}
複製程式碼前面的二行是檢查是否為null。主要是第三行通過fromeArray返回了一個Observable。
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Observable<T> fromArray(T... items) {
ObjectHelper.requireNonNull(items, "items is null");
if (items.length == 0) {
return empty();
} else
if (items.length == 1) {
return just(items[0]);
}
return RxJavaPlugins.onAssembly(new ObservableFromArray<T>(items));
}
複製程式碼我們可以看到根據使用者傳的個數，返回不同的Observable，比如0個的時候返回empty();,一個的時候返回just(items[0]);,其他都返回RxJavaPlugins.onAssembly(new ObservableFromArray<T>(items));,但其實本質都差不多。為什麼這麼說：
empty()原始碼：
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
@SuppressWarnings("unchecked")
public static <T> Observable<T> empty() {
return RxJavaPlugins.onAssembly((Observable<T>) ObservableEmpty.INSTANCE);
}
複製程式碼我們可以看到也是呼叫了RxJavaPlugins.onAssembly方法。
just(items[0])原始碼：
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Observable<T> just(T item) {
ObjectHelper.requireNonNull(item, "The item is null");
return RxJavaPlugins.onAssembly(new ObservableJust<T>(item));
}
複製程式碼其實也是呼叫了RxJavaPlugins.onAssembly方法。
所以三者雖然是不同的Observable，但是都是呼叫RxJavaPlugins.onAssembly方法，然後傳入不同的物件引數而已。
PS : 對於我們平時見到的什麼
Observable.create方法，或者Observable.interval方法等，都是最終呼叫RxJavaPlugins.onAssembly方法，只是一個呼叫了RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));,一個呼叫了RxJavaPlugins.onAssembly(new ObservableInterval(xxx,xxxx,xxxx))方法。
因為我們的情形一種是發射了二個物件，那我們就重點來看一下RxJavaPlugins.onAssembly(new ObservableFromArray<T>(items));方法：
我們可以看到RxJavaPlugins.onAssembly方法：
@SuppressWarnings({ "rawtypes", "unchecked" })
@NonNull
public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
Function<? super Observable, ? extends Observable> f = onObservableAssembly;
if (f != null) {
return apply(f, source);
}
return source;
}
複製程式碼我們可以看到最後返回了傳入的Observable source，所以也就是我們傳入的new ObservableFromArray<T>(items)。
所以最終我們拿到的Observable是new ObservableFromArray<T>(items),所以我們一般接下去就是
//本質就是傳了一個 new ObservableFromArray<T>(items)
Observable observable = Observable.just(
new Data("aaaa"),
new Data( "bbbb")
);
//比如我們用一個Observer物件來訂閱
observable .subscribe(new Observer<Data>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Data data) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
複製程式碼我們先來看subscribe方法：
@SchedulerSupport(SchedulerSupport.NONE)
@Override
public final void subscribe(Observer<? super T> observer) {
ObjectHelper.requireNonNull(observer, "observer is null");
try {
observer = RxJavaPlugins.onSubscribe(this, observer);
ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
//最終呼叫了Observable的subscribeActual方法
subscribeActual(observer);
} catch (NullPointerException e) { // NOPMD
throw e;
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
// can't call onError because no way to know if a Disposable has been set or not
// can't call onSubscribe because the call might have set a Subscription already
RxJavaPlugins.onError(e);
NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
npe.initCause(e);
throw npe;
}
}
複製程式碼我們可以看到程式碼裡面的加的備註，說明最終我們的
observable.subscribe(observer)最終執行了變為：observable.subscribeActual(observer);,因為我們說過我們的observable具體是ObservableFromArray的例項，所以我們直接看相關原始碼。
ObservableFromArray.class：
public final class ObservableFromArray<T> extends Observable<T> {
final T[] array;
//例項化物件的呼叫的建構函式，同時傳入我們要傳送的陣列
public ObservableFromArray(T[] array) {
this.array = array;
}
//最終訂閱的時候呼叫這個方法
@Override
public void subscribeActual(Observer<? super T> s) {
//new 一個我們平時用來取消訂閱的Disposable，這裡具體是FromArrayDisposable
FromArrayDisposable<T> d = new FromArrayDisposable<T>(s, array);
//也就是我們Observer複寫的onSubscribe方法，並把Disposable物件傳入
s.onSubscribe(d);
if (d.fusionMode) {
return;
}
//然後執行了FromArrayDisposable物件的run方法
d.run();
}
static final class FromArrayDisposable<T> extends BasicQueueDisposable<T> {
final Observer<? super T> actual;
final T[] array;
int index;
boolean fusionMode;
volatile boolean disposed;
//建構函式，傳入了Observer 和我們要傳的陣列
FromArrayDisposable(Observer<? super T> actual, T[] array) {
this.actual = actual;
this.array = array;
}
@Override
public int requestFusion(int mode) {
if ((mode & SYNC) != 0) {
fusionMode = true;
return SYNC;
}
return NONE;
}
@Nullable
@Override
public T poll() {
int i = index;
T[] a = array;
if (i != a.length) {
index = i + 1;
return ObjectHelper.requireNonNull(a[i], "The array element is null");
}
return null;
}
@Override
public boolean isEmpty() {
return index == array.length;
}
@Override
public void clear() {
index = array.length;
}
//我們用來取消訂閱的方法
@Override
public void dispose() {
disposed = true;
}
//用來判斷是否取消了訂閱
@Override
public boolean isDisposed() {
return disposed;
}
//當訂閱的時候，真正執行的是Disposable的run方法。
void run() {
T[] a = array;
int n = a.length;
/*遍歷我們要傳的陣列，然後並且判斷isDisposed()的disposed值
所以我們就知道了為啥我們取消訂閱只要執行Disposable.dispose()方法了
因為這時候會把disposed返回true,然後這裡的for迴圈判斷就會退出迴圈。
*/
for (int i = 0; i < n && !isDisposed(); i++) {
T value = a[i];
/*我們知道在RxJava 1的時候我們傳送一個null值是可以的，
但是RxJava2就不行了，因為做了一個判空操作。
就會執行Observer的onError方法
*/
if (value == null) {
actual.onError(new NullPointerException("The " + i + "th element is null"));
return;
}
//執行Observer的onNext方法，並且把值一個個傳過去
actual.onNext(value);
}
/*如果使用者在onNext都執行完後，並且沒有執行dispose()方法，
則if裡面為true，就會執行Observer的onComplete()方法。
*/
if (!isDisposed()) {
actual.onComplete();
}
}
}
}
複製程式碼我們通過程式碼可以看到，其實Observable在生成例項後，裡面傳送的陣列是同一個陣列，並且傳送的資料也是同一個資料，所以雖然我們用多個Observer去訂閱的時候，收到的Data物件是同一個，但是因為第一個Observer對這個物件裡面的屬性修改了，所以第二個Observer對獲取同個物件的時候，獲取的屬性值也就變了。
簡單可以這麼理解：
Data data = new Data("aaaa");
Log.v("TAG",data.name);
change(data);
Log.v("TAG",data.name)
public void change(Data data){
data.name = "bbbb";
}
複製程式碼其實我們可以這麼理解。雖然都是列印同一個物件，但是屬性被更改了。
所以我們的情形一的程式碼結果是不是已經能理解了呢，各位。
而情形二其實不是考驗RxJava的原始碼基礎，而是考驗 Java基礎。因為情形二我們傳送的是（1，2）;相當於：
int data = 1;
Log.v("TAG","data:"+data);
change(data);
Log.v("TAG","data:"+data);
public void change(int data){
data = 2;
}
複製程式碼你就會發現其實二個Log列印的內容是一樣的，都是1。
與其他語言不同，Java不允許程式設計師選擇按值傳遞還是按引用傳遞各個引數，基本型別(byte--short--int--long--float--double--boolean--char)的變數總是按值傳遞。就物件而言，不是將物件本身傳遞給方法，而是將物件的的引用或者說物件的首地址傳遞給方法，引用本身是按值傳遞的-----------也就是說，講引用的副本傳遞給方法（副本就是說明物件此時有兩個引用了），通過物件的引用，方法可以直接操作該物件（當操作該物件時才能改變該物件，而操作引用時源物件是沒有改變的）。
具體可以參考這篇：Java值傳遞以及引用的傳遞、陣列的傳遞
結語：
所以本章我們更多地看了Rxjava的Observable生成及Observer訂閱時候的部分原始碼及Java值傳遞等相關知識。