RxJava源码分析及版本对比(一)

内容简介：1.x版本基本使用分析——先对RxJava简单介绍，之后对RxJava1的基本使用和原理进行分析。

RxJava简介

RxJava is a Java VM implementation of Reactive Extensions: a library for composing asynchronous and event-based programs by using observable sequences.

It extends the observer pattern to support sequences of data/events and adds operators that allow you to compose sequences together declaratively while abstracting away concerns about things like low-level threading, synchronization, thread-safety and concurrent data structures.

简单来说就是：RxJava 是使用 Java VM 实现的响应式编程库：一个通过使用可观察序列来编写异步和基于事件的程序的库。

它扩展了观察者模式以支持数据/事件序列，并添加了允许您以声明方式组合序列的运算符，同时抽象出对低级线程、线程同步、线程安全和并发数据结构等问题的关注。

发展历史

RxJava 存在 1.x 版本和 2.x 版本， API 改动较大，接入方法基本不兼容，但实现思路类似，做了一定的优化，下面是官方对 RxJava2 的介绍。

Version 2.x (Javadoc)

• single dependency: Reactive-Streams

• continued support for Java 6+ & Android 2.3+

• performance gains through design changes learned through the 1.x cycle and through Reactive-Streams-Commons research project.

• Java 8 lambda-friendly API

• non-opinionated about source of concurrency (threads, pools, event loops, fibers, actors, etc)

• async or synchronous execution

• virtual time and schedulers for parameterized concurrency

• 单一依赖：Reactive-Streams

• 继续支持 Java 6+ 和 android 2.3+

• 通过1.x和 Reactive-Streams-Commons 项目的积累，实现设计变更，提高性能。

• 友好地支持 Java 8 lambda 表达式

• 灵活的处理并发，包括 threads, pools, event loops, fibers, actors 等

• 同步或异步操作

• 为参数化的并发设计了调度器

项目地址

既然都打算看看原理了，难道还不下载源码看看吗？？

项目地址：https://github.com/ReactiveX/RxJava

这里1.x版本和2.x版本在不同的分支上。

1.x基本使用

    public static void main(String[] args) {	
        Observable.create(new Observable.OnSubscribe() {	
            @Override	
            public void call(Subscriber subscriber) {	
                if (!subscriber.isUnsubscribed()) {	
                    subscriber.onNext("test");	
                    subscriber.onCompleted();	
                }	
            }	
        }).subscribe(new Observer() {	
            @Override	
            public void onCompleted() {	
                System.out.println("onCompleted");	
            }	
            @Override	
            public void onError(Throwable e) {	
            }	
            @Override	
            public void onNext(String s) {	
                System.out.println("onNext:" + s);	
            }	
        });	
    }

拆分一下，分为两部分

1. 构建一个 Observable 对象

2. 调用 Observable 对象的 subscribe 方法

    // 通过Observable的create静态方法，传入一个OnSubscribe对象	
    // 这个OnSubscribe对象附带了一个call方法，用于回调	
    // 整个create方法返回了一个Observable对象的实例	
    Observable observable = Observable.create(new Observable.OnSubscribe() {	
        @Override	
        public void call(Subscriber subscriber) {	
            if (!subscriber.isUnsubscribed()) {	
                subscriber.onNext("test");	
                subscriber.onCompleted();	
            }	
        }	
    });

    // 调用observable的subscribe方法，传入一个Observer对象，	
    // 这个Observer对象附带了三个回调方法	
    // 通过这里subscribe方法调用上面Observable.OnSubscribe对象中的call方法	
    // 再在call方法中的subscriber对象调用这里Observer中的onNext，onCompleted方法	
    observable.subscribe(new Observer() {	
        @Override	
        public void onCompleted() {	
            System.out.println("onCompleted");	
        }	
        @Override	
        public void onError(Throwable e) {	
        }	
        @Override	
        public void onNext(String s) {	
            System.out.println("onNext:" + s);	
        }	
    });

上面的程序打印出的效果是：

1.x源码分析

从 Observable.create 方法开始

    @Deprecated	
    public static  Observable create(OnSubscribe f) {	
        // 接收一个OnSubscribe参数，调用构造函数返回一个Observable	
        // 1）、先看Observable的构造函数做了什么	
        // 2）、再看OnSubscribe类是怎样的	
        return new Observable(RxJavaHooks.onCreate(f));	
    }

Observable 的构造函数

    // Obserbable类中存在一个final变量是OnSubscribe类型的	
    final OnSubscribe onSubscribe;	
    // 构造方法将传入的OnSubscribe对象赋值给局部变量onSubscribe保存起来	
    protected Observable(OnSubscribe f) {	
        this.onSubscribe = f;	
    }

