Android RxJava系列一: 基础经常使用详解

时间  2019-12-09
标签 android rxjava 系列 基础 经常 使用 详解 栏目 Android 繁體版
原文   原文链接

前言

本篇主要介绍Rxjava在 Android 项目中的基础使用和经常使用方法,旨在给对 RxJava 感兴趣的人一些入门的指引.对Rxjava不熟悉的朋友能够去看我以前写的一篇简单介绍 Android RxJava：基础介绍与使用,下面就来咱们一块儿来看看在项目中如何使用 Rxjava 吧!java

Rxjava是什么?为何要用Rxjava?

首先咱们要知道Rxjava究竟是什么东西?为何这么多人用它以及它在Android项目中所占的比重.
  • Rxjava究竟是什么呢?

RxJava 在 GitHub 主页上的自我介绍是 : a library for composing asynchronous and event-based programs using observable sequences for the Java VM（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）。这就是 RxJava ，归纳得很是精准。然而对于初学者来讲,两个字,不懂.其实说白了,Rxjava就是一个用来实现异步操做的第三方库,而至于其余的拓展功能也只是在实现异步过程当中提供了一些辅助功能罢了.因此总结一下就一句话:数据库

Rxjava是一个用来实现异步的、基于事件的第三方库(就把它理解成Android Handler 的升级版就好了)
  • 为何要用Rxjava?

这就到咱们今天的重头戏了.相信不少初学者都是在如下场景初识Rxjava的segmentfault

1.201x年你必须知道的几个Android开源库: .......、Rxjava
这是一个基于 Rxjava+Retrofit+mvp+........的demo
Android 工做必回 Rxjava+Retrofit+.......几件套数组

起初本人也是由于看到这些字眼才接触的Rxjava的,也是由于这些缘由我才使用的Rxjava. But,当你真正的去了解了Rxjava,真正的把Rxjava用到了你的项目中,你才真正知道,为啥这么多人说要用Rxjava,以及你为何要用Rxjava ,由于Rxjava真的太好用太便捷了,用了一次你就离不开它了.网络

举个例子你就能明白了:
假如如今有这么一个需求:你须要从数据库中取出一组图片资源id,而后经过遍历将它们显示在imageView上面,实现方式有不少种app

  • 使用传统方式实现
//操做数据库属于耗时操做,须要开辟一个新线程放在后台操做
        new Thread() {
            @Override
            public void run() {
                super.run();
                final int[] drawableRes = {}; //.......从数据库中取出id资源数组操做
                //将id对应 drawable显示在界面上,须要在UI线程操做
                imageView.post(new Runnable() {
                    @Override
                    public void run() {
                        imageView.setImageResource(drawableRes[0]);
                    }
                });
            }
        }.start();
Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            //.....操做UI
            imageView.setImageResource(drawableRes[0]);
        }
    };

 new Thread(){
            @Override
            public void run() {
                super.run();
                final int[] drawableRes = {}; //.......从数据库中取出id资源数组操做
                //将id对应 drawable显示在界面上,须要在UI线程操做
                handler.sendEmptyMessage(0);//发送消息,通知主线程刷新UI

            }
        }.start();
  • 使用Rxjava方式实现
Observable.create(new ObservableOnSubscribe<List>() {
            @Override
            public void subscribe(ObservableEmitter<List> emitter) throws Exception {
               drawableRes = new ArrayList<>(); //.......从数据库中取出id资源数组操做
               emitter.onNext(drawableRes);
               emitter.onComplete();
            }
        }).flatMap(new Function<List, ObservableSource<Integer>>() {
            @Override
            public ObservableSource<Integer> apply(List list) throws Exception {
                return Observable.fromIterable(list);
            }
        }).subscribeOn(Schedulers.io())//在IO线程执行数据库处理操做
          .observeOn(AndroidSchedulers.mainThread())//在UI线程显示图片
          .subscribe(new Observer<Integer>() {
              @Override
              public void onSubscribe(Disposable d) {
                  Log.d("----","onSubscribe");
              }

              @Override
              public void onNext(Integer integer) {
                  imageView.setImageResource(integer);//拿到id,加载图片
                  Log.d("----",integer+"");
              }

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

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

诶,等一下,你不是说使用Rxjava实现代码会更简洁快捷嘛,我怎么看着实现还变复杂了,明明只要切换一下线程,你这咋写了这么多,看不懂?????异步

咳咳,看不懂了吧,看不懂就对了,看着的确是变复杂了,But 代码这一连串链式调用下来不是显得代码逻辑很清晰吗.并且随着业务需求的增多,你可能须要拿到图片id时还要加一层过滤呢,只须要在加一个.xxx()方法便可,并且还能够随意切换操做线程,代码依然仍是这么清晰简洁.并且使用Android studio 打开时还会自动缩进和显示提示信息:async

Rxjava.jpg

上面的例子省去了部分代码,也是我随手写的,只要是让你体会一下Rxjava的书写方式和对比一下传统方式的实现有什么不一样,看不懂不要紧,下面我会一一解释,搬好小板凳
总结一下:ide

为何要用Rxjava: 由于随着程序逻辑变得愈来愈复杂，它依然可以保持代码的简洁和阅读性.

怎么用Rxjava?

关于Rxjava的简单集成和基础使用请查看我以前的介绍Android RxJava：基础介绍与使用post

首先大概说一下Rxjava的原理:

1.概念: 观察者模式
RxJava 的异步实现，是经过一种扩展的观察者模式来实现的。至于观察者模式的原理实现你们确定都已经很熟悉了,我就再也不阐述了,不熟悉的能够自行搜索.

RxJava 有四个基本概念：Observable (可观察者，即被观察者)、 Observer (观察者)、 subscribe (订阅)、事件。Observable 和 Observer 经过 subscribe() 方法实现订阅关系，从而 Observable 能够在须要的时候发出事件来通知 Observer。

RxJava 的事件回调方法除了普通事件 onNext() （至关于 onClick() / onEvent()）以外，还定义了两个特殊的事件：onCompleted() 和 onError()。

  • onCompleted(): 事件队列完结。RxJava 不只把每一个事件单独处理，还会把它们看作一个队列。RxJava 规定，当不会再有新的 onNext() 发出时，须要触发

    • onCompleted() 方法做为标志。
  • onError(): 事件队列异常。在事件处理过程当中出异常时，onError() 会被触发，同时队列自动终止，不容许再有事件发出。
  • 在一个正确运行的事件序列中, onCompleted() 和 onError() 有且只有一个，而且是事件序列中的最后一个。须要注意的是，onCompleted() 和 onError() 两者也是互斥的，即在队列中调用了其中一个，就不该该再调用另外一个。

Rxjava的观察者模式.jpg

  1. 基本实现
  • 建立 Observer 观察者
Observer observer = new Observer<String>(){

            @Override
            public void onSubscribe(Disposable d) {
                Log.d("----","onSubscribe" );
            }

            @Override
            public void onNext(String s) {
                Log.d("----", s);
            }

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

            @Override
            public void onComplete() {
                Log.d("----", "onComplete");
            }
        };
  • 建立 Observable 被观察者
Observable observable =Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                    emitter.onNext("rxjava");
                    emitter.onComplete();
            }
        });
  • Subscribe (订阅)
