手動寫一個Rxjava和源碼理解（一）事件的發送和訂閱

背景：很早之前其實就有這個想法，因爲覺得RxJava真的很神奇，特別它的鏈式調用和線程切換，真的是一個很神奇的框架

我的Rxjava的簡單理解

RxJava是一個觀察者和被觀察者，Observable是觀察者，所有的事件創建，邏輯處理，事件發送，其實都是Observable中發送，只是RxJava採取了一個巧妙的方式，Observale只負責接收事件源，事件的發送交給了一個叫 Emitter的類，Observer負責接收事件，並處理相關業務，下面結合代碼來進行分析

	（1）todo 創建被觀察者，參數是一個藉口類，就是當訂閱時間發生後，接口的subscribe會自動被調用
 Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableCreate.Emitter<Integer> emitter) throws Exception {
						//todo 處理業務邏輯
                        //發送事件
                        emitter.next(1);
                        emitter.next(2);
                    }
                }).map(new Function<Integer, String>() {
                    @Override
                    public String apply(Integer r) {
                    //數據轉換
                        return r+"";
                    }
                })
                //被觀察者處理業務發生的線程
                .subscribeOn(Schedulers.IO)
					//被觀察者處理業務發生的線程
                        .observerOn(Schedulers.MAIN)
						//觀察者處理業務發生的線程，所有的事件接收的回調方法都會在這個線程中處理
                        .subscribe(new Observer<String>() {
                            @Override
                            public void onSubscribe() {
								//訂閱前的回調
                                Log.i(TAG, "onSubscribe");
                            }

                            @Override
                            public void onNext(String value) {
                            		//接收事件
                                Log.i(TAG, "onNext："+value);
                            }

                            @Override
                            public void onError(Throwable e) {
                            	//接收觀察者發送出來的錯誤事件
                                Log.i(TAG, "onError");
                            }

                            @Override
                            public void onComplete() {
                            //接收觀察者處理業務完成的回調
                                Log.i(TAG, "onComplete");
                            }
                        });

下面開始用源碼分析其中的過程是怎麼完成的

第一步：分析被觀察者是怎麼被創建的

 Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableCreate.Emitter<Integer> emitter) throws Exception {
						//todo 處理業務邏輯
                        //發送事件
                        emitter.next(1);
                        emitter.next(2);
                    }
                })

要理解這個就必須要理解Observable類，下面是Observable的源代碼

public abstract class Observable<T> implements ObservableSource<T> {
    @Override
    public void subscribe(Observer<? super T> observer) {
        subscribeActual(observer);
    }

    protected abstract void subscribeActual(Observer<? super T> observer);

    public static <T> Observable<T> create(ObservableOnSubscribe<T> observableCreate) {
        return new ObservableCreate(observableCreate);
    }


    public final Observable<T> subscribeOn(Scheduler scheduler) {
        return new ObservableSubscribeOn<T>(this, scheduler);
    }

    public final <R> Observable<R> map(Function<? super T, ? extends R> function) {
        return new ObservableMap<T, R>(this, function);
    }

    public final Observable<T> observerOn(Scheduler scheduler) {
        return new ObservableObserverOn<T>(this, scheduler);
    }
}

可以看到Observable實際上是一個抽象類，並實現了一個接口ObservableSource

public interface ObservableSource<T> {
    void subscribe(Observer<? super T> observer);
}

這個接口就一個方法 subscribe，而這方法正是訂閱開始的方法，接下來我們來看Observable的Create方法

 public static <T> Observable<T> create(ObservableOnSubscribe<T> observableCreate) {
        return new ObservableCreate(observableCreate);
    }

它是直接New了ObservableCreate的實例，所以接下來需要看ObservableCreate的代碼實現

public class ObservableCreate<T> extends Observable<T> {


    ObservableOnSubscribe<T> observableOnSubscribe;

    public ObservableCreate(ObservableOnSubscribe<T> observableOnSubscribe) {
        this.observableOnSubscribe = observableOnSubscribe;
    }


    @Override
    protected void subscribeActual(Observer<? super T> observer) {

        Emitter<T> emitter = new Emitter<T>(observer);
        observer.onSubscribe();
        try {
            observableOnSubscribe.subscribe(emitter);
            emitter.onComplete();
        } catch (Exception e) {
            emitter.error(e);
            e.printStackTrace();
        }
    }





   public static class Emitter<T> {

        Observer<? super T> observer;

        public Emitter(Observer<? super T> observer) {
            this.observer = observer;
        }

        public void next(T t) {
            observer.onNext(t);
        }

        public void error(Throwable throwable) {
            observer.onError(throwable);
        }

        public void onComplete() {
            observer.onComplete();
        }
    }
}

ObservableCreate 裏面有一個Emitter的靜態類，這個類就是Rxjava的事件發射器，next(T t) 調用了Observer方法的next方法，完成整個事件的發送和接收

（二）訂閱是怎麼被觸發的？

要理解這個，就需要理解 Observable的subscribe方法

    @Override
    public void subscribe(Observer<? super T> observer) {
        subscribeActual(observer);
    }

這個方法實際上調用的是subscribeActual這個方法

    protected abstract void subscribeActual(Observer<? super T> observer);

subscribeActual其實是一個抽象方法，具體的實現是方法Observable的子類裏面，ObservableCreate便是Observable的子類

至此，RxJava最簡單的鏈式調用完成！