RxJava 2

1.前言

本着更好的使用Rxjava 的心理看了部分Rxjava的部分源码，写一点自己的理解，主要是说 Observable的create()和subscribe()调用时发生了什么，也不关注线程调度(以后再说..)。

2.主要类介绍

Observable 被观察者 抽象类
ObservableOnSubscribe 功能性接口 订阅完成时回调并带回一个Emitter
Emitter 发射器 发送事件(发送onNext/onError/onComplete 事件)
Observer 观察者 监听事件(接收onNext/onSubscribe/onError/onComplete 事件)
Consumer 消费者(另外一种观察者 单一的监听onNext/onSubscribe/onError/onComplete )
Subject 实现多监听(Observable子类，同时实现了Observer接口)
Flowable被观察者（支持背压，不说它）
Subscriber观察者 （支持背压，也不说它）

①Observable 被观察者

这是一个抽象类，实现了接口

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

它只有一个抽象方法 void subscribeActual();
这个方法在订阅关系实际发生时被调用,也就是subscribe被调用时这个方法会被调用;
类似构建者模式，在subscribe被调用前，基本所有public方法都返回它本身。
Rxjava的所有操作符，如just map .. 都定义在这个类中;

②Emitter 发射器

public interface Emitter<T> {
    void onNext(T t)
    void onError(Throwable error);
    void onComplete();
}

一般来说，是它的实现类用来发送消息，Observer的实现类来接受消息。

③Observer 观察者

public interface Observer<T> {
    void onSubscribe(Disposable d);
    void onNext(T value);
    void onError(Throwable e);
    void onComplete();
}

④ObservableOnSubscribe

public interface ObservableOnSubscribe<T> {
    void subscribe(ObservableEmitter<T> e) throws Exception;
}

一个功能性接口，就是在create方法被调用时使用，当subscribe被调用时回调。用于绑定Emitter和Observer。

⑤Consumer

public interface Consumer<T> {
    void accept(T t) throws Exception;
}

它也是一种观察者，和Observer主要有两个区别。
1，相对于Observer实现了四种事件的接受，Consumer只接受单一的事件，可以是四种事件中的任何一种，如果你想接受多个事件（比如onNext(),oncomplete()）,可以在subscribe()里传入多个Consumer的实现。
2，它和Observer的另外一个区别是传入Observer是一个空返回值，而Consumer会返回一个Dispose对象。

⑥Subject

 public abstract class Subject<T> extends Observable<T> implements Observer<T> {
       public abstract boolean hasObservers();
       public abstract boolean hasThrowable();
       public abstract boolean hasComplete();
       public abstract Throwable getThrowable();
    }

这个玩意继承自Obserable同时也实现了Observer，也就是说它既是观察者也是被观察者。
其实他就是实现多分发的，几个子类也都是各种花样的分发事件(子类如PublishSubject,ReplaySubject)。可以这样想，既然他是一个Obserable，我们就可以订阅，总不能订阅了没任何作用吧…,
等下看看他一个子类的PublishSubject的代码就知道了..

⑦Flowable和Subscriber

Flowable/Subscriber 
Single/SingleObserver
Completable/CompletableObserver
Maybe/MaybeObserver

这些前面都是被观察者，后面是观察者。Flowable/Subscriber 是用来支持背压的。后面三个都是针对单一事件的(如果你只关注事件执行的结果，可以使用后面三个中的一个，用法的话试一下就知道了，基本同Observable和Observer类似);
关于这四种观察者模式的介绍， 可以点这个链接去看看

3.一个基础的Rxjava流程分析

Observable
    .create(new ObservableOnSubscribe<Integer>() {
           @Override
           public void subscribe(ObservableEmitter<Integer> e) throws Exception {
               e.onNext(1);
               e.onNext(2);
               e.onComplete();
           }
       })
       .subscribe(new Observer<Integer>() {
           @Override
           public void onSubscribe(Disposable d) {}
           @Override
           public void onNext(Integer value){}
           @Override
           public void onError(Throwable e) {}
           @Override
           public void onComplete() {}
       });

上面是一个最简单的用法，没有线程切换，只关注这个过程中Rxjava做了什么操作.
首先看一下create方法的源码：

 public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
       ObjectHelper.requireNonNull(source, "source is null");
       return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
   }

可以看到创建了一个Observable 的子类ObservableCreate 并返回，下面是类ObservableCreate 的部分代码。

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;
    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        observer.onSubscribe(parent);
        source.subscribe(parent);
    }       
}

这个实现类的构造方法中记录create()方法传入的ObservableOnSubscribe 对象，当subscribe()被调用时
回调它的subscribeActual（)方法；

@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");
        subscribeActual(observer);
    } catch (Throwable e) {
        ...
    }
}

