手动写一个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最简单的链式调用完成！