RxJava

一、RxJava总结

（一）RxJava简单介绍

RxJava基于观察者模式,创建被观察者并生产事件(数据)；创建观察者Observer，并定义响应事件(数据)的行为；通过Subscribe订阅方法连接观察者和被观察者。当产生数据后，观察者或获得数据的响应。

（二）RxJava核心思想

1、观察者模式

RxJava基于观察者模式，将观察者和被观察者解耦。

2、模板方法模式

一、Observable的subscribe方法

• 1）Observable是抽象父类，基于模板方法模式。在Observable的subscribe方法中，定义了实现框架，然后将某些步骤的实现细节在子类实现。
• 2）Observable.create创建的类是ObservableCreate，是Observable的实现类；
• 3）调用subscribeOn创建的类ObservableSubscribeOn，是Observable的实现类；
• 4）调用observeOn 创建的类ObservableObserveOn，是Observable的实现类；
• 他们都实现了subscribeActual方法。

  二、subscribeActual方法

一、在ObservableCreate的subscribeActual方法中

• 1）创建发射器CreateEmitter，将observer观察者传入到发射器中。
• 2）调用source.subscribe(CreateEmitter)来生产事件，并将发射器传入到事件(数据)生产者中。
• 3）在source.subscribe(CreateEmitter)方法中，又会调用CreateEmitter的onNext、onError、onComplete等方法。
• 4）因为发射器持有观察者，所以在发射器的onNext方法中，调用观察者observer的onNext方法。完成了事件由生产者到观察者的传递。

二、在ObservableSubscribeOn的subscribeActual方法中，

• 1）将observer观察者存到SubscribeOnObserver订阅观察者中。
• 2）创建SubscribeTask，它实现了Runnable接口。在run方法中会调用source.subscribe(parent)方法。
• 3）在subscribeOn(Schedulers.io())方法中，Schedulers.io()会创建IoScheduler调度器。
• 4）在IoScheduler调度器中存在线程池，调用线程池执行SubscribeTask。然后执行SubscribeTask的run方法，执行source.subscribe方法。最后执行到生产者的subscribe方法，来生产事件。
• 5）至此完成了将生产数据切换到子线程执行的操作。

三、在ObservableObserveOn的subscribeActual方法中，

• 1）将observer观察者存到ObserveOnObserver观察者中。
• 2）在observeOn(AndroidSchedulers.mainThread())中，AndroidSchedulers.mainThread()会创建HandlerScheduler，里面持有主线程的Handler。
• 3）然后调用source.subscribe方法来生产事件。然后会回调到ObserveOnObserver观察者相对应的方法。
• 比如onNext方法。
• 4）在ObserveOnObserver的onNext方法方法中，会从队列中取出事件，然后通过主线程的handler进行线程切换，将事件切换到主线程执行。然后调用observer的onNext方法。
• 5）至此完成了切换到主线程的操作。

  二、RxJava源码解析

总结：

1、首先我们自定义创建事件(数据)生产者source；

2、创建被观察者Observable；

3、创建观察者observer，并实现响应事件的方法；

4、通过subscribeOn(Schedulers.io()) 将生产者线程切换到子线程；

5、通过observeOn(AndroidSchedulers.mainThread())，里面持有主线程的Handler，然后将事件切换到主线程处理；

6、调用subscribe方法，将被观察者Observable和观察者Observer产生订阅关系。

7、在Observable的subscribe方法中，会回调到source的subscribe方法中，并将emitter发射器传入，发送数据。然后又回调到observer的onNext方法中。

一、RxJava基本使用流程

1、RxJava基本流程总结

1）调用new ObservableOnSubscribe()创建ObservableOnSubscribe对象作为事件(数据)生产者；

2）将ObservableOnSubscribe作为参数并调用 Observable的create() 方法创建被观察者Observable；

3）调用new Observer创建观察者；

4）调用 subscribe() 方法，将被观察者和观察者产生订阅关系；

5）调用 dispose() 方法取消订阅关系；

2、创建事件(数据)生产者