那么我们看一下回调方法里做了什么（代码在上面类ObservableCreate 中）：
1,创建一个发射器CreateEmitter，并把Observe传递过去。这个是ObservableCreate的一个内部类，实现了ObservableEmitter接口
2,回调Observe的onSubscribe()方法
3,回调ObservableOnSubscribe的subscribe()方法，并把创建的Emitter传递回去。
下面贴一下Emitter的部分代码:

    static final class CreateEmitter<T> extends AtomicReference<Disposable> implements ObservableEmitter<T>, Disposable {
        final Observer<? super T> observer;
        CreateEmitter(Observer<? super T> observer) {
            this.observer = observer;
        }
        @Override
        public void onNext(T t) {
            if (!isDisposed()) {
                observer.onNext(t);
            }
        }
        @Override
        public void onError(Throwable t) {
            if (!isDisposed()) {
                try {
                    observer.onError(t);
                } finally {
                    dispose();
                }
            } else {
                RxJavaPlugins.onError(t);
            }
        }
        @Override
        public void onComplete() {
            if (!isDisposed()) {
                try {
                    observer.onComplete();
                } finally {
                    dispose();
                }
            }
        }
    }

可以看到，当我们调用emitter的onNext()方法时，这个内部类会回调Observe的onNext()方法，onComplete方法同理。而onSubscribe()的回调是发生在subscribe()被调用时。至此，便完成了一个观察者模式。

图片画图画的，好丑..

4,从源码看Consumer和Observable的区别

    //一个参数的subscribe(),Consumer监听的是onNext事件,其他三个使用默认Action去填充
    public final Disposable subscribe(Consumer<? super T> onNext) {
        return subscribe(onNext, Functions.ERROR_CONSUMER, Functions.EMPTY_ACTION, Functions.emptyConsumer());
    }
    //两个参数的subscribe(),第一个Consumer监听的是onNext事件,第二个Consumer监听的是onError事件，其他两个使用默认Action去填充
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {
        return subscribe(onNext, onError, Functions.EMPTY_ACTION, Functions.emptyConsumer());
    }
    //三个参数的subscribe(),第一个Consumer监听的是onNext事件,第二个Consumer监听的是onError事件，第三个Consumer监听Complete事件,onSubscribe事件使用默认去填充。
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
            Action onComplete) {
        return subscribe(onNext, onError, onComplete, Functions.emptyConsumer());
    }
    //四个参数的subscribe监听全部事件，他和Observer的区别就只是他会返回一个Disposable对象。
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
            Action onComplete, Consumer<? super Disposable> onSubscribe) {
        ObjectHelper.requireNonNull(onNext, "onNext is null");
        ObjectHelper.requireNonNull(onError, "onError is null");
        ObjectHelper.requireNonNull(onComplete, "onComplete is null");
        ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");
        LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);
        subscribe(ls);
        return ls;
    }

无论那个传入几个参数，最终subscribe都会补充其余参数，然后构造一个Observer对象，最终还是调

void subscribe(Observer observer)

不同的是，中间会返回一个Disposable对象，下面是Disposable的代码：

/**
*Represents a disposable resource.
*表示一个可以被处置的资源,用于打断，并释放资源。
*/
public interface Disposable {
    void dispose();
    boolean isDisposed();
}

5.Subject

private void doSomeWork() {

   Subject<Integer> source = PublishSubject.create();
   source.subscribeOn(Schedulers.io());
   source.observeOn(AndroidSchedulers.mainThread());
   **source.subscribe(getFirstObserver());**
   **source.subscribe(getSecondObserver());**

   source.onNext(1);
   source.onNext(2);
   source.onNext(3);
   source.onNext(4);
   source.onComplete();

}

用法大致就是这样子的，实现也不复杂。PublishSubject 的部分代码如下：

public final class PublishSubject<T> extends Subject<T> {

  public static <T> io.reactivex.subjects.PublishSubject<T> create() {
      return new PublishSubject<T>();
  }

  @Override
  public void subscribeActual(Observer<? super T> t) {
      PublishSubject.PublishDisposable<T> ps = new iPublishSubject.PublishDisposable<T>(t, this);
      t.onSubscribe(ps);
      if (add(ps)) {
          if (ps.isDisposed()) {
              remove(ps);
          }
      } else {
          ...
      }
  }

  @Override
  public void onSubscribe(Disposable s) {}

  @Override
  public void onNext(T t) {
      if (subscribers.get() == TERMINATED) {
          return;
      }
      if (t == null) {
          onError(new NullPointerException("onNext called with null."));
          return;
      }
      //遍历集合，分发事件
      for (PublishSubject.PublishDisposable<T> s : subscribers.get()) {
          s.onNext(t);
      }
  }

  @Override
  public void onError(Throwable t) {}

  @Override
  public void onComplete() {}
}

当订阅关系发送时(subscribe()被调用)，subscribActure()被调用，把传入的Observer放入到一个subscribers集合里，当接收到onNext等事件时，遍历subscribers分发事件。

就写这么多吧..
第一次写博客，可能有点乱……..
有什么错误的话,欢迎指正.