Rxjava温故知新（十）------100行代码实现RxJava的Observable.create（简版）

1.前言

前面讲解了一些操作符的使用，现在我们看一下部分源码，实现一个简单版本Rxjava的Observable.create到订阅的动作。

2.实现简版RxJava

2.1 代码分析

首先我们来看看RxJava里面的源码走向是怎么的，从Observable.create到subscribe里面做了些什么操作，最后消息会发送到我们的观察者里面

我们知道RxJava Observable是一个被观察者，Observer是一个观察者，那么我们先看这2个类的定义可以知道:
1.Observable是一个抽象类，里面有一系列的静态方和私有方法，其中就有我们需要了解的create方法和subscribe
2.Observer 是一个接口，里面包含了要实现的方法。主要用于接收上游发射的数据 （图二）
3.Observable 通过 订阅（subscribe） Observer ，建立关系，然后下游可以接收到上游发送的消息。

来看一段简单的代码

Observable.create(new ObservableOnSubscribe<Object>() {
        @Override
        public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
            emitter.onNext("发送数据");
        }
    }).subscribe(new Observer<Object>() {
        @Override
        public void onSubscribe(Disposable d) {
        }

        @Override
        public void onNext(Object o) {
            Log.i(TAG, "onNext: " + o);
        }

        @Override
        public void onError(Throwable e) {
        }

        @Override
        public void onComplete() {
        }
    });

最后输出：

onNext：发送数据

接下来我们具体跟进去代码 看代码是如何实现的 首先我们看调用create做了什么操作

2.1.1 Observable.create方法调用

这里简单画了一幅图，提取了里面一些关键方法的调用，来看看实际上RxJava里面内部是怎么操作的。

上面的图里面有2个很重要的类，一个是ObservableCreate，一个是CreateEmitter类 这2个类实际上是真正执行调用的地方，ObservableCreate类会拿到外部传进来的ObservableOnSubscribe接口实例，然后在内部调用接口的回调方法， 同时把CreateEmitter传递出去，CreateEmitter又持有外部订阅的Observer，这样在ObservableOnSubscribe接口回调里面，就可以拿到CreateEmitter（实现自ObservableEmitter接口—内部有onNext方法）的实例，然后调用它内部的onNext方法，然后在它内部用Observer的onNext方法，打到消息的传递。来看看这个类。

首先调用create方法

流程分析

1在调用Observable.create中会传如一个参数 ObservableOnSubscribe 
2.在调用create的时候会新建一个对象ObservableCreate返回，这是一个新的Observable（被观察者）。
  所以后续的操作都是基于这个新的Observable来进行的。
3.然后开始调用订阅方法，subscribe
4.在调用订阅方法，首先会执行父类的subscribe方法，然后执行ObservableCreate中的subscribeActual
  因为在父类中调用subscribeActual，ObservableCreate有重写这个抽象方法。
5.然后会回调到第一步骤中传入的ObservableOnSubscribe接口中的subscribe方法，
  同时会传入一个新的对象回去，CreateEmitter ,这个对象会持有订阅的时候传入的观察者Observer。
6.现在已经可以回调到ObservableOnSubscribe 接口中subscribe方法
7.在ObservableOnSubscribe 的subscribe方法中拿到CreateEmitter的引用，可以调用onNext
8.最后在CreateEmitter的Next方法中会触发Observer的onNext方法，因为CreateEmitter持有Observer的引用。
9.最后消息会被发送到我们下游。

3.手动实现

根据上面的流程和我们的日常使用，我们常用的几个类可以先写出来，然后模仿去实现内部逻辑。

假设我们可以先写一段伪代码

Observable.create(new ObservableOnSubscribe<T>{}).subscribe(new Observer<T>{})

首先看上面这段代码我们知道这里至少需要的就是需要三个类了。Observable，ObservableOnSubscribe，Observer

然后看原始内部调用create中需要传入一个ObservableCreate，然后内部还有一个CreateEmitter类，额外还需要一个ObservableEmitter接口类。

我们可以先把这五个类新建好，然后一步步实现，这里我已经写好了 ，也不太好一个个的讲解，把这几个类我先贴出来大家先看下。

/***
 * 被观察者
 * @param <T>
 */
public abstract class Observable<T> {

    /***
     * 创建一个Observable
     * @param emitter
     * @param <T>
     * @return
     */
    public static <T> Observable<T> create(ObservableOnSubscribe<T> emitter) {
        //需要包装一层
        return new ObservableCreate<T>(emitter);
    }

    /***
     * 订阅观察者
     * @param observer
     */
    public  void subscribe(Observer<? super T> observer) {
        subscribeActual(observer);
    }

    /***
     * 内部实现
     * @param observer
     */
    abstract void subscribeActual(Observer<? super T> observer);
}

.

/***
 * 观察者
 * @param <T>
 */
public interface Observer<T> {

    void onNext(T t);
}

.

/***
 * 主要通过ObservableEmitter发送消息
 * @param <T>
 */
public interface ObservableOnSubscribe<T> {

    void subscribe(ObservableEmitter<T> emitter) throws Exception;
}

.

/***
 * 消息发送接口
 * @param <T>
 */
public  interface ObservableEmitter<T>  {
    void accapt(T t);
}

.

/***
 * 实际的Oberveable方法
 * @param <T>
 */
public class ObservableCreate<T> extends Observable<T> {

    ObservableOnSubscribe<T> source;

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

    @Override
    public void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> createEmitter = new CreateEmitter<T>(observer);
        try {
            source.subscribe(createEmitter);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    private class CreateEmitter<T> implements ObservableEmitter<T> {
        private Observer<? super T> observer;
        public CreateEmitter(Observer<? super T> observer) {
            this.observer = observer;
        }
        @Override
        public void accapt(T t) {
            observer.onNext(t);
        }
    }
}	

好了，就是这五个类，数了一下，加上注释总共100行左右代码，实现了一个最简单的RxJava版本，里面去除了原始RxJava的onComplete，onError，onSubscribe方法，因为这里只是实现一个最简单版本的，了解其内部核心。所以其他的方法也能很快明白啦。这里就没有写其他的了，大家可以完善扩展。 接下来看看用我们写的版本来跑一边把 ，先看看写法。

接下来看看输出效果

ok，到这里我们的手写简版RxJava就算实现了。

4.最后

分析有问题的，欢迎大家指正哈。