RxJava的简单入门

RxJava的简单入门

什么是RxJava

GitHub上是这么说的:

一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库

本质上做的就两个字 : 异步.
剩下的定语: 可观测序列,基于事件,响应式,等等 全是用来修饰异步这个词,
所以可以简单地认为他跟handler,AsyncTask一样的做异步任务的东西;

然后你要明白它好在哪儿:

本质上还是就两个字 线程切换方便,代码逻辑清楚.
现在是不是想不明白它为啥这么牛是么,来,让我用通俗的,人类可以明白的语言解释一下.

线程切换方便
之前我们切换线程,是不是先写一个Thread然后用handler来通讯,或者handler.post或者view.post.要写老多代码.然而在RxJava这儿,线程切换就两行代码:

第一行上面的在子线程中运行,第二行下面的在主线程中运行.
怎么样?爽不爽?!

代码逻辑清楚

这个RxJava的思路事实上是这样的,先create出来一个ApplicationInfoList的list,然后用filter过滤掉非系统应用,然后用map将ApplicationInfo转换成为AppInfo,然后祭出线程切换的两行神奇代码,把上面的这些放到子线程中,然后后面在主线程中更新视图.

完成,有的大兄弟还是蒙圈,没事,你看咱们不看代码 ,就看这几个操作符(create,map,filter)啥的,里面的代码不看,这样的话代码的逻辑是不是清楚了许多.

RxJava怎么写

知道了他的定义和好处,接下来就要看他怎么写了,首先声明,接下来的代码,大部分基于RxJava2,其实RxJava 1 2的用法差不多了;

因为是基于观察者模式,所以必定会有观察者和被观察者,这里的被观察者可以叫做Publisher(发射源),观察者叫做(Observer),流程呢,大致也是一个观察者模式,就不一一概述了.

首先我们需要一个被观察者/发射源 : Publisher
我们常用的publisher有Observable , Floatable 大致是这么拼的. 在Rxjava2 里面 observable不支持背压,所以我们一般用的是 floatable :
首先创建一个Floatable :

//创建一个 Publisher发射源

        Flowable<String> flowable = Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> e) throws Exception {
                e.onNext("Hello Rxjava2------LV1" );
                e.onComplete();
            }
        }, BackpressureStrategy.BUFFER);

然后还需要一个接收器 :

//创建一个Subscriber 接收器

        Subscriber<String> mySubscriber = new Subscriber<String>() {
            @Override
            public void onSubscribe(Subscription s) {
                Log.e("subscriber", "onSubscribe");
                //request表示请求资源
                s.request(Long.MAX_VALUE);
            }

            @Override
            public void onNext(String s) {
                Log.e("subscriber", "onNext");
                Toast.makeText(MainActivity.this, s, Toast.LENGTH_LONG).show();
            }

            @Override
            public void onError(Throwable t) {
                Log.e("subscriber", "onError" +"*****" + t.getMessage() + "*****");
            }

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

然后让他俩发生关系:

flowable.subscribe(mySubscriber);

发生关系特别快,一句话的事.

这就完成了一个最简单的 Rxjava的一套流程,只是做了一个toast.

是不是感觉并无卵用,为了一个toast我们需要写这么多的代码,然后他是可以简化的,简化后代码如下:

Flowable<String> flowable = Flowable.just("Hello Rxjava2------LV2");
        Consumer consumer = new Consumer() {
            @Override
            public void accept(Object o) throws Exception {
                Toast.makeText(MainActivity.this, o.toString(), Toast.LENGTH_LONG).show();
            }
        };
        flowable.subscribe(consumer);

有两点需要解释,一是 : 这里的Flowable 用的操作符不再是create 而是 just create 的意思只是生成一个Flowable对象,剩下的啥都没有, just的意思就是要把just()括号里的东西发射出去,射出去,可以看到我这里设立一个”Hello Rxjava2——LV2” . 然后我们对接收器也做了精简,我们一般只关心接收器里面的 on next()这个方法,所以我们可以用只有这个方法的cnsumer来代替Observer.然后最后一句话还是发生关系;

感觉代码还是有点多,事实上还可以再精简 :

Flowable.just("Hello Rxjava2------LV3")
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Toast.makeText(MainActivity.this, s, Toast.LENGTH_LONG).show();
                    }
                });

事实上就是不再创建出各自的对象,直接写;这个不必过分多说.

以上是一个最简单的RxJava流程的几种形态接下来讲的是RxJava最好玩的地方 : 操作符

操作符

1.map
最常用的操作符之一,作用的话,我们直接看代码:

 Flowable.just("map")
                .map(new Function<String, Integer>() {
                    @Override
                    public Integer apply(String s) throws Exception {
                        return s.hashCode();
                    }
                })
                .map(new Function<Integer, String>() {
                    @Override
                    public String apply(Integer integer) throws Exception {
                        return integer.toString();
                    }
                })
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Toast.makeText(MainActivity.this, s, Toast.LENGTH_LONG).show();
                    }
                });

是的,很简单,就是改变Flowable里面的对象:
由一个String –> Integer –>String 随意变着玩 但是请注意 他只是变得Flowable里的对象,本质上你的Flowable还是你Flowable;
接下来讲他的哥哥 : flatmap :
2.faltmap
是的,他就是map的升级版.他变得不仅仅是Flowable里面的对象了,他变得是Flowable,是不是有点莫权篡位的感觉.
具体代码如下:

query("hello rxjava").flatMap(new Function<List<String>, Publisher<String>>() {
            @Override
            public Publisher<String> apply(List<String> strings) throws Exception {
                return Flowable.fromIterable(strings);
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e("flatMap", "url ::" + s);
            }
        });

query()这个方法就是一个输入 List<String> 的一个方法,可以看到,当我们输出了一个 List<String>
的时候,我们通过flatmap这个操作符,将其变为了一个又一个string发了出去,就相当于把list里面的东西一个个拿出来,然后通过一个个Flowable打包然后再发出去.

3.其余操作符
还有一些像是take,interval……的操作符就不说了,原理跟上面两个差不多的.

onError()

上面我们讲的代码,都是发生在接收器的onNext(),这个方法中,然后我们要讲的就是onError(),这个方法,顾名思义,就是这个流程发生错误的时候会走的方法,需要注意的事,这个方法在整个流程中,只要有一个流程出错,就会走到这儿,然后后面的都不会走了.
具体的代码的话,可以结合retrofit来讲: