专注分享 Android开发 干货

CSDN签约作者、稀土掘金专栏作者 & 简书推荐作者

Android RxJava:一步步带你源码分析 RxJava

前言

  • Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点,深受各大 Android开发者的欢迎。

Github截图

如果还不了解RxJava,请看文章:Android:这是一篇 清晰 & 易懂的Rxjava 入门教程

  • 今天,我将为大家带来 源码分析:Rxjava的订阅流程,其为Rxjava使用的基本 & 核心,希望大家会喜欢。
    1. 本系列文章主要基于 Rxjava 2.0
    2. 接下来的时间,我将持续推出 AndroidRxjava 2.0 的一系列文章,包括原理、操作符、应用场景、背压等等 ,有兴趣可以继续关注Carson_Ho的安卓开发笔记!!

示意图

目录

示意图


1. RxJava简介

此处简单介绍RxJava

示意图

若还不了解RxJava,请看文章:Android:这是一篇 清晰 & 易懂的Rxjava 入门教程


2. 订阅流程 的使用

2.1 使用步骤

RxJava的订阅流程 使用方式 = 基于事件流的链式调用,具体步骤如下:

步骤1:创建被观察者(Observable)& 定义需发送的事件
步骤2:创建观察者(Observer) & 定义响应事件的行为
步骤3:通过订阅(subscribe)连接观察者和被观察者

2.2 实例讲解

// RxJava的链式操作
        Observable.create(new ObservableOnSubscribe<Integer>() {
        // 1. 创建被观察者(Observable) & 定义需发送的事件
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
            // 2. 创建观察者(Observer) & 定义响应事件的行为
            // 3. 通过订阅(subscribe)连接观察者和被观察者
            @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事件作出响应");
            }

        });
    }
}
  • 运行结果

示意图


3. 源码分析

下面,我将根据 使用步骤 进行RxJava的源码分析:
步骤1:创建被观察者(Observable)& 定义需发送的事件
步骤2:创建观察者(Observer) & 定义响应事件的行为
步骤3:通过订阅(subscribe)连接观察者和被观察者

步骤1:创建被观察者(Observable)& 定义需发送的事件

  • 源码分析如下
/** 
  * 使用步骤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();
            }
        })

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

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

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


  /** 
    * 分析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);
            }
    }

  /** 
    * 分析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()类似,此处不作过多描述
        // 特别说明:调用该2方法,最终都会自动调用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();
                }
            }
        }
  • 步骤1总结

示意图

步骤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事件作出响应");
            }
        };

步骤3:通过订阅(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);
  • 总结
    示意图

4. 源码总结

  • 在步骤1(创建被观察者(Observable))、步骤2(创建观察者(Observer))时,仅仅只是定义了发送的事件 & 响应事件的行为;
  • 只有在步骤3(订阅时),才开始发送事件 & 响应事件,真正连接了被观察者 & 观察者
  • 具体源码总结如下

示意图


5. 特别注意:涉及多个被观察者(Observable)的发送事件顺序

  • 具体描述

示意图

  • 实例讲解
/** 
  * 存在涉及多个被观察者(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
  • 测试结果
    示意图

6. 总结

  • 本文主要对 RxJava2 中 的订阅流程进行了源码分析

  • 接下来的时间,我将持续推出 AndroidRxjava 2.0 的一系列文章,包括原理、操作符、应用场景、背压等等 ,有兴趣可以继续关注Carson_Ho的安卓开发笔记!!

示意图


请帮顶 / 评论点赞!因为你的鼓励是我写作的最大动力!

阅读更多

扫码向博主提问

去开通我的Chat快问

carson_ho

博客专家

专注分享Android领域
  • 擅长领域:
  • Android
  • 自定义View
  • 开源库源码分析
  • RxJava
  • 性能优化
版权声明:本文为博主原创文章,未经博主允许不得转载,更多请继续关注Carson_Ho https://blog.csdn.net/carson_ho/article/details/79168523
个人分类: RxJava 详细教程
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