Android-RxJava使用介绍

最新推荐文章于 2024-04-06 02:38:28 发布
最新推荐文章于 2024-04-06 02:38:28 发布
阅读量415 收藏
点赞数 1
分类专栏： Android java 文章标签： RxJava Android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daiyibo123/article/details/80186788
版权

RxJava的应用场景

我认为“RxJava的应用场景到底在哪里？”的答案，应该到“什么是Rx”里找？先弄清楚“什么是Rx”，然后再思考RxJava可以给我们的项目带来什么好处？
    Rx是什么：Rx是一个基于响应式编程思想实现的函数库，让开发者可以利用可观察序列和LINQ风格查询操作符来编写异步和基于事件的程序（可以这样定义：Rx=Observable + LINQ + Schedule）
    因此，RxJava的应用场景其实应该从其特点（Observable-事件，LINQ-链式操作符，Schedule-线程，响应式编程）出发。能够发挥其特点帮助开发者更快速高效的进行开发的场景，就是RxJava的应用场景。

  1. 项目中，存在大量复杂的操作（包括UI反馈，网络请求等）。这些操作会引出一连串业务处理（包括UI刷新，DB处理等），通过RxJava将操作转化为Observable，再通过响应式编程链式调用来实现业务，可以让业务处理的流程更加清楚，改动业务更灵活。
  2. RxJava提供了大量操作事件的操作符，这些操作符的功能涵盖了项目开发中大部分的应用场景，使用这些操作符API，可以减少开发成本，事半功倍。
  3. RxJava提供了方便的线程切换操作，切换线程不再需要用到Handler之类的操作了。加大开发效率，提升代码清晰度。

Observable使用介绍

  • Observable为上游操作，负责发送事件
  • Observer为下游操作，负责接收事件

同步调用示例

//创建一个上游 Observable：
Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
        emitter.onComplete();
    }
});
//创建一个下游 Observer
Observer<Integer> observer = new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "subscribe");
    }
​
    @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");
    }
};
//建立连接
observable.subscribe(observer);
​
/*
打印信息：
        04-24 21:31:10.412 20629-20629/example.abe.com.android.frameworkgit D/VolleyBaseActivity: subscribe
        04-24 21:31:10.412 20629-20629/example.abe.com.android.frameworkgit D/VolleyBaseActivity: 1
        04-24 21:31:10.412 20629-20629/example.abe.com.android.frameworkgit D/VolleyBaseActivity: 2
        04-24 21:31:10.412 20629-20629/example.abe.com.android.frameworkgit D/VolleyBaseActivity: 3
        04-24 21:31:10.412 20629-20629/example.abe.com.android.frameworkgit D/VolleyBaseActivity: complete
*/

参数介绍

ObservableEmitter参数
用来发出事件的发射器，它可以发出三种类型的事件，通过onNext(T value)发送next事件、通过onComplete()发送complete事件和通过onError(Throwable error)发送error事件
  • onNext()方法：上游可以发送无限个onNext, 下游也可以接收无限个onNext。
  • onCompute()方法：当上游发送了一个onComplete后, 上游onComplete之后的事件将会继续发送, 而下游收到onComplete事件之后将不再继续接收事件。      
  • onError()方法：当上游发送了一个onError后, 上游onError之后的事件将继续发送, 而下游收到onError事件之后将不再继续
  • 注意点：最为关键的是onComplete和onError必须唯一并且互斥, 即不能发多个onComplete, 也不能发多个onError, 也不能先发一个onComplete, 然后再发一个onError, 反之亦然
Disposable参数
连接上游和下游的一个开关，当调用它的dispose()方法时, 它就会将两根管道切断, 从而导致下游收不到事件.注意: 调用dispose()并不会导致上游不再继续发送事件, 上游会继续发送剩余的事件。

异步调用示例

Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        Log.d(TAG, "Observable thread is : " + Thread.currentThread().getName());
        Log.d(TAG, "emit 1");
        emitter.onNext(1);
    }
});
Consumer<Integer> consumer = new Consumer<Integer>() {
    @Override
    public void accept(Integer integer) throws Exception {
        Log.d(TAG, "Observer thread is :" + Thread.currentThread().getName());
        Log.d(TAG, "onNext: " + integer);
    }
};
observable
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(consumer);
​
/**
打印信息：
        04-24 21:55:51.466 21858-21912/example.abe.com.android.frameworkgit D/VolleyBaseActivity: Observable thread is : RxCachedThreadScheduler-1
        04-24 21:55:51.466 21858-21912/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit 1
        04-24 21:55:51.485 21858-21858/example.abe.com.android.frameworkgit D/VolleyBaseActivity: Observer thread is :main
        04-24 21:55:51.485 21858-21858/example.abe.com.android.frameworkgit D/VolleyBaseActivity: onNext: 1
*/
RxJava线程切换操作
Schedulers.io() 代表io操作的线程, 通常用于网络,读写文件等io密集型的操作
Schedulers.computation() 代表CPU计算密集型的操作, 例如需要大量计算的操作
Schedulers.newThread() 代表一个常规的新线程
AndroidSchedulers.mainThread() 代表Android的主线程