//1、创建数据生产者
ObservableOnSubscribe observableOnSubscribe = new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(@io.reactivex.annotations.NonNull ObservableEmitter<String> emitter) throws Exception {
        emitter.onNext("hello");
        emitter.onError(new Throwable("主动错误"));
        emitter.onComplete();
    }
};

解析：

• 创建事件(数据)生产者ObservableOnSubscribe，在subscribe方法中调用emitter生产事件(数据)；
• emitter的实现类是CreateEmitter；我们可以调用CreateEmitter的onNext、onError、onComplete方法，来生产数据。

  3、创建被观察者

//2、将observableOnSubscribe事件(数据)生产者作为参数create方法中，创建被观察者
Observable observable = Observable.create(observableOnSubscribe);

解析：

1）首先将事件(数据)生产者observableOnSubscribe赋值给source(数据源)，并封装为ObservableCreate对象。ObservableCreate继承自Observable。

2）Observable.create方法最终返回的就是ObservableCreate对象。

4、创建观察者

//3、创建观察者
Observer<String> observer = new Observer<String>() {
  onSubscribe、onNext、onError、onComplete
};

解析：

创建观察者，并实现观察者的四个方法： onSubscribe、onNext、onError、onComplete；

5、调用subscribe方法，将被观察者和观察者产生订阅关系

//通过订阅subscribe链接观察者和被观察者
observable.subscribe(observer);

解析：

1）调用observable.subscribe(observer)方法，此时会调用subscribeActual(observer)方法。

2）subscribeActual是Observable类的抽象方法，此时observable的实现对象是在步骤3创建的ObservableCreate对象。所以，此时调用ObservableCreate的subscribeActual(observer)方法

3）我们看一下ObservableCreate的subscribeActual(observer)的代码

@Override
protected void subscribeActual(Observer<? super T> observer) {
     //1、创建CreateEmitter对象
    CreateEmitter<T> parent = new CreateEmitter<T>(observer);
     //2、通过观察者成功订阅了被观察者
    observer.onSubscribe(parent);
     //3、调用数据生产者的subscribe方法。
    source.subscribe(parent);
}

4）通过代码可知，subscribeActual可以分为三步。
1、创建CreateEmitter对象，并传入了observer观察者。CreateEmitter继承AtomicReference并实现ObservableEmitter和Disposable接口

2、调用observer.onSubscribe(parent)，并将CreateEmitter对象作为参数传入。作用是告诉观察者成功订阅了被观察者，并返回CreateEmitter(因为CreateEmitter实现Disposable接口，所以我们接收的参数类型是Disposable)。

3、source.subscribe(parent)作用：调用数据生产者的subscribe方法。此时source就是我们步骤二创建的数据生产者ObservableOnSubscribe对象。parent是CreateEmitter对象。此时我们可以参考步骤二。

4、也就是说source.subscribe(parent)方法作用：会将CreateEmitter作为参数传入到ObservableOnSubscribe中，调用它的subscribe方法。在subscribe方法中我们可以调用CreateEmitter的onNext、onError、onComplete方法，来生产数据。

5、此时，我们进入到CreateEmitter类中，来看它的代码。CreateEmitter是ObservableCreate的内部类。CreateEmitter继承AtomicReference并实现ObservableEmitter和Disposable接口。

static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
@Override
public void onNext(T t) {
    if (!isDisposed()) {
        observer.onNext(t);
    }
}
}

6、在CreateEmitter的onNext方法中，我们可以看到先判断是否isDisposed，然后调用observer的onNext(t)方法。此时，数据已经通知到观察者。
7、至此完成了数据的生成传递并通知到观察者。

三、线程切换

1、线程切换总结

在RxJava基本使用流程之上，添加两个方法，实现线程切换。

1）调用 subscribeOn(Schedulers.io()) 将生产事件(数据)的线程置为IO线程即子线程；

2）调用observeOn(AndroidSchedulers.mainThread())，将线程切换为主线程；

observable.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(observer);

2、调用subscribeOn(Schedulers.io())

解析：订阅在子线程，也就是说生产事件(数据)执行在子线程。

