Android实战派-RxJava3.x(一) 入门

 

以实战立足,坚信实践出真知,唯有理论结合实践才能真正理解并掌握所学的知识。

Rxjava:https://github.com/ReactiveX/RxJava

Reativex:https://github.com/ReactiveX

官网:http://reactivex.io/

Table of Contents

一.内容

二.简单集成

1.开发环境

2.添加依赖

3.lambda支持(可选)

三.使用入门

1.观察者模式

2.RxJava使用步骤

1.创建被观察者(数据源)并生产数据

2.创建观察者

3.订阅(关系绑定)

4.示例程序执行结果

5.调用时序图

6.源码解析

四.总结


一.内容

1.提供相关资料,如何集成。

2.学习简单入门使用,类程序语言的"Hello World"。

二.简单集成

1.开发环境

AndroidStudio3.5
classpath 'com.android.tools.build:gradle:3.5.0'
distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-all.zip
compileSdkVersion 28
minSdkVersion 21
buildToolsVersion "28.0.3"

2.添加依赖

使用的rxjava版本为3.0.0-RC2,由于目前rxandroid还没有升级到3.0,所以采用的版本为2.1.0

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])

    implementation 'androidx.appcompat:appcompat:1.0.2'
    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'androidx.test:runner:1.2.0'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
    implementation "io.reactivex.rxjava3:rxjava:3.0.0-RC2"
//    implementation 'io.reactivex.rxjava2:rxjava:2.2.2'
    implementation 'io.reactivex.rxjava2:rxandroid:2.1.0'
}

3.lambda支持(可选)

ladmbda会让代码更加简洁,当然也是可以不使用的。

使用要求:jdk1.8,minSdkVersion 21。

    compileOptions {
        sourceCompatibility = 1.8
        targetCompatibility = 1.8
    }

 

三.使用入门

1.观察者模式

RxJava使用的就是一种观察者模式,所以这里做一下对比。

通用观察者模式:

Android实战派-RxJava3.x(一) 入门_第1张图片

RxJava观察者模式

Android实战派-RxJava3.x(一) 入门_第2张图片

RxJava主要有:Obervable(被观察者),Observer(观察者),subscribe(订阅),事件序列。与通用的观察者模式所不同的是RxJava把多个事件作为一个序列,有开始(onSubscribe),结束(onComplete),错误(onError),多个事件(onNext()),也就是说在开始之后,结束或者出错之前可以发送多个事件给观察者。有点类似Android的事件序列,从手指按下开始MotionEvent.ACTION_DOWN,手指抬起结束MotionEvent.ACTION_UP,中间会有多个MotionEvent.ACTION_MOVE事件传递。不过这里需要注意的是RxJava中onError()和onComplete()只能调用一个。

 

2.RxJava使用步骤

响应式编程

数据源产生数据并发发射给订阅了这个数据的观察者。所以主要分为三步:

第一步:创建被观察者(数据源)并生产数据

第二步:创建观察者

第三步:订阅(关系绑定)

1.创建被观察者(数据源)并生产数据

       //1.创建被观察者
        Observable observableByFrom = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Throwable {
                //创建数据并发送,包括状态和错误信息
                //数据发送
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onNext(4);
                emitter.onNext(5);
                //异常发送
                //emitter.onError(new IllegalArgumentException("Test Exception!"));
                //完成事件发送
                emitter.onComplete();
                //可以理解为监听回调
            }
        });
        //lambda 方式 
        Observable observableByFromWithLambda = Observable.create((emitter -> {
            emitter.onNext(1);
            emitter.onComplete();
        }));

ObservableOnSubscribe是一个函数式接口,只有一个void subscribe(@NonNull ObservableEmitter emitter)方法。其中ObservableEmitter是发射器,数据就是通过其进行发送的。值得注意的是RxJava提供了很多的Obervable和ObservableEmitte,这里暂不展开,后续会更新。