再来看 OnSubscribe 类，其实就是一个包含有一个 call 方法的类，在基本使用的第 2 步，调用 observable 对象 subscribe 方法时触发。

    /**	
     * 这里的OnSubscribe是一个接口，继承子Action1接口	
     * 	
     * 在Observable.subscribe方法被调用的时候执行	
     * 这里的subscribe是第2部分，如果印象模糊可以回头看一下上面的基本使用部分	
     * @param  the output value type	
     */	
    public interface OnSubscribe extends Action1> {	
        // cover for generics insanity	
    }	
    /**	
      * 一个call方法，observable对象subscribe方法时触发	
      * 用上面的基本使用的例子，这里的call携带的范型T就是Subscriber的实例subscriber	
      * 上面call方法就是调用subscribe中的onNext方法和onCompleted	
      * 可以看出这里的onNext和onCompleted就是基本使用例子第二步的subscribe方法传入Observer对象的方法	
      * 	
      * 继续跟Action和 Action继承的Function都没有实现	
     * @param  the first argument type	
     */	
    public interface Action1 extends Action {	
        void call(T t);	
    }

可以看出例子第1 步实例 Observable.OnSubscribe 对象的时候实现了一个 call 方法，  call 方法传入的参数就是Subscriber 实例，方法内调用的 onNext 方法和 onCompleted 方法执行了第 2 步中 Observer 实例的对应方法，所以这里可以猜测 Observer 是一个接口， Subscriber 实现了 Observer 。我们来看一下这两个类。

    /**	
     * 很熟悉的三连，自己实现，完成业务	
     */	
    public interface Observer {	
        void onCompleted();	
        void onError(Throwable e);	
        void onNext(T t);	
    }	
    /**	
     * 和我们的猜测一致，Subscriber实现了Observer	
     */	
    public abstract class Subscriber implements Observer, Subscription {	
        ...	
    }

到这里应该对整体有一个理解了，我们再来看一下 observable.subscribe 方法，结束后在进行总结。

    public final Subscription subscribe(final Observer observer) {	
        if (observer instanceof Subscriber) {	
            return subscribe((Subscriber)observer);	
        }	
        if (observer == null) {	
            throw new NullPointerException("observer is null");	
        }	
        // 这里我门传入的是new Observer，直接进入下面部分	
        return subscribe(new ObserverSubscriber(observer));	
    }	
    ...	
    public final Subscription subscribe(Subscriber subscriber) {	
        return Observable.subscribe(subscriber, this);	
    }	
    static  Subscription subscribe(Subscriber subscriber, Observable observable) {	
        ...	
        // 方法比较长，这里只分析重要部分	
        // 这里的RxJavaHooks.onObservableStart方法返回了observable.onSubscribe	
        // 再调用observable类中的局部变量onSubscribe的call方法，具体的实现就是我们再例子中实现的call方法，调用了subscriber.onNext和subscriber.onCompleted	
        RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);	
        return RxJavaHooks.onObservableReturn(subscriber);	
    }	
    // RxJavaHooks.onObservableStart分析	
    public static  Observable.OnSubscribe onObservableStart(Observable instance, Observable.OnSubscribe onSubscribe) {	
        Func2 f = onObservableStart;	
        if (f != null) {	
            // 会进入该方法，最后返回的就是Observable构造函数中存储的局部变量onSubscribe，不要将这个call和我门自己实现的call方法弄混了	
            return f.call(instance, onSubscribe);	
        }	
        return onSubscribe;	
    }

其实分析到这里就结束了，将整个调用链连接了起来我们再来看一下关于 RxJavaHooks.onObservableStart 分析，分析这里的返回值就是 Observable 构造函数中存储的局部变量 onSubscribe 。

对 RxJavaHooks.onObservableStart 方法进行断点调试，进入 f!=null  判断。

    // Func2是一个接口，我们继续使用断点调试查看具体的实现	
    public interface Func2 extends Function {	
        R call(T1 t1, T2 t2);	
    }

    // 通过断点调试找到call方法的实现	
    onObservableStart = new Func2() {	
        @Override	
        public Observable.OnSubscribe call(Observable t1, Observable.OnSubscribe t2) {	
            return RxJavaPlugins.getInstance().getObservableExecutionHook().onSubscribeStart(t1, t2);	
            }	
        };

    // 返回了第二个参数	
    @Deprecated	
    public  OnSubscribe onSubscribeStart(Observable observableInstance, final OnSubscribe onSubscribe) {	
        // pass through by default	
        return onSubscribe;	
    }

最后返回了第二个参数，就是 observable.onSubscribe 。

1.x总结

第一步：在调用 create 方法构造了一个 Observable 对象，并且在 Observable 对象的构造方法中，将局部变量 onSubscribe 赋值，该 onSubscribe 实现了 call 方法等待被回调， call 方法中提供了一个 subscriber 实例，该实例实现了 Observer ，有 onCompleted ， onError ， onNext 方法可以进行调用。

第二步：执行 Observable 实例的 subscribe 方法，传入了 Observer 对象，实现了  onCompleted , onError , onNext 方法。再通过

RxJavaHooks.onObservableStart(observable,observable.onSubscribe).call(subscriber);

方法回调到了第一步中 OnSubscribe 的 call 方法，这里的 subscriber 方法就是第二步中实例的 Observer 。

整体就是在第一步中写了一个回调，等待第二步 subscribe 方法调起。第二步中的 Observer 实现了一个回调的三个方法，供第一步中的回调函数内调用。

--END--

识别二维码，关注我们