• 1）Schedulers.io()返回的是IoScheduler对象；
• 2）subscribeOn(IoScheduler)方法中，返回ObservableSubscribeOn对象。ObservableSubscribeOn是Observable的实现类；
• 3）如果此时调用subscribe方法，会先调用Observable的subscribe方法，在subscribe方法中，会调用subscribeActual方法
• 4）subscribeActual是抽象方法，此时Observable的实现类是2中创建的ObservableSubscribeOn类。此时，我们看ObservableSubscribeOn的subscribeActual方法。

  1）Schedulers.io()

解析：Schedulers.io()返回的是IoScheduler对象；

2）subscribeOn(IoScheduler)

解析：subscribeOn(IoScheduler)方法中，返回ObservableSubscribeOn对象。ObservableSubscribeOn是Observable的实现类；

3）调用subscribe方法

解析：调用subscribe方法，会先调用Observable的subscribe方法，在subscribe方法中，会调用subscribeActual方法

4）执行subscribeActual方法

解析：subscribeActual是抽象方法，此时Observable的实现类是2中创建的ObservableSubscribeOn类。此时，我们看ObservableSubscribeOn的subscribeActual方法。

5）ObservableSubscribeOn类

解析：此代码为ObservableSubscribeOn类的subscribeActual方法

@Override
public void subscribeActual(final Observer<? super T> observer) {
   //将我们自定义的Observer包装成了一个SubscribeOnObserver对象。
    final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);
   //通知观察者订阅了被观察者
    observer.onSubscribe(parent);
   //创建了一个SubscribeTask对象
    parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}

从代码中可以看出：

• 1、将我们的observer封装为一个SubscribeOnObserver，SubscribeOnObserver实现了Observer、Disposable两个接口；
• 2、调用observer.onSubscribe(parent)，作用是通知观察者订阅被观察者成功。并将SubscribeOnObserver作为参数传给观察者observer；
• 3、最后一行代码可以分成三个步骤
• 步骤一、创建SubscribeTask对象，详情见—步骤6SubscribeTask类。
• 步骤二、调用scheduler.scheduleDirect(SubscribeTask)方法，此时scheduler是subscribeOn(Schedulers.io())传入的Schedulers.io()，Schedulers.io()返回IoScheduler对象。IoScheduler继承Scheduler。详情见—步骤7IoScheduler类

  6）SubscribeTask类

解析：

• SubscribeTask是ObservableSubscribeOn的内部类，SubscribeTask 实现了Runnable，在SubscribeTask的run方法中会执行source.subscribe(parent)。
• 这个source其实就是我们在ObservableSubscribeOn构造方法中传进来的ObservableCreate对象。也就是在Observable.create方法返回的ObservableCreate对象。
• source.subscribe(parent)先执行Observable的subscribe方法，然后执行ObservableCreate的subscribeActual方法，在subscribeActual方法的source就是我们创建的事件（数据生产者）。此时逻辑就到了ObservableOnSubscribe的subscribe方法那里。

• 总结：也就是说source.subscribe(parent)执行在子线程。

  final class SubscribeTask implements Runnable {
    private final SubscribeOnObserver<T> parent;
    SubscribeTask(SubscribeOnObserver<T> parent) {
        this.parent = parent;
    }
    @Override
    public void run() {
        source.subscribe(parent);
    }
  }
  

  7）IoScheduler类

• 解析：调用scheduler.scheduleDirect(SubscribeTask)。此时scheduler是subscribeOn(Schedulers.io())传入的Schedulers.io()，Schedulers.io()返回IoScheduler对象。IoScheduler继承Scheduler。所以调用的是IoScheduler的scheduleDirect方法。

  @NonNull
  public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
    //1、创建工作者对象Worker，调用createWorker方法。createWorker是抽象方法，具体实现是IoScheduler的createWorker方法，返回了EventLoopWorker。
    final Worker w = createWorker();
    final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
    DisposeTask task = new DisposeTask(decoratedRun, w);
    //执行worker的schedule方法，也就是执行了EventLoopWorker的schedule方法。
    w.schedule(task, delay, unit);
    return task;
  }
  

  由上面代码看出：

