RxJava源码分析及版本对比(二)——2.x版本基本使用分析与对比1.x版本

在基本使用上(无背压) 2.x版本和1.x版本极为相似，针对扩展性做了优化

同样的方法再盘他一遍！

2.x基本使用

    Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> e) throws Exception {
            if (!e.isDisposed()) {
                e.onNext("1");
                e.onComplete();
            }
        }
    }).subscribe(new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {
            System.out.println("onSubscribe");
            d.dispose();
        }
        @Override
        public void onNext(String value) {
            System.out.println("onNext:" + value);
        }
        @Override
        public void onError(Throwable e) {
        }
        @Override
        public void onComplete() {
            System.out.println("onCompleted");
        }
    });
复制代码

同样的拆分一下，分为两部分

构建一个Observable对象
调用Observable对象的subscribe方法

	// 通过Observable的create静态方法，传入一个ObservableOnSubscribe对象
	// 这个OnSubscribe对象附带了一个call方法，用于回调
	// 整个create方法返回了一个Observable对象的实例
	
	// 这里对于1.x版本的区别是
	// Observable.OnSubscribe->ObservableOnSubscribe
	// Observer-> ObservableEmitter
	// subscriber.isUnsubscribed->e.isDisposed
    Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> e) throws Exception {
            if (!e.isDisposed()) {
                e.onNext("1");
                e.onComplete();
            }
        }
    });
    
    // 调用observable的subscribe方法，传入一个Observer对象
    // 这个Observer对象实现了onSubscribe方法，onNext方法，onError方法，onComplete方法。
    
    // 这里对比1.x版本的区别是
    // Observer接口增加了void onSubscribe(@NonNull Disposable d);方法需要实现
    // 主动设置状态d.dispose();增加了灵活性
    observable.subscribe(new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {
            System.out.println("onSubscribe");
            d.dispose();
        }
        @Override
        public void onNext(String value) {
            System.out.println("onNext:" + value);
        }
        @Override
        public void onError(Throwable e) {
        }
        @Override
        public void onComplete() {
            System.out.println("onCompleted");
        }
    });
复制代码

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

将d.dispose()注释掉

上面的程序打印出的效果是：
onSubscribe
onNext:1
onCompleted

2.x源码解析

1.同样的，从从Observable.create方法开始

    // 在1.x版本中，Observable.create方法是弃用的
    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
        ObjectHelper.requireNonNull(source, "source is null");
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }
复制代码

ObservableCreate的构造方法


	final ObservableOnSubscribe<T> source;
	// 对局部变量赋值，保存，等待回调调用
	public ObservableCreate(ObservableOnSubscribe<T> source) {
		this.source = source;
	}
复制代码

与1.x版本的实现方式大致相同，细节部分有些改变

这里通过RxJavaPlugins.onAssembly方法，返回了一个ObservableCreate对象，该对象继承与Observable,构造方法中传入了一个ObservableOnSubscribe实例，赋值给局部变量，等待被回调。该实例就是我们在基本使用的例子中创建的对象，并且实现了subscribe(ObservableEmitter<String> e)方法。

回顾1.x版本，思路也是保存一个我们自己实现的实例到局部变量，等待被回调。可以说两者在基本使用这种情况下没有本质区别。

2.再来看看我们的subscribe(ObservableEmitter<String> e)方法是如何被回调的

从第二部分的observable.subscribe()方法入手分析

    @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(Observer<? super T> observer) {
    	// 省略一些判断及异常捕捉。
       ...
       subscribeActual(observer);
       ...
    }
复制代码

这里的 subscribeActual是一个抽象方法，根据1中分析可以得知，调用者observable是一个ObservableCreate对象，我们进入该类查找subscribeActual(observer)方法。

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        // 构造了一个CreateEmitter对象，这个对象实现了Emitter、Disposable接口
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        // 调用传入observer的onSubscribe方法，这里的observer就是我们在基本使用第2步中构造出的observer实例，回调我们自己实现的onSubscribe,传入parent可以进行对d.dispose()方法进行控制，标记是否已经进行了处理。
        observer.onSubscribe(parent);

        try {
            // 调用第1步中保存的source，是一个我们自己实现ObservableOnSubscribe对象，在这里被回调。
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }
复制代码

再来看一下为什么通过基本使用例子里面的e.onNext("1");e.onComplete();就调用到了我们在限免实现Observer里面的的方法

    @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;
        }
        // 调用了observer.onNext
        if (!isDisposed()) {
            observer.onNext(t);
        }
    }
    
    @Override
    public void onComplete() {
        if (!isDisposed()) {
            try {
                // 调用了observer.onComplete();

                observer.onComplete();
            } finally {
                dispose();
            }
        }
    }
复制代码

这样下来，就通过subscribeActual(observer)就实现了第1步和第2步的关联

1)在内部先调用observer.onSubscribe(parent)
进入我们自己的逻辑执行了System.out.println("onSubscribe")
2)再调用了source.subscribe(parent)
进入我们自己的逻辑执行了

	if (!e.isDisposed()) {
		e.onNext("1");
		e.onComplete();
	}
复制代码

接着执行了

 	@Override
	public void onNext(String value) {
		System.out.println("onNext:" + value);
	}
	
	@Override
	public void onComplete() {
		System.out.println("onCompleted");
	}
复制代码

将我们的代码连接了起来。

总结

其实在2.x版本的基本使用中，有这么几个对象：

Observable 可观察的，也可以说是一个被观察对象，在构造的时候传入一个ObservableOnSubscribe对象实现subscribe(ObservableEmitter<String> e)方法等待被回调
Observer 观察者，被观察的对象。在Observable调用subscribe(new Observer)方法的时候传入一个观察者，通过该方法，先调用了自己的onSubscribe方法，可以进行Disposable的标记，再回调了等待被回调的被观察者Observable的subscribe方法
Disposable 可处理的，对当前的流程进行标记，是否放弃操作
ObservableOnSubscribe 在构造被观察对象时传入的实例，实现subscribe方法等待被回调
Emiter 这里用到的是CreateEmitter，实现了ObservableOnSubscribe对象与Observer关联，相当于是一个桥的调用。