为了账号安全,请及时绑定邮箱和手机立即绑定

RxJava2.0教程一:入门

标签:
Android

什么是Rxjava2.0

根据RxJava在GitHub上给出的描述:
RxJava – Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java
大致意思是:一个可以在JVM上使用的,是由异步的基于事件编写的通过使用可观察序列构成的一个库。
关键词:异步基于事件可观察序列

RxJava1.0和RxJava2.0的核心思想都是观察者模式,只不过RxJava2.0在RxJava1.0的基础对一些方法进行了优化,方便于开发者更好地理解其编程思想,同时又增加了一部分新的方法解决1.0存在的问题,例如背压等。所以,如果你学习过RxJava1.0那么很好,你可能已经理解了什么是观察者模式;如果你没有学过RxJava1.0,当然也不必着急,因为本文将从最基本的观察者模式讲起,让你从最基本最简单的角度入手RxJava。综上所述,不管你是不是学过RxJava1.0,都不会影响你学习本篇文章。

观察者模式

  • 什么是观察者模式?
    观察者模式(Observer)完美的将观察者和被观察的对象分离开。举个例子,用户界面可以作为一个观察者,业务数据是被观察者,用户界面观察业务数据的变化,发现数据变化后,就显示在界面上。面向对象设计的一个原则是:系统中的每个类将重点放在某一个功能上,而不是其他方面。一个对象只做一件事情,并且将他做好。观察者模式在模块之间划定了清晰的界限,提高了应用程序的可维护性和重用性。
    观察者设计模式定义了对象间的一种一对多的组合关系,以便一个对象的状态发生变化时,所有依赖于它的对象都得到通知并自动刷新。
  • 例子说明:
    举例如下,A和B两个,A是被观察者,B是观察者,B对A进行观察,B并不是需要时刻盯着A,而是A如果发生了变化,会主动通知B,B会对应做一些变化。举个例子,假设A是连载小说,B是读者,读者订阅了连载小说,当小说出现了新的连载的时候,会推送给读者。读者不用时刻盯着小说连载,而小说有了新的连载会主动推送给读者。这就是观察者模式。而RxJava正是基于观察者模式开发的。
    观察者模式

RxJava2.0的基本使用

首先引入RxJava2.0相关的类库。

    implementation 'io.reactivex.rxjava2:rxjava:2.2.5'
    implementation 'io.reactivex.rxjava2:rxandroid:2.1.0'
  1. 创建连载小说(被观察者)
        //创建被观察者
        Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("连载1");
                emitter.onNext("连载2");
                emitter.onNext("连载3");
                emitter.onComplete();
            }
        });

Observable中文意思就是被观察者,通过create方法生成对象,里面放的参数ObservableOnSubscribe,可以理解为一个计划表,泛型T是要操作对象的类型,重写subscribe方法,里面写具体的计划,本文的例子就是推送连载1、连载2和连载3,在subscribe中的ObservableEmitter对象的Emitter是发射器的意思。ObservableEmitter有三种发射的方法,分别是void onNext(T value)、void onError(Throwable error)、void onComplete(),onNext方法可以无限调用,Observer(观察者)所有的都能接收到,onError和onComplete是互斥的,Observer(观察者)只能接收到一个,OnComplete可以重复调用,但是Observer(观察者)只会接收一次,而onError不可以重复调用,第二次调用就会报异常。

2. 创建读者(观察者)

        //创建观察者
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                mDisposable = d;
                Log.d(TAG, "onSubscribe: ");
            }

            @Override
            public void onNext(String s) {
                Log.d(TAG, "onNext: s = " + s);
                if (TextUtils.equals("2", s)) {
                    mDisposable.dispose();//取消订阅
                }
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: ");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: ");
            }
        };

通过new创建接口,并实现其内部的方法,看方法其实就应该差不多知道干嘛的,onNext、onError、onComplete都是跟被观察者发射的方法一一对应的,这里就相当于接收了。onSubscribe(Disposable d)里面的Disposable对象要说一下,Disposable英文意思是可随意使用的,这里就相当于读者和连载小说的订阅关系,如果读者不想再订阅该小说了,可以调用 mDisposable.dispose()取消订阅,此时连载小说更新的时候就不会再推送给读者了。

  1. 读者和连载小说建立订阅关系
        //被观察者和观察者建立订阅关系
        observable.subscribe(observer);

这里我们先看一下输出效果