• Scheduler的scheduleDirect方法执行到了EventLoopWorker的schedule方法。
• EventLoopWorker类的schedule()->NewThreadWorker的scheduleActual()->executor线程池.submit((Callable)sr),最终调用了线程池执行runnable，也就是我们的SubscribeTask。
  • 在SubscribeTask实现Runnable，在它的run方法中，执行source.subscribe(parent)。

  3、调用observeOn(AndroidSchedulers.mainThread())

  解析：Observable.observeOn方法返回ObservableObserveOn对象；ObservableObserveOn也是Observable的实现类；

  1）AndroidSchedulers.mainThread()

  AndroidSchedulers.mainThread()：返回的HandlerScheduler,里面持有主线程的Handler

  static final Scheduler DEFAULT
      = new HandlerScheduler(new Handler(Looper.getMainLooper()), false);
  

  2）ObservableObserveOn类

  解析：Observable会调用subscribe方法，然后调用subscribeActual方法。具体是由它的实现类ObservableObserveOn。所以现在我们看ObservableObserveOn的subscribeActual方法

  @Override
  protected void subscribeActual(Observer<? super T> observer) {
       、、、省略代码
       //创建一个工作者对象
       Scheduler.Worker w = scheduler.createWorker();
       //创建ObserveOnObserver对象，并调用
          source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
  }
  

  由上面代码可得：

  • 此时的source就是我们在ObservableSubscribeOn构造方法中传进来的ObservableCreate对象。也就是在Observable.create方法返回的ObservableCreate对象。
  • 所以source.subscribe的方法先调用Observable的subscribe方法
  • 然后调用ObservableCreate的subscribeActual方法。
  • 之后再调用source.subscribe(parent);
  • 此时的source就是我们创建的ObservableOnSubscribe，然后调用它的emitter.onNext(“hello”)方法。
  • 最后回调到我们创建的ObserveOnObserver类的onNext方法。

    3）ObserveOnObserver类

  解析：

  • 在ObserveOnObserver的onNext()和onError()、onComplete()方法中最后都会调用到schedule()方法。
  • 在onNext方法中，先将消息数据存放到队列中；
  • 接下来调用schedule()方法。
  • schedule方法调用worker.schedule(this);

    @Override
    public void onNext(T t) {
      if (sourceMode != QueueDisposable.ASYNC) {
          queue.offer(t);
      }
      schedule();
    }
    void schedule() {
      if (getAndIncrement() == 0) {
          worker.schedule(this);
      }
    }
    

    4）ObserveOnObserver->worker.schedule(this)

  解析：

  worker就是我们之前ObservableObserveOn类中subscribeActual方法创建的HandlerWorker。

  //scheduler就是HandlerScheduler，HandlerScheduler持有主线程的Handler，也就是在主线程创建了worker。
  Scheduler.Worker w = scheduler.createWorker();
  

  • worker.schedule(this)：也就是执行HandlerWorker的schedule方法。this表示当前类ObserveOnObserver，ObserveOnObserver实现了Runnable接口。
  • 接下来看HandlerWorker的schedule方法

    5）HandlerWorker类

  HandlerWorker是HandlerScheduler内部类，由schedule源码，通过handler发送message到主线程，执行ObserveOnObserver(它实现runnable)里的run方法。

  public Disposable schedule(Runnable run, long delay, TimeUnit unit) {
     //1、这里的run就是ObserveOnObserver
      run = RxJavaPlugins.onSchedule(run);
      //2、创建ScheduledRunnable
      ScheduledRunnable scheduled = new ScheduledRunnable(handler, run);
      //3、下面就是Handler的方法
      创建message，然后通过handler发送message。
      Message message = Message.obtain(handler, scheduled);
      handler.sendMessageDelayed(message, unit.toMillis(delay));
  }
  

  6）ObserveOnObserver类

  run方法->drainNormal()方法

  drainNormal代码精简完之后
  void drainNormal() {
       //1、downstream就是我们自己创建的observer对象
      final Observer<? super T> a = downstream;
      //开启循环获取队列里的消息
      for (;;) {
          v = q.poll();
          //然后调用observer的onNex方法。
          a.onNext(v);
      }
  }
  

  至此数据回调到了观察者observer的onNext方法。

  ​