observable.subscribe(observer);

以上就是传统的使用方式,你也能够采用链式调用：

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("rxjava");
                emitter.onComplete();
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d("----", "onSubscribe");
            }

            @Override
            public void onNext(String s) {
                Log.d("----", s);
            }

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

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

在 RxJava 的默认规则中，事件的发出和消费都是在同一个线程的。也就是说，若是只用上面的方法，实现出来的只是一个同步的观察者模式。观察者模式自己的目的就是『后台处理，前台回调』的异步机制，所以异步对于 RxJava 是相当重要的。而要实现异步，则须要用到 RxJava 的另外一个概念： Scheduler 。

先贴代码,如下即可实现异步操做:

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("rxjava");
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.newThread())
          .observeOn(AndroidSchedulers.mainThread())      
          .subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d("----", "onSubscribe");
            }

            @Override
            public void onNext(String s) {
                Log.d("----", s);
            }

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

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

在这里咱们使用了Scheduler 进行了线程的切换,接下来介绍一下Scheduler :

  1. Scheduler (线程切换)

在不指定线程的状况下， RxJava 遵循的是线程不变的原则，即：在哪一个线程调用 subscribe()，就在哪一个线程生产事件；在哪一个线程生产事件，就在哪一个线程消费事件。若是须要切换线程，就须要用到 Scheduler （调度器）。

RxJava 已经内置了几个 Scheduler :

  • Schedulers.newThread(): 老是启用新线程，并在新线程执行操做。
  • Schedulers.io(): I/O 操做（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差很少，区别在于 io() 的内部实现是是用一个无数量上限的线程池，能够重用空闲的线程，所以多数状况下 io() 比 newThread() 更有效率。不要把计算工做放在 io() 中，能够避免建立没必要要的线程。
  • Schedulers.computation(): 计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算，即不会被 I/O 等操做限制性能的操做，例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。不要把 I/O 操做放在 computation() 中，不然 I/O 操做的等待时间会浪费 CPU。
  • AndroidSchedulers.mainThread()，它指定的操做将在 Android 主线程运行

有了这几个 Scheduler ，就可使用 subscribeOn() 和 observeOn() 两个方法来对线程进行控制了。

  • subscribeOn(): 指定 subscribe() 所发生的线程，即 Observable.OnSubscribe 被激活时所处的线程。或者叫作事件产生的线程。
  • observeOn(): 指定 Subscriber 所运行在的线程。或者叫作事件消费的线程。

简单使用以下:

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();
            }
        }).subscribeOn(Schedulers.io()) //在io执行上述操做
          .observeOn(AndroidSchedulers.mainThread())//在UI线程执行下面操做
          .subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d("----","开始了");
            }

            @Override
            public void onNext(String s) {
                Log.d("----", s);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {
                Log.d("----", "complete");
            }
        });
以上就是Rxjava的基本经常使用方法了,看到这里你就已经能够愉快的使用Rxjava代替AsyncTask / Handler了,赶忙去试试吧!
  • 参考文章: 给 Android 开发者的 RxJava 详解,这是扔物线很早以前写的一篇关于Rxjava 1.x的详解,虽然如今已经Rxjava已经发展到2.x版本了.但其中一些基本实现原理的讲解确实很是到位,通俗易懂,很适合初学者学习,强烈建议去看下
  • RxJava2 只看这一篇文章就够了这是玉刚说的一篇关于Rxjava经常使用API的介绍,基本囊括了Rxjava所用到的全部API,还有代码举例,也是强烈建议观看收藏

关于Rxjava系列一就到此结束啦,后面有时间我还会写写一些其余的经常使用拓展操做符和与retrofit2的结合使用,欢迎关注订阅!

欢迎关注做者darryrzhong,更多干货等你来拿哟.

请赏个小红心！由于你的鼓励是我写做的最大动力！

更多精彩文章请关注
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程