2019-01-10 16:37:54.003 5022-5022/? E/84018442: onSubscribe
2019-01-10 16:37:54.003 5022-5022/? E/84018442: onNext:连载1
2019-01-10 16:37:54.003 5022-5022/? E/84018442: onNext:连载2
2019-01-10 16:37:54.003 5022-5022/? E/84018442: onNext:连载3
2019-01-10 16:37:54.003 5022-5022/? E/84018442: onComplete()

小结一下:这就是RxJava2.0最最简单的用法,创建小说,创建读者,建立订阅关系,记住这三步,你就能实现一个最简单的RxJava2.0的用法。

RxJava2.0的异步和链式编程

前言里面有提到,RxJava是支持异步的,但是RxJava是如何做到的呢?这里就需要Scheduler。Scheduler,英文名调度器,它是RxJava用来控制线程。当我们没有设置的时候,RxJava遵循哪个线程产生就在哪个线程消费的原则,也就是说线程不会产生变化,始终在同一个。然后我们一般使用RxJava都是后台执行,前台调用,本着这个原则,我们需要调用observeOn(AndroidSchedulers.mainThread()),observeOn是事件回调的线程,AndroidSchedulers.mainThread()一看就知道是主线程,subscribeOn(Schedulers.io()),subscribeOn是事件执行的线程,Schedulers.io()是子线程,这里也可以用Schedulers.newThread(),只不过io线程可以重用空闲的线程,因此多数情况下 io() 比 newThread() 更有效率。前面的代码根据异步和链式编程的原则,我们可以写成

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("连载1");
                emitter.onNext("连载2");
                emitter.onNext("连载3");
                emitter.onComplete();
            }
        })
                .observeOn(AndroidSchedulers.mainThread())//回调在主线程
                .subscribeOn(Schedulers.io())//执行在io线程
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG,"onSubscribe");
                    }

                    @Override
                    public void onNext(String value) {
                        Log.e(TAG,"onNext:"+value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG,"onError="+e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        Log.e(TAG,"onComplete()");
                    }
                });

这里就是RxJava最常用的写法,异步+链式编程,还要再说一下,subscribe的方法重载,subscribe()方法里什么参数也不放是空实现,也就是说连载小说无论出什么连载,读者都不关心,推送过来了也不读,如果读者只关心onNext方法里的内容,可以直接重载subscribe(Consumer<? spuer T> onNext)这个方法,会减少代码,当然如果是初学者还是建议创建Observer对象。

应用场景

因为RxJava就是一个支持异步的链式编程,所以所有的用到异步的地方,我们都可以用RxJava来完成,下面给大家举几个例子。

  1. 定时执行任务
Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(123);
                sleep(3000);
                emitter.onNext(456);
            }
        }).observeOn(AndroidSchedulers.mainThread())
                .subscribeOn(Schedulers.io())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG,integer+"");
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {

                    }
                }, new Action() {
                    @Override
                    public void run() throws Exception {

                    }
                });
  1. 比如我们要依次加载10张图片(加载图片是耗时过程),其中第六张我们延时3秒加载,第7张我们复制到sd卡里,第8张我们要上网络,那么请问你要怎么做,如果用Handler,必然是各种嵌套,各种逻辑复杂得让你再看一眼都难受,但是如果使用RxJava呢?
Observable.create(new ObservableOnSubscribe<Drawable>() {
            @Override
            public void subscribe(ObservableEmitter<Drawable> emitter) throws Exception {
                for (int i=0;i<drawableRes.length;i++){
                    Drawable drawable=getResources().getDrawable(drawableRes[i]);
                    //第6个图片延时3秒后架子
                    if (i==5){
                        sleep(3000);
                    }
                    //复制第7张图片到sd卡
                    if (i==6){
                        Bitmap bitmap=((BitmapDrawable)drawable).getBitmap();
                        saveBitmap(bitmap,"test.png", Bitmap.CompressFormat.PNG);
                    }
                    //上传到网络
                    if (i==7){
                        updateIcon(drawable);
                    }
                    emitter.onNext(drawable);
                }
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Drawable>() {
                    @Override
                    public void accept(Drawable drawable) throws Exception {
                           //回调后在UI界面上展示出来
                    }
                });
点击查看更多内容
TA 点赞

若觉得本文不错,就分享一下吧!

评论

作者其他优质文章

正在加载中
  • 推荐
  • 评论
  • 收藏
  • 共同学习,写下你的评论
感谢您的支持,我会继续努力的~
扫码打赏,你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫,即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消