Flowable使用介绍

  • Flowable为上游操作，负责发送事件，与Observable的区别在于Flowable提供背压策略，方便使用。
  • Subscriber为下游操作，负责接收事件。
Flowable支持的背压策略如下
  • BackpressureStrategy.ERROR：缓存区默人大小128，流速不均衡时发射MissingBackpressureException信号。
  • BackpressureStrategy.BUFFER：缓存区不限制大小，使用不当仍会OOM。
  • BackpressureStrategy.DROP：缓存最近的nNext事件。
  • BackpressureStrategy.LATEST：缓存区会保留最后的OnNext事件，覆盖之前缓存的OnNext事件。
  • BackpressureStrategy.MISSING：OnNext事件没有任何缓存和丢弃，下游要处理任何溢出。

同步操作

Flowable<Integer> upstream = Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emit 1");
                emitter.onNext(1);
                Log.d(TAG, "emit 2");
                emitter.onNext(2);
                Log.d(TAG, "emit 3");
                emitter.onNext(3);
                Log.d(TAG, "emit complete");
                emitter.onComplete();
            }
        }, BackpressureStrategy.ERROR); //增加了一个参数，提供背压策略
​
        Subscriber<Integer> downstream = new Subscriber<Integer>() {
​
            @Override
            public void onSubscribe(Subscription s) {
                Log.d(TAG, "onSubscribe");
                s.request(Long.MAX_VALUE);  //设置获取上游请求数量
            }
​
            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: " + integer);
​
            }
​
            @Override
            public void onError(Throwable t) {
                Log.w(TAG, "onError: ", t);
            }
​
            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete");
            }
        };
        upstream.subscribe(downstream);
​
/**
打印信息：
         04-25 19:25:13.453 1754-1754/example.abe.com.android.frameworkgit D/VolleyBaseActivity: onSubscribe
         04-25 19:25:13.453 1754-1754/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit 1
         04-25 19:25:13.453 1754-1754/example.abe.com.android.frameworkgit D/VolleyBaseActivity: onNext: 1
         04-25 19:25:13.453 1754-1754/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit 2
         04-25 19:25:13.453 1754-1754/example.abe.com.android.frameworkgit D/VolleyBaseActivity: onNext: 2
         04-25 19:25:13.453 1754-1754/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit 3
         04-25 19:25:13.453 1754-1754/example.abe.com.android.frameworkgit D/VolleyBaseActivity: onNext: 3
         04-25 19:25:13.453 1754-1754/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit complete
         04-25 19:25:13.453 1754-1754/example.abe.com.android.frameworkgit D/VolleyBaseActivity: onComplete
*/

异步操作

Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emit 1");
                emitter.onNext(1);
                Log.d(TAG, "emit 2");
                emitter.onNext(2);
                Log.d(TAG, "emit 3");
                emitter.onNext(3);
                Log.d(TAG, "emit complete");
                emitter.onComplete();
            }
        }, BackpressureStrategy.ERROR).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<Integer>() {
​
                    @Override
                    public void onSubscribe(Subscription s) {
                        Log.d(TAG, "onSubscribe");
                        s.request(3);  //把Subscription保存起来
                    }
​
                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "onNext: " + integer);
                    }
​
                    @Override
                    public void onError(Throwable t) {
                        Log.w(TAG, "onError: ", t);
                    }
​
                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete");
                    }
                });
​
/**
打印信息：
         04-25 19:29:58.530 2639-2639/example.abe.com.android.frameworkgit D/VolleyBaseActivity: onSubscribe
         04-25 19:29:58.531 2639-2697/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit 1
         04-25 19:29:58.532 2639-2697/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit 2
         04-25 19:29:58.532 2639-2697/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit 3
         04-25 19:29:58.532 2639-2697/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit complete
         04-25 19:29:58.545 2639-2639/example.abe.com.android.frameworkgit D/VolleyBaseActivity: onNext: 1
         04-25 19:29:58.545 2639-2639/example.abe.com.android.frameworkgit D/VolleyBaseActivity: onNext: 2
         04-25 19:29:58.545 2639-2639/example.abe.com.android.frameworkgit D/VolleyBaseActivity: onNext: 3
         04-25 19:29:58.545 2639-2639/example.abe.com.android.frameworkgit D/VolleyBaseActivity: onComplete
*/

Map操作符介绍

Map是RxJava中最简单的一个变换操作符了, 它的作用就是对上游发送的每一个事件应用一个函数, 使得每一个事件都按照指定的函数去变化. 用事件图表示为：


Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
    }
}).map(new Function<Integer, String>() {
    @Override
    public String apply(Integer integer) throws Exception {
        return "This is result " + integer;
    }
}).subscribe(new Consumer<String>() {
    @Override
    public void accept(String s) throws Exception {
        Log.d(TAG, s);
    }
});
​
/*
打印信息：
        04-24 22:15:21.136 22309-22309/example.abe.com.android.frameworkgit D/VolleyBaseActivity: This is result 1
        04-24 22:15:21.136 22309-22309/example.abe.com.android.frameworkgit D/VolleyBaseActivity: This is result 2
        04-24 22:15:21.136 22309-22309/example.abe.com.android.frameworkgit D/VolleyBaseActivity: This is result 3
*/

FlatMap操作符介绍

FlatMap将一个发送事件的上游Observable变换为多个发送事件的Observables，然后将它们发射的事件合并后放进一个单独的Observable里，时间无序。


Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        //上游发送3个事件
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onNext(3);
    }
}).flatMap(new Function<Integer, ObservableSource<String>>() {
    @Override
    public ObservableSource<String> apply(Integer integer) throws Exception {
        //将1个事件转变为发送3个事件，并延迟10毫秒发送
        final List<String> list = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            list.add("I am value " + integer);
        }
        return Observable.fromIterable(list).delay(10, TimeUnit.MILLISECONDS);
    }
}).subscribe(new Consumer<String>() {
    @Override
    public void accept(String s) throws Exception {
        Log.d(TAG, s);
    }
});
/**
打印信息：
         D/TAG: I am value 1
         D/TAG: I am value 1
         D/TAG: I am value 1
         D/TAG: I am value 3
         D/TAG: I am value 3
         D/TAG: I am value 3
         D/TAG: I am value 2
         D/TAG: I am value 2
         D/TAG: I am value 2
         */

ConcatMap操作符介绍

ConcatMap和FlatMap的作用是一样的，唯一区别是concatMap是时间有序的。用法和FlatMap一样。如下所示： 
Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
            }
        }).concatMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                final List<String> list = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    list.add("I am value " + integer);
                }
                return Observable.fromIterable(list).delay(10,TimeUnit.MILLISECONDS);
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, s);
            }
        });
/**
打印信息：
         D/TAG: I am value 1
         D/TAG: I am value 1
         D/TAG: I am value 1
         D/TAG: I am value 2
         D/TAG: I am value 2
         D/TAG: I am value 2
         D/TAG: I am value 3
         D/TAG: I am value 3
         D/TAG: I am value 3
         */

Zip操作符介绍

zip通过一个函数将多个Observable发送的事件结合到一起，然后发送这些组合到一起的事件. 它按照严格的顺序应用这个函数。它只发射与发射数据项最少的那个Observable一样多的数据。


Observable<Integer> observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emit 1");
                emitter.onNext(1);
                Thread.sleep(1000);
​
                Log.d(TAG, "emit 2");
                emitter.onNext(2);
                Thread.sleep(1000);
​
                Log.d(TAG, "emit 3");
                emitter.onNext(3);
                Thread.sleep(1000);
​
                Log.d(TAG, "emit 4");
                emitter.onNext(4);
                Thread.sleep(1000);
​
                Log.d(TAG, "emit complete1");
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.io());//切换线程，主要是为了体现异步有序的特点
​
        Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                Log.d(TAG, "emit A");
                emitter.onNext("A");
                Thread.sleep(1000);
​
                Log.d(TAG, "emit B");
                emitter.onNext("B");
                Thread.sleep(1000);
​
                Log.d(TAG, "emit C");
                emitter.onNext("C");
                Thread.sleep(1000);
​
                Log.d(TAG, "emit complete2");
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.io());//切换线程，主要是为了体现异步有序的特点
​
        Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
            @Override
            public String apply(Integer integer, String s) throws Exception {
                return integer + s;
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe");
            }
​
            @Override
            public void onNext(String value) {
                Log.d(TAG, "onNext: " + value);
            }
​
            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError");
            }
​
            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete");
            }
        });
​
/**
打印信息：
        04-25 18:49:46.294 31115-31115/example.abe.com.android.frameworkgit D/VolleyBaseActivity: onSubscribe
        04-25 18:49:46.295 31115-31156/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit 1
        04-25 18:49:46.295 31115-31157/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit A
        04-25 18:49:46.296 31115-31157/example.abe.com.android.frameworkgit D/VolleyBaseActivity: onNext: 1A
        04-25 18:49:47.296 31115-31156/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit 2
        04-25 18:49:47.296 31115-31157/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit B
        04-25 18:49:47.296 31115-31157/example.abe.com.android.frameworkgit D/VolleyBaseActivity: onNext: 2B
        04-25 18:49:48.296 31115-31156/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit 3
        04-25 18:49:48.296 31115-31157/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit C
        04-25 18:49:48.296 31115-31157/example.abe.com.android.frameworkgit D/VolleyBaseActivity: onNext: 3C
        04-25 18:49:49.296 31115-31156/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit 4
        04-25 18:49:49.296 31115-31157/example.abe.com.android.frameworkgit D/VolleyBaseActivity: emit complete2
        04-25 18:49:49.296 31115-31157/example.abe.com.android.frameworkgit D/VolleyBaseActivity: onComplete
*/


参考

给初学者的RxJava2.0教程(一)：http://www.jianshu.com/p/464fa025229e
给初学者的RxJava2.0教程(二)：http://www.jianshu.com/p/8818b98c44e2
给初学者的RxJava2.0教程(三)：http://www.jianshu.com/p/128e662906af
给初学者的RxJava2.0教程(四)：http://www.jianshu.com/p/bb58571cdb64
给初学者的RxJava2.0教程(五)：http://www.jianshu.com/p/0f2d6c2387c9
给初学者的RxJava2.0教程(六)：http://www.jianshu.com/p/e4c6d7989356
给初学者的RxJava2.0教程(七)：http://www.jianshu.com/p/9b1304435564
给初学者的RxJava2.0教程(八)：http://www.jianshu.com/p/a75ecf461e02
给初学者的RxJava2.0教程(九)：http://www.jianshu.com/p/36e0f7f43a51


Abe_119
关注
专栏目录
Android中abe工具
05-18
Android中可以查看备份文件ab的工具
android--RXJava详细使用篇
袁震的博客
01-30 2897
人性的背后是白云苍狗，愿我们都能做生活的高手
给 Android 开发者的 RxJava 详解
青岛海珊瑚IT学习中心
04-17 3133
前言 我从去年开始使用 RxJava ，到现在一年多了。今年加入了 Flipboard 后，看到 Flipboard 的 Android 项目也在使用 RxJava ，并且使用的场景越来越多 。而最近这几个月，我也发现国内越来越多的人开始提及 RxJava 。有人说『RxJava 真是太好用了』，有人说『RxJava 真是太难用了』，另外更多的人表示：我真的百度了也谷歌了，但我还是想问： RxJava 到底是什么？ 鉴于 RxJava 目前这种既火爆又神秘的现状，而我又在一年的使用过程中对 RxJa..
android——rxjava的使用(连续多个弹窗的处理)
wy313622821的博客
01-11 2981
本文介绍项目开发中使用到rxjava的情形，以及详细的代码。RxJava是一个基于Java语言的Reactive Extensions库，它用于实现异步编程和流式处理，通过将事件和数据流以数据序列的形式进行处理，提高了代码的可读性和可维护性。
Android开发之RxJava使用
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
11-11 2345
RxJava是响应式编程，也可以理解为流式编程，核心是观察者模式。Rx是微软.Net的一个响应式扩展，Rx借助可观测的序列提供一种简单的方式来创建异步的，基于事件驱动的程序。2012年Netflix为了应对不断增长的业务需求开始将.NET Rx迁移到JVM上面。并于13年二月份正式向外展示了RxJava。使用RxJava可以是编程更加简洁、易懂，避免出现回调地狱。
Android-RxjavaApi实例代码
08-13
在Android开发中，RxJava是一个非常重要的库，它引入了反应式编程的概念，使得异步操作变得更加简单和优雅。RxJava结合了观察者模式、序列化执行和灵活的数据流管理，为开发者提供了强大的工具来处理复杂的事件处理...
Android-RxjavaRetrofit封装便捷使用
08-12
在Android开发中，响应式编程框架RxJava与网络请求库Retrofit的结合使用，能够极大地提升应用的异步处理能力和代码的可读性。这里我们主要探讨如何进行RxJava和Retrofit的封装，以实现更便捷、高效的应用开发。 1. ...
Android-MVVM-DataBinding-RxJava-Retrofit
05-02
在“Android-MVVM-DataBinding-RxJava-Retrofit”项目中，开发者首先使用Retrofit创建一个接口来定义与Github API的交互，如获取顶级公共要点的请求。接着，Retrofit会将这个接口转换为实际的网络请求。然后，RxJava...
Android-RxJava和Kotlin实现的拼图游戏
08-13
在Android开发领域，使用Kotlin和RxJava可以创建出高效且易于维护的代码。本项目是一个基于Android的拼图游戏，充分利用了这两种技术的优势。让我们深入探讨如何在Android应用中结合Kotlin和RxJava来构建这样的游戏...
Android-rxjava2.0和retrofit2.0兼容的网络框架的封装
08-13
在Android开发中，网络请求是应用必不可少的一部分，而RxJava2.0与Retrofit2.0的结合使用，为开发者提供了高效、灵活的网络请求解决方案。这个“Android-rxjava2.0和retrofit2.0兼容的网络框架的封装”就是针对这两...
Android Rxjava框架的原理和使用
m0_70749039的博客
03-26 1263
本文主要是对RxJava使用及Android常见使用场景进行总结，掌握这些还远远不够，RxJava还有许多强大的功能，诸如从磁盘/内存中获取缓存数据，背压策略，联想搜索优化等等。后面在项目开发中遇到相关场景再进行总结，更新。本文若有不当之处，请批评指正。
Android RxJava实际应用案例讲解：使用RxJava的最佳开发场景
chuanao8829的博客
03-09 380
前言 Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大Android开发者的欢迎。 如果还不了解RxJava，请看文章：Android：这是一篇 清晰 & 易懂的Rxjava 入门教程 今天，我将为大家带来...
《给 Android 开发者的 RxJava 详解》笔记
linxi7的博客
10-24 524
这篇文章是看扔物线的《给 Android 开发者的 RxJava 详解》的笔记，在此仅仅做一个笔记，以便日后查用。RxJava的优势 异步（RxJava本质上是一个实现异步操作的库） 简洁（随着程序逻辑变得越来越复杂，它依然能够保持简洁） API 介绍和原理简析RxJava的观察者模式 RxJava 有四个基本概念：Observable (可观察者，即被观察者)、 Observer (观察者)、
Android Rxjava教程：清晰 简洁 易懂的Rxjava入门教程
yzwfeng的专栏
03-15 7713
前言 Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。 image 本文主要： 面向 刚接触Rxjava的初学者 提供了一份 清晰、简洁、易懂的Rxjava入门教程 涵盖 基本介绍、原理 & 具体使用等 解决的是初学者不理解Rxjava原理 & 不懂得如何使用的问题 希望你们会喜欢。 本文主要基于Rxjava 2.0 如果读者还没学习过Rxjava 1.0也没关系，因为Rxja
Android之RxJava入门教程
LVXIANGAN的专栏
04-09 721
先总结本文的知识要点，更多详情请查看本文余下部分。 1、创建操作符 2、变换操作符 3、组合 / 合并操作符 4、功能性操作符 前言 Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大Android开发者的欢迎。 本文主要基于Rxjava 2.0 如果读者还没学习过Rxjava 1.0也没关系，因为Rxj...
Android中的RxJava入门及常用操作符
ChenYiRan123456的博客
10-07 845
RxJava在GitHub的介绍// 翻译：RxJava 是一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库也就是说：RxJava是一个基于事件流，实现异步操作的库。
Android RxJava使用介绍（四） RxJava的操作符
热门推荐
呼啸而过的专栏
07-18 1万+
本篇文章继续介绍以下类型的操作符 Combining Observables(Observable的组合操作符) Error Handling Operators(Observable的错误处理操作符) Combining Observables(Observable的组合操作符)combineLatest操作符combineLatest操作符把两个Observable产生的结果进行合并，合并的结果
Android RxJava：这是一份RxJava使用入门学习指南，涨姿势
最新发布
2401_84149570的博客
04-06 1627
即 开厨房 - 确定对应菜式Next事件、Complete事件 &Error事件。具体如下：具体实现// 1. 创建观察者 （Observer ）对象// 2. 创建对象时通过对应复写对应事件方法 从而 响应对应事件// 观察者接收事件前，默认最先调用复写 onSubscribe（）@OverrideLog.d(TAG, “开始采用subscribe连接”);
使用Rxlifecycle解决Android中RxJava内存泄漏
"本文主要探讨了如何利用Rxlifecycle解决Android应用中由RxJava引发的内存泄漏问题。RxJava作为一款流行的响应式编程框架，因其简洁的编程风格和强大的异步处理能力而受到广泛欢迎。然而，如果不正确地管理RxJava的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值