2.创建观察者

    //2.创建观察者/订阅者
        Observer observer = new Observer() {

            /**
             *  订阅时被调用
             * @param d
             */
            @Override
            public void onSubscribe(Disposable d) {
                
                Log.d(TAG, "onSubscribe(Disposable d) called!");
            }

            /**
             * 发送数据时被多次调用
             * @param o
             */
            @Override
            public void onNext(Integer o) {
                Log.d(TAG, "nNext(Integer o) called!" + String.valueOf(o));
            }

            /**
             * 出错时被调用
             * @param e
             */
            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError(Throwable e) called!" + e.toString());

            }

            /**
             * 完成时被调用
             */
            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete called!");

            }
        };

  上面代码中因为我们的数据是整形,所以泛型类的参数是Integer。方法 public void onSubscribe(Disposable d)中的形参Disposable的作用是可以通过其判断Obervable与Observer 之间的订阅关系,d.dispose();(取消/解除订阅) d.isDisposed();(是否一已经解除订阅)。

3.订阅(关系绑定)

        //订阅,此时触发1步中subscribe方法的执行
        observableByFrom.subscribe(observer);

4.示例程序执行结果

Android实战派-RxJava3.x(一) 入门_第3张图片

 

5.调用时序图

Android实战派-RxJava3.x(一) 入门_第4张图片

6.源码解析

首先我们从创建Observable开始,当我们调用Obervable.create(xx)的时候,看看发生了什么,点进源码。

   public static  Observable create(ObservableOnSubscribe source) {
        ObjectHelper.requireNonNull(source, "source is null");
        return RxJavaPlugins.onAssembly(new ObservableCreate(source));
    }

    //ObservableCreate构造函数
    public ObservableCreate(ObservableOnSubscribe source) {
        this.source = source;
    }

可以看到其内部创建了一个使用我们传进去的source参数的ObservableCreate对象,在其构造方法中,把source赋值给了成员变量记录,之后返回 RxJavaPlugins.onAssembly后的Obserable对象。

然后我们再来看下observableFrom.subscribe(observer);的调用过程。

可以看到在1处做了参数的校验,在2处执行实际的订阅,所以再来看下2处的调用。

@Override
    protected void subscribeActual(Observer observer) {
        //1.构建发射器
        CreateEmitter parent = new CreateEmitter(observer);
        //2.调用Observer的onSubscribe方法
        observer.onSubscribe(parent);

        try {
            //3.调用Observable的subscribe方法
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

结合上边的时序图,整个调用流程非常清晰的展示在我们面前。

1.在订阅的方法中,创建了发射器parent,

2. 调用了Observer的onSubscribe方法,并把发射器parent作为形参传递进去,这里要说明一下,CreateEmitter实现了Disposable接口,所以在Observer的onSubscribe方法中接收到的参数为Disposable。
       3.调用source也就是(Observable)的subscribe方法,并把发射器parent传递进去。
       4.执行之前我们在subscribe(ObservableEmitter emitter)写的代码。
       到这里整个订阅的流程就梳理完毕了,接下来我们再来看下subscribe(ObservableEmitter emitter)中发射数据的代码调用。
 

首先调用了多次emitter.onNext(T value);

    @Override
    public void onNext(T t) {
        //1.参数校验
        if (t == null) {
            onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
            return;
        }
        //2.判断是否解绑或者终止,没有的话调用onNext(t);
        if (!isDisposed()) {
            observer.onNext(t);
        }
    }

在这段代码中做了两件事:1.参数校验,不满足的话直接调用onError,并在其内部调用dispose。 2.判断是否解绑或终止,然后调用observer.onNext(t)方法,此时数据就传递给了Observer。

 @Override
    public void onError(Throwable t) {
        if (!tryOnError(t)) {
            RxJavaPlugins.onError(t);
        }
    }

    @Override
    public boolean tryOnError(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();
            }
            return true;
        }
        return false;
    }

接着调用了emitter.onComplete();

    @Override
    public void onComplete() {
        //1.判断是否解绑或者终止,没有的话调用onComplete();
        if (!isDisposed()) {
            try {
                observer.onComplete();
            } finally {
                dispose();
            }
        }
    }

在这段代码中做了一件事:1.判断是否解绑或终止,然后调用observer.onComplete()方法,最后调用dispose。     所以由此可知在调用onError和onComplete之后是无法在继续发送数据的了。至此示例的源码解析完成。

四.总结

本文只是一个 基于RxJava3的入门级文章,后续会从入门->进阶->掌握的流程来更新。

你可能感兴趣的:(RxJava3,RxJava,RxAndroid,RxJava2,Rx)