RxJava使用入门

最新推荐文章于 2024-08-16 11:58:00 发布

抽烟的青蛙

最新推荐文章于 2024-08-16 11:58:00 发布

阅读量712

点赞数 1

分类专栏： RxJava

本文链接：https://blog.csdn.net/u012858313/article/details/55811309

版权

RxJava 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

简介

这篇文章只是记录一下RxJava的使用，不涉及源码分析

前言

RxJava是做什么的？我们为什么要用Rxjava?就我现在的理解来说，一个作用是发送数据接收数据，二是异步。

基本概念

Observable：被观察者。事件的产生者，发送者，是主动的，整个事件的起点。
Observer：观察者。事件的处理者，相应者，是被动的，整个事件的结束点。
Subscriber：Subscriber是实现Observer接口的抽象类，即和Observer同为观察者
subscribe：订阅方法，被观察者通过subscribe( )响应到观察者那里去，同理unsubscribe( )方法是取消订阅
Subscription：Observable调用subscribe( )方法返回的对象，用于unsubscribe( )方法是取消订阅
Action0：RxJava中的一个接口，它只有一个call( )方法，无参数且无返回值，当然还有Action1，Action2,Action3…,0,1,2,3分别表示call( )这个方法接受参数的数量，他和Observer都可以当做观察者来使用，区别只是Observer是onNext，onError,onComplete三个方法，而Action只有call方法
Func0：和Action0的区别就是Action0没有返回值，而Func0有返回值

总的来说就是Observable发出一系列事件，Observer/Subscriber处理这些事件

基本用法

1、创建被观察者

正常模式

Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>(){

            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("create1");
                subscriber.onNext("create2");
                subscriber.onCompleted();
            }
        });

just模式

Observable<String> observable = Observable.just("create1","create2");

from模式

String [] strArray={"create1","create2"};
Observable<String> observable = Observable.from(strArray);

interval模式，按固定时间间隔发射long型的Observable

//每隔2秒发送一次
Observable<Long> observable = Observable.interval(2, TimeUnit.SECONDS);
//5秒倒计时，每隔1秒发送一次
Observable<Long> observable1 = Observable.interval(0,5 ,TimeUnit.SECONDS);

repeat模式
```
//重复发射3次
Observable<String> observable = Observable.from(strArray).repeat(3);
```
还有其他的range，timer，defer等模式，这里不详细说了，这些模式实际上也都是被观察者把那些信息”create1”,”create2”，包装成onNext（”create”）这样的事件依次发给观察者，当然，它自己补上了onComplete()事件

2、创建观察者

Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {

            }
        };


Action1<String> action1 = new Action1<String>() {
            @Override
            public void call(String s) {

            }
        };

Func1<String, Boolean> func1 = new Func1<String, Boolean>() {
            @Override
            public Boolean call(String s) {
                return TextUtils.isEmpty(s);
            }
        };

3、订阅

Subscription subscription = observable.subscribe(observer);

这样写法看起来好像是被观察者订阅了观察者，造成一定的误解，之所以这样写，是为了保证流式API调用风格，所以这地方需要你自己理顺了

总结一下：

创建被观察者，产生事件
设置事件传递过程中的过滤，合并，变换等加工操作。
订阅一个观察者对象，实现事件最终的处理。

4、操作符

Map ：对原始Observable发射的每一个数据应用一个你选择的函数，然后返回一个发射这些结果

 Observable.just("Hello", "RxJava")
                .map(new Func1<String, String>() {
                    @Override
                    public String call(String s) {
                        return s.toUpperCase();
                    }
                })
                .subscribe(new Observer<String>() {
                    @Override
                    public void onCompleted() {
                    }

                    @Override
                    public void onError(Throwable e) {
                    }

                    @Override
                    public void onNext(String s) {
                        //HELLO 
                        //RXJAVA
                    }
                });

flatMap ：将Observable产生的事件里的信息再包装成新的Observable传递出来，即接收一个Observable的输出作为输入，然后作为一个新的Observable再发射

List<List<String>> all = new ArrayList<>();
List<String> list = new ArrayList<>();
list.add("Hello");
list.add("RxJava");
all.add(list);
Observable.from(all).flatMap(new Func1<List<String>, Observable<String>>() {
            @Override
            public Observable<String> call(List<String> strings) {
                return Observable.from(strings);
            }
        }).map(new Func1<String, String>() {
            @Override
            public String call(String s) {
                return s.toUpperCase();
            }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {

            }
        });

Scan ：累加器函数`
GroupBy 按照指定的规则来分组元素
Filter 过滤操作
take()、takeLast() ：只发射前N个元素，只发射最后N个元素
First、last ：只发射第一个元素或者最后一个元素
Skip、SkipLast ：跳过前N个元素，跳过最后N个元素
distinct ：仅处理一次，可以处理去除重复的数据
ElementAt ：仅从一个序列中发射第n个元素然后就完成了，这里是从0开始计的。

Observable.just(1, 2, 3, 4, 5, 6)
                .elementAt(3)
                .subscribe(……);
    //打印结果：4

Merge : 合并多个Observables的发射物，多输入，单输出
-

5、Schedulers

调度器类型	效果
Schedulers.computation()	用于计算任务,这个计算指的是 CPU 密集型计算，不要把 I/O 操作放在 computation() 中。它也是许多RxJava方法的默认调度器：buffer()，debounce()，delay()，interval()，sample()，skip()
Schedulers.immediate()	直接在当前线程运行，相当于不指定线程。
Schedulers.io()	I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。
Schedulers.newThread()	启用新线程，并在新线程执行操作。
Schedulers.mainThread()	主线程运行。

线程调度只有subscribeOn( )和observeOn( )两个方法

subscribeOn( )它指示Observable在一个指定的调度器上创建（只作用于被观察者创建阶段create()）。只能指定一次，如果指定多次则以第一次为准.
observeOn( )指定在事件传递（加工变换）和最终被处理（观察者）的发生在哪一个调度器。可指定多次，每次指定完都在下一步生效。

Observable.just(1, 2, 3, 4) // IO 线程，由 subscribeOn() 指定
    .subscribeOn(Schedulers.io())
    .observeOn(Schedulers.newThread())
    .map(mapOperator) // 新线程，由 observeOn() 指定
    .observeOn(Schedulers.io())
    .map(mapOperator2) // IO 线程，由 observeOn() 指定
    .observeOn(AndroidSchedulers.mainThread) 
    .subscribe(subscriber);  // Android 主线程，由 observeOn() 指定