【笔记】RxJava学习笔记

最新推荐文章于 2025-05-01 20:06:47 发布

Garvan0

最新推荐文章于 2025-05-01 20:06:47 发布

阅读量197

点赞数

分类专栏： Android 文章标签： java android

本文链接：https://blog.youkuaiyun.com/Gao_WKang/article/details/107369514

版权

Android 专栏收录该内容

9 篇文章

订阅专栏

蛋疼！刚开始接触RxJava的朋友们一定会有这样的想法。这货有啥用？看了很多文章抨击RxJava所以就不去了解。但是RxJava发展到现在仍然有不少公司在使用一定是有它存在的道理的，不是教程，不是教程，纯粹分享，map和flatMap的部分看了很多解读，总结了一个比较好理解的，希望对同样困惑的朋友有一丢丢的帮助~

1.基本使用

1.1 首先要有一个被观察者对象，用于向观察者发送通知：

 Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("1");
                subscriber.onNext("2");
                subscriber.onCompleted();
            }
        });

1.2 然后需要一个观察者对象

        Observer<String> observer = new Observer<String>() {
            @Override
            public void onCompleted() {
                Log.d(TAG, "onCompleted: ");
            }

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

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

除了Observer接口之外，还有一个实现了Observer接口的抽象类Subscriber

public abstract class Subscriber<T> implements Observer<T>

使用上与Observer相同，在subscribe的过程中，Observer也会先转换成subscriber

public final Subscription subscribe(final Observer<? super T> observer) {
        if (observer instanceof Subscriber) {
            return subscribe((Subscriber<? super T>)observer);
        }
        return subscribe(new Subscriber<T>() {

            @Override
            public void onCompleted() {
                observer.onCompleted();
            }

            @Override
            public void onError(Throwable e) {
                observer.onError(e);
            }

            @Override
            public void onNext(T t) {
                observer.onNext(t);
            }

        });
    }

区别：1. subscriber中增加了一个方法onStart()，这个方法会在subscribe开始，但事件还没有发送之前调用

unsubscribe():subscriber可以取消订阅，也可以用isUnsubscribe()判断在subscribe之后，被观察者会持有观察者的引用，可以在onPause()或onStop()等方法中解除引用关系，避免内存泄漏。

1.3 最后被观察者产生的事件被观察者订阅

  observable.subscribe(observer);

在被观察者产生事件，以及观察者接收到事件并处理的过程中可以做很多事情，比如转换事件类型、合并多个事件、事件延迟发送等。

2.创建操作符

2.1 creat(）

使用creat()创建一个被观察者对象

2.2 just()

快速创建被观察者对象
使用just（）操作符
直接发送传入的事件(最多只能发送十个参数)

        Observable.just(1, 2, 3,4)
                .subscribe(new Observer<Integer>() {

                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    }
                    // 默认最先调用复写的 onSubscribe（）

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });

2.3 延迟创建

timer（）

延迟指定时间后发送一个数值0（Long类型）
本质上是延迟指定时间后调用onNext(0)

   Observable.timer(2, TimeUnit.SECONDS) 
                  .subscribe(new Observer<Long>() {

interval()

每隔指定时间就发送事件
发送的事件序列为从0开始，递增1的整数序列

 // 参数说明：
        // 参数1 = 第1次延迟时间；
        // 参数2 = 间隔时间数字；
        // 参数3 = 时间单位；
        Observable.interval(3,1,TimeUnit.SECONDS)

3.变换操作符

3.1 map

.map(new Func1<I, O>()

作用：对参数 I 的数据作处理使之达到 O 的要求，可进行类型转换、数据筛选等操作。
例如

3.2 flatMap

/**
     * Returns an Observable that emits items based on applying a function that you supply to each item emitted
     * by the source Observable, where that function returns an Observable, and then merging those resulting
     * Observables and emitting the results of this merger.
     * <p>
     * <img width="640" height="310" src="https://raw.github.com/wiki/ReactiveX/RxJava/images/rx-operators/flatMap.png" alt="">
     * <dl>
     *  <dt><b>Scheduler:</b></dt>
     *  <dd>{@code flatMap} does not operate by default on a particular {@link Scheduler}.</dd>
     * </dl>
     * 
     * @param func
     *            a function that, when applied to an item emitted by the source Observable, returns an
     *            Observable
     * @return an Observable that emits the result of applying the transformation function to each item emitted
     *         by the source Observable and merging the results of the Observables obtained from this
     *         transformation
     * @see <a href="http://reactivex.io/documentation/operators/flatmap.html">ReactiveX operators documentation: FlatMap</a>
     */
    public final <R> Observable<R> flatMap(Func1<? super T, ? extends Observable<? extends R>> func) {
        if (getClass() == ScalarSynchronousObservable.class) {
            return ((ScalarSynchronousObservable<T>)this).scalarFlatMap(func);
        }
        return merge(map(func));
    }

flatMap中的 “flat” 可以理解为 “flatten”的过程。map和flatMap都是将传入的对象转化为另一个对象，但是flatMap中返回的是一个Observable对象，这个Observable对象并不是直接发送到了subscriber的回调方法中进行处理。
首先flatMap会根据传入的事件创建Observale对象，但是flatMap并不会发送这个对象，而是“激活”这个Observale开始发送事件，每一个Observale发送的事件最终被汇入同一个Observale中，并交给subscriber的回调方法去处理。把初始的对象“铺平”后再通过一个Observale发送。

具体例子

Func1中传入的I是String类型的对象，目标O是Observable<List>，首先将传入的String对象转换为Observable对象，然后这个Obsercable对象开始发送他的事件，也就是List，最终返回的是一个Observable对象，并将其发送的事件（List）交给subscriber中的回调方法进行处理。

.flatMap(new Func1<String, Observable<List<WrapperModel>>>()

4. Zip()

当数据有多个来源，例如首页的数据可能有多个请求的接口，每个接口请求数据的响应时间也不同，但我们希望在所有数据接收完毕后再渲染界面，这个时候就可以用zip来合并请求的数据源。

事件1 是获取首页广告数据
事件2是获取首页轮播图数据
通过zip将这两个事件合并起来，当两个数据都请求完成的时候通过subscriber的回调方法进行处理