RxJava源码解读

/** 
  * 使用步骤1：创建被观察者(Observable)& 定义需发送的事件
  **/

  Observable.create(new ObservableOnSubscribe<Integer>() {

            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        })

2、Observable.create()

/** 
  * 源码分析：Observable.create(new ObservableOnSubscribe<Integer>(){...}）
  **/
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {

    ...
    // 仅贴出关键源码

     return new ObservableCreate<T>(source);
    // 创建ObservableCreate类对象 ->>分析1
    // 注：传入source对象（即 我们手动创建的ObservableOnSubscribe对象）  
}

通过new ObservableCreate<T>(source)来创建Observable对象。

  /** 
    * 分析1：new ObservableCreate<T>(source)
    **/

  public final class ObservableCreate<T> extends Observable<T> {
  // ObservableCreate类 = Observable的子类 

      ...
      // 仅贴出关键源码

        final ObservableOnSubscribe<T> source;

      // 构造函数
      // 传入了传入source对象 = 手动创建的ObservableOnSubscribe对象
	public ObservableCreate(ObservableOnSubscribe<T> source) {
	    this.source = source;
	}
	    
    /** 
      * 重点关注：复写了subscribeActual（）
      * 作用：订阅时，通过接口回调 调用被观察者（Observerable） 与 观察者（Observer）的方法
      **/
	@Override
	protected void subscribeActual(Observer<? super T> observer) {

	    // 1. 创建1个CreateEmitter对象（封装成1个Disposable对象）
            // 作用：发射事件
	    CreateEmitter<T> parent = new CreateEmitter<T>(observer);

	    // 2. 调用观察者（Observer）的onSubscribe（）
	    // onSubscribe（）的实现 = 使用步骤2（创建观察者（Observer））时复写的onSubscribe(）
	    observer.onSubscribe(parent);

	    try {
	         // 3. 调用source对象的subscribe（）
	         // source对象 = 使用步骤1（创建被观察者（Observable））中创建的ObservableOnSubscribe对象 
	         // subscribe（）的实现 = 使用步骤1（创建被观察者（Observable））中复写的subscribe（）->>分析2
	         source.subscribe(parent);
	    } catch (Throwable ex) {
	         Exceptions.throwIfFatal(ex);
	         parent.onError(ex);
         }
 }

• 通过构造方法将source赋值给本地成员变量，ObservableCreate类继承Observable类，并重写subscribeActual()方法
  
• 创建new CreateEmitter()对象parent，该CreateEmitter类后续进行分析
• observer.onSubscribe(parent)是使用步骤2时重写的OnSubscribe()方法
• 最后try...catch中的source.subscrbe(parent)是使用步骤1是重写的subscribe()方法
• source对象是使用步骤1中创建的ObservableOnSubscribe对象。

3、new CreateEmitter()

CreateEmitter类中主要是分析

  /** 
    * 分析2：emitter.onNext("1");
    * 此处仅讲解subscribe（）实现中的onNext（）
    * onError（）、onComplete()类似，此处不作过多描述
    **/
    static final class CreateEmitter<T> extends AtomicReference<Disposable>
                                        implements ObservableEmitter<T>, Disposable {

        ...
        // 仅贴出关键代码

        // onNext（）源码分析
        @Override
        public void onNext(T t) {
            // 注：发送的事件不可为空
            if (t == null) {
                onError(new NullPointerException
("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
                return;
            }

            // 若无断开连接（调用Disposable.dispose()），
            // 则调用观察者（Observer）的同名方法 = onNext（）
            // 观察者的onNext（）的内容 = 使用步骤2中复写内容
            if (!isDisposed()) {
                observer.onNext(t);
            }
        }

        // onError（）、onComplete()类似，此处不作过多描述
        // 特别说明：调用该两方法，最终都会自动调用dispose()，即断开观察者 & 被观察者的连接
        @Override
        public void onError(Throwable t) {
            if (t == null) {
                t = new NullPointerException
("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
            }
            if (!isDisposed()) {
                try {
                    observer.onError(t);
                } finally {
                    dispose();
                }
            } else {
                RxJavaPlugins.onError(t);
            }
        }

        @Override
        public void onComplete() {
            if (!isDisposed()) {
                try {
                    observer.onComplete();
                } finally {
                    dispose();
                }
            }
        }

在CreateEmitter类中，若没有dispose()，则执行observer.onNext()，即观察者的同名方法，onNext()中的内容是使用步骤2中重写内容。

4、步骤1总结

• 创建被观察者（Observable）的本质：创建ObservableCreate类对象。传入手动创建的ObservableOnSubscribe对象，并在ObservableOnSubscribe对象内重写了发送事件的行为：subscribe();
• ObservableCreate类对象内部中有1个subscrbeActual()，该subsccribeActual()中的逻辑如下：
• 创建一个CreateEmitter对象（封装成1个Disposable对象）
• 调用观察者（observer）重写的onSubscribe()
• 调用被观察者ObservableOnSubscribe对象重写的subscribe()
• 额外：被观察者的subscribe()中调用的onNext()、onError()、onComplete()内部分别再调用观察者（Observer）重写的对应方法
• 特别注意：该方法还未被执行，仅仅是被定义

5、步骤2：创建观察者 & 定义响应事件的行为

/** 
  * 使用步骤2：创建观察者 & 定义响应事件的行为（方法内的创建对象代码）
  **/
  subscribe(new Observer<Integer>() {
      
              @Override
              public void onSubscribe(Disposable d) {
                  Log.d(TAG, "开始采用subscribe连接");
              }
              // 默认最先调用复写的 onSubscribe（）

              @Override
              public void onNext(Integer value) {
                  Log.d(TAG, "对Next事件"+ value +"作出响应"  );
              }

              @Override
              public void onError(Throwable e) {
                  Log.d(TAG, "对Error事件作出响应");
              }

              @Override
              public void onComplete() {
                  Log.d(TAG, "对Complete事件作出响应");
              }

  });

底层源码如下：

/** 
  * 源码分析：Observer类
  **/
  public interface Observer<T> {
      // 注：Observer本质 = 1个接口

      // 接口内含4个方法，分别用于 响应 对应于被观察者发送的不同事件
        void onSubscribe(@NonNull Disposable d); // 内部参数：Disposable 对象，可结束事件
        void onNext(@NonNull T t);
        void onError(@NonNull Throwable e);
        void onComplete();
    }

/** 
  * 特别说明：Subscriber类
  * 定义：RxJava 内置的一个实现了 Observer 的抽象类
  * 作用：扩展Observer 接口 = 新增了2个方法 = 
  *      1. onStart()：在还未响应事件前调用，用于初始化工作
  *      2. unsubscribe()：用于取消订阅。在该方法被调用后，观察者将不再接收 & 响应事件
  *      注：调用该方法前，先使用 isUnsubscribed() 判断状态，
  *          确定被观察者Observable是否还持有观察者Subscriber的引用；若引用不能及时释放，就会出现内存泄露
  * 使用方式：与Observer使用几乎相同（实质上，Observer总是会先被转换成Subscriber再使用）
  **/
  Subscriber<String> subscriber = new Subscriber<Integer>() {

            @Override
            public void onSubscribe(Subscription s) {
                Log.d(TAG, "开始采用subscribe连接");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "对Next事件作出响应" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        };

注意：Observer是接口，内部需要重写四个方法：onSubscribe()、onNext()、onError()、onComplete()

6、通过订阅（subscribe）连接观察者和被观察者

/** 
  * 使用步骤3：通过订阅（subscribe）连接观察者和被观察者 = subscribe（）
  **/
  subscribe(new Observer<Integer>() {
              // 2. 通过通过订阅（subscribe）连接观察者和被观察者
              // 3. 创建观察者 & 定义响应事件的行为
              @Override
              public void onSubscribe(Disposable d) {
                  Log.d(TAG, "开始采用subscribe连接");
              }
              // 默认最先调用复写的 onSubscribe（）

              @Override
              public void onNext(Integer value) {
                  Log.d(TAG, "对Next事件"+ value +"作出响应"  );
              }

              @Override
              public void onError(Throwable e) {
                  Log.d(TAG, "对Error事件作出响应");
              }

              @Override
              public void onComplete() {
                  Log.d(TAG, "对Complete事件作出响应");
              }

          });

源码分析：

/** 
  * 源码分析：Observable.subscribe（observer）
  * 说明：该方法属于 Observable 类的方法（注：传入1个 Observer 对象）
  **/  

  @Override
  public final void subscribe(Observer<? super T> observer) {

    ...
    // 仅贴出关键源码
   
    subscribeActual(observer);
    // 继续往下看：分析1

  }

/** 
  * Observable.subscribeActual(observer)
  * 说明：属于抽象方法，由子类实现；此处的子类 = 步骤1创建被观察者（Observable）时创建的ObservableCreate类
  * 即 在订阅时，实际上是调用了步骤1创建被观察者（Observable）时创建的ObservableCreate类里的subscribeActual（）
  * 此时，你应该回头看上面的步骤1里的subscribeActual()，应该能理解RxJava的整个订阅流程了。
  **/
  protected abstract void subscribeActual(Observer<? super T> observer);

注意：subscribeActual(observer)方法，因为在ObservableCreate类中重写了subscribeActual()，因而在订阅时，实际上调用了步骤1创建被观察者（Observable）时创建的ObservableCreate类里的subscribeActual()。

7、步骤3总结

• 订阅（subscribe）的本质：调用ObservableCreate类对象的subscribeActual()方法（ObservableCreate类是Observable子类）
• subscribeActual()的内部逻辑如下：
• 创建1个CreateEmitter对象（封装成1个Disposable对象）
• 调用观察者（Observer）重写的onSubscribe()
• 调用被观察者ObservableOnSubscribe对象重写的subscribe()
• 被观察者内的subscribe()里调用的onNext()、onError()、onComplete()内部分别再调用观察者（Observer）重写的对应方法
• 特别注意：此方法此时是被调用、执行。

四、源码总结

• 在步骤1（创建被观察者（Observable））、步骤2（创建观察者（Observer））时，仅仅只是定义了发送的事件 & 响应事件的行为；
• 只有步骤3（subscribe），才开始发送事件 & 响应事件，真正连接了被观察者 & 观察者

五、特别注意：涉及多个被观察者（Observable）的发送事件顺序

1、具体描述

• 背景

上述仅涉及单个被观察者（Observable）

实际开发中，在使用RxJava的操作符时基本都在内部创建1个被观察者（Observable）

每个操作符中的Observable.subscribeActual(Observer)中的默认实现都不相同

但基本原理相同：都是封装传入的观察者（Observer）对象，调用被观察者（Observable）重写的subscribe()方法

2、实例讲解

/** 
  * 存在涉及多个被观察者（Observable）的情况
  **/
  
    // 创建第1个被观察者（Observable1）
    Observable.create(new ObservableOnSubscribe<Integer>() {
                @Override
                public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                    emitter.onNext(1);
                    emitter.onNext(2);
                    emitter.onNext(3);
                }
            })
            // 使用flatMap操作符（内部会创建第2个被观察者（Observable2））
            .flatMap(new Function<Integer, ObservableSource<String>>() {
                @Override
                public ObservableSource<String> apply(Integer integer) throws Exception {
                    final List<String> list = new ArrayList<>();
                    for (int i = 0; i < 3; i++) {
                        list.add("我是事件" + integer + "拆分后的子事件" + i);
                        // 通过flatMap中将被观察者生产的事件序列先进行拆分，
                        // 再将每个事件转换为一个新的发送三个String事件
                        // 最终合并，再发送给被观察者
                    }
                    return Observable.fromIterable(list);
                }

            })
            .subscribe(new Observer<String>() {
                @Override
                public void onSubscribe(Disposable d) {
                    Log.d(TAG, "开始采用subscribe连接");
                }
                // 默认最先调用复写的 onSubscribe（）

                @Override
                public void onNext(String value) {
                    Log.d(TAG, "响应事件："+ value   );
                }

                @Override
                public void onError(Throwable e) {
                    Log.d(TAG, "对Error事件作出响应");
                }

                @Override
                public void onComplete() {
                    Log.d(TAG, "对Complete事件作出响应");
                }
            });
            // 过程讲解
            // 调用顺序：先回调Observable2的subscribe(Observer) 、subscribeActual(Observer)、
            // 再回调Observable1的subscribe(Observer) 、subscribeActual(Observer)
            // Observable的发送顺序 = 先发送Observable1、再发送Observable2

输出结果：

开始采用subscribe连接
响应事件：我是事件1拆分后的子事件0
响应事件：我是事件1拆分后的子事件1
响应事件：我是事件1拆分后的子事件2
响应事件：我是事件2拆分后的子事件0
响应事件：我是事件2拆分后的子事件1
响应事件：我是事件2拆分后的子事件2
响应事件：我是事件3拆分后的子事件0
响应事件：我是事件3拆分后的子事件1
响应事件：我是事件3拆分后的子事件2

具体是通过flatMap()方法来完成相应的操作

过程讲解：

调用顺序： 先回调Observable2的subscribe(Observer) 、subscribeActual(Observer)、再回调Observable1的subscribe(Observer) 、subscribeActual(Observer) 

Observable的发送顺序：先发送Observable1、再发送Observable2

本文内容基本来源于：Android RxJava：一步步带你源码分析 RxJava