RxJava2.x详解（一）

最新推荐文章于 2024-07-09 10:51:40 发布
最新推荐文章于 2024-07-09 10:51:40 发布
阅读量238 收藏
点赞数 1
分类专栏： Android 第三方框架源码 文章标签： RxJava2.x
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011035026/article/details/85307622
版权
RxJava2.x详解系列博客

转载请标明出处：
https://blog.csdn.net/u011035026/article/details/85307622；

1、RxJava简介？
  • 简洁，支持链式调用
  • 扩展的观察者模式
  • 线程之间切换非常方便
  • 被观察者订阅观察者
2、RxJava2.x总纲
3、RxJava1.x和RxJava2.x的区别？


4、RxJava的使用三步骤
  • 创建Observable（被观察者）
  • 创建Observer（观察者）
  • 使用subscribe()进行订阅，这里要注意是被观察者订阅观察者
5、subscribe的重载方法
  • subscribe(onNext)
  • subscribe(onNext,onError)
  • subscribe(onNext,onError,onComplete)
  • subscribe(onNext,onError,onComplete,obSubscribe)
    注意：
    （1）onNext、onError、onSubscribe都是对应一个Consumer对象，而onComplete对应一个Action对象。
    （2）Consumer和Action的区别在于Consumer带有一个单一参数类型，Action是一个无参数类型。
    （3）执行顺序优先级，onSubscribe优先执行，成功则执行onNext，然后onComplete，反之失败则执行onError。
6、RxJava2.x中的5种观察者模式
  • Observable=>能够发射0或者n个数据，并以成功或者错事件终止。
  • Flowable=>能够发射0或者n个数据，并以成功或者错误事件终止，支持背压，可以控制数据源的发射速度。
  • Single=>只发射单个数据或者错误事件
  • Completable=>从来不发射数据，只处理onComplete和onError事件。
  • Maybe=>能够发射0或者1个数据，要么成功，要么失败。
（1）那么接下来咱们先看看第一种观察者模式写法Observable.subscribe(Observer)
### 第一种写法
### 注意这里的onNext()方法是Rxjava2.x里面的一种操作符，通俗的理解就是一个事件触发机制，
### 它会把"Hello Rxjava2.x"这个String类型的字符串数据，发送到成功的回调方法中去让其响应。
### 同理onError()和onComplete()方法同上理解，只是触发的回调不同而已。
Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("Hello Rxjava2.x");
                //emitter.onError(new Throwable("Hello Rxjava2.x Error"));
                emitter.onComplete();
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                //订阅的回调，可以用来取消当前订阅
                System.out.println("subscribe");
            }

            @Override
            public void onNext(String s) {
                //成功的回调
                System.out.println(s);
            }

            @Override
            public void onError(Throwable e) {
                //失败的回调
                System.out.println(e.getMessage());
            }

            @Override
            public void onComplete() {
                //完成的回调
                System.out.println("onComplete");
            }
        });
### 第二种写法
Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("Hello Rxjava2.x");
                //emitter.onError(new Throwable("Hello Rxjava2.x Error"));
                emitter.onComplete();
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                //成功的回调
                System.out.println(s);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable e) throws Exception {
                //失败的回调
                System.out.println(e.getMessage());
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                //完成的回调
                System.out.println("onComplete");
            }
        }, new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                //订阅的回调，可以用来取消当前订阅
                System.out.println("subscribe");
            }
        });

### 对应的Kotlin写法
 Observable.create(ObservableOnSubscribe<String> {
            it.onNext("Hello Rxjava2.x")
            //it.onError(new Throwable("Hello Rxjava2.x Error"));
            it.onComplete()
        }).subscribe(object : Observer<String> {
            override fun onSubscribe(d: Disposable) {
                //订阅的回调，可以用来取消当前订阅
                println("subscribe")
            }

            override fun onNext(s: String) {
                //成功的回调
                println(s)
            }

            override fun onError(e: Throwable) {
                //失败的回调
                print(e.message)
            }

            override fun onComplete() {
                //完成的回调
                println("onComplete")
            }
        })
Observable.create(ObservableOnSubscribe<String> {
            it.onNext("Hello Rxjava2.x")
            //it.onError(new Throwable("Hello Rxjava2.x Error"));
            it.onComplete()
        }).subscribe({
            //成功的回调
            println(it)
        }, {
            //失败的回调
            println(it.message)
        }, {
            //完成的回调
            println("onComplete")
        }, {
            //订阅的回调，可以用来取消当前订阅
            println("subscribe")
        })
（2）第二种观察者模式写法Flowable.subscribe(Subscriver)
### 第一种写法
Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> emitter) throws Exception {
                emitter.onNext("Hello Rxjava2.x");
                //emitter.onError(new Throwable("Hello Rxjava2.x Error"));
                emitter.onComplete();
            }
        }, BackpressureStrategy.BUFFER).subscribe(new FlowableSubscriber<String>() {
            @Override
            public void onSubscribe(Subscription s) {
                //订阅的回调，可以用来取消当前订阅
                System.out.println("subscribe");
            }

            @Override
            public void onNext(String s) {
                //成功的回调
                System.out.println(s);
            }

            @Override
            public void onError(Throwable e) {
                //失败的回调
                System.out.println(e.getMessage());
            }

            @Override
            public void onComplete() {
                //完成的回调
                System.out.println("onComplete");
            }
        });
### 第二种写法
 Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> emitter) throws Exception {
                emitter.onNext("Hello Rxjava2.x");
                //emitter.onError(new Throwable("Hello Rxjava2.x Error"));
                emitter.onComplete();
            }
        }, BackpressureStrategy.BUFFER).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                //成功的回调
                System.out.println(s);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable e) throws Exception {
                //失败的回调
                System.out.println(e.getMessage());
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                //完成的回调
                System.out.println("onComplete");
            }
        }, new Consumer<Subscription>() {
            @Override
            public void accept(Subscription subscription) throws Exception {
                //订阅的回调，可以用来取消当前订阅
                System.out.println("subscribe");
            }
        });

### 对应的Kotlin写法
Flowable.create(FlowableOnSubscribe<String> {
            it.onNext("Hello Rxjava2.x")
            //it.onError(new Throwable("Hello Rxjava2.x Error"));
            it.onComplete()
        }, BackpressureStrategy.BUFFER).subscribe(object : FlowableSubscriber<String> {
            override fun onSubscribe(s: Subscription) {
                //订阅的回调，可以用来取消当前订阅
                println("subscribe")
            }

            override fun onNext(s: String) {
                //成功的回调
                println(s)
            }

            override fun onError(e: Throwable) {
                //失败的回调
                println(e.message)
            }

            override fun onComplete() {
                //完成的回调
                println("onComplete")
            }
        })
Flowable.create(FlowableOnSubscribe<String> {
            it.onNext("Hello Rxjava2.x")
            //it.onError(new Throwable("Hello Rxjava2.x Error"));
            it.onComplete()
        }, BackpressureStrategy.BUFFER).subscribe({ s ->
            //成功的回调
            println(s)
        }, {
            //失败的回调
            println(it.message)
        }, {
            //完成的回调
            println("onComplete")
        }, {
            //订阅的回调，可以用来取消当前订阅
            println("subscribe")
        })
（3）第三种观察者模式写法Single.subscribe(SingleObserver)
### 第一种写法
Single.create(new SingleOnSubscribe<String>() {
            @Override
            public void subscribe(SingleEmitter<String> emitter) throws Exception {
                emitter.onSuccess("Hello Rxjava2.x");
                //emitter.onError(new Throwable("Hello Rxjava2.x Error"));
            }
        }).subscribe(new SingleObserver<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                //订阅的回调，可以用来取消当前订阅
                System.out.println("subscribe");
            }

            @Override
            public void onSuccess(String s) {
                //成功的回调
                System.out.println(s);
            }

            @Override
            public void onError(Throwable e) {
                //失败的回调
                System.out.println(e.getMessage());
            }
        });
### 第二种写法
Single.create(new SingleOnSubscribe<String>() {
            @Override
            public void subscribe(SingleEmitter<String> emitter) throws Exception {
                emitter.onSuccess("Hello Rxjava2.x");
                //emitter.onError(new Throwable("Hello Rxjava2.x Error"));
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                //成功的回调
                System.out.println(s);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable e) throws Exception {
                //失败的回调
                System.out.println(e.getMessage());
            }
        });

### 对应的Kotlin写法
Single.create(SingleOnSubscribe<String> {
            it.onSuccess("Hello Rxjava2.x")
            //it.onError(new Throwable("Hello Rxjava2.x Error"));
        }).subscribe(object : SingleObserver<String> {
            override fun onSubscribe(d: Disposable) {
                //订阅的回调，可以用来取消当前订阅
                println("subscribe")
            }

            override fun onSuccess(s: String) {
                //成功的回调
                println(s)
            }

            override fun onError(e: Throwable) {
                //失败的回调
                println(e.message)
            }
        })
Single.create(SingleOnSubscribe<String> {
            it.onSuccess("Hello Rxjava2.x")
            //it.onError(new Throwable("Hello Rxjava2.x Error"));
        }).subscribe({
            //成功的回调
            println(it)
        }, { 
            //失败的回调
            println(it.message)
        })
（4）第四种观察者模式写法Completable.subscribe(CompletebleObserver)
### 第一种写法
 Completable.create(new CompletableOnSubscribe() {
            @Override
            public void subscribe(CompletableEmitter emitter) throws Exception {
                //emitter.onError(new Throwable("Hello Rxjava2.x Error"));
                emitter.onComplete();
            }
        }).subscribe(new CompletableObserver() {
            @Override
            public void onSubscribe(Disposable d) {
                //订阅的回调，可以用来取消当前订阅
                System.out.println("subscribe");
            }

            @Override
            public void onComplete() {
                //完成的回调
                System.out.println("onComplete");
            }

            @Override
            public void onError(Throwable e) {
                //失败的回调
                System.out.println(e.getMessage());
            }
        });
### 第二种写法
Completable.create(new CompletableOnSubscribe() {
            @Override
            public void subscribe(CompletableEmitter emitter) throws Exception {
                //emitter.onError(new Throwable("Hello Rxjava2.x Error"));
                emitter.onComplete();
            }
        }).subscribe(new Action() {
            @Override
            public void run() throws Exception {
                //完成的回调
                System.out.println("onComplete");
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable e) throws Exception {
                //失败的回调
                System.out.println(e.getMessage());
            }
        });

### 对应的Kotlin写法
Completable.create {
            //it.onError(new Throwable("Hello Rxjava2.x Error"));
            it.onComplete()
        }.subscribe(object : CompletableObserver {
            override fun onSubscribe(d: Disposable) {
                //订阅的回调，可以用来取消当前订阅
                println("subscribe")
            }

            override fun onComplete() {
                //完成的回调
                println("onComplete")
            }

            override fun onError(e: Throwable) {
                //失败的回调
                println(e.message)
            }
        })
Completable.create {
            //it.onError(new Throwable("Hello Rxjava2.x Error"));
            it.onComplete()
        }.subscribe({
            //完成的回调
            println("onComplete")
        }, { 
            //失败的回调
            println(it.message)
        })
（5）第四种观察者模式写法Maybe.subscribe(MaybeObserver)
### 第一种写法
Maybe.create(new MaybeOnSubscribe<String>() {
            @Override
            public void subscribe(MaybeEmitter<String> emitter) throws Exception {
                emitter.onSuccess("Hello Rxjava2.x");
                //emitter.onError(new Throwable("Hello Rxjava2.x Error"));
                emitter.onComplete();
            }
        }).subscribe(new MaybeObserver<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                //订阅的回调，可以用来取消当前订阅
                System.out.println("subscribe");
            }

            @Override
            public void onSuccess(String s) {
                //成功的回调
                System.out.println(s);
            }

            @Override
            public void onError(Throwable e) {
                //失败的回调
                System.out.println(e.getMessage());
            }

            @Override
            public void onComplete() {
                //完成的回调
                System.out.println("onComplete");
            }
        });
 ### 第二种写法
Maybe.create(new MaybeOnSubscribe<String>() {
            @Override
            public void subscribe(MaybeEmitter<String> emitter) throws Exception {
                emitter.onSuccess("Hello Rxjava2.x");
                //emitter.onError(new Throwable("Hello Rxjava2.x Error"));
                emitter.onComplete();
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                //成功的回调
                System.out.println(s);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable e) throws Exception {
                //失败的回调
                System.out.println(e.getMessage());
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                //完成的回调
                System.out.println("onComplete");
            }
        });

### 对应的Kotlin写法
Maybe.create(MaybeOnSubscribe<String> {
            it.onSuccess("Hello Rxjava2.x")
            //it.onError(new Throwable("Hello Rxjava2.x Error"));
            it.onComplete()
        }).subscribe(object : MaybeObserver<String> {
            override fun onSubscribe(d: Disposable) {
                //订阅的回调，可以用来取消当前订阅
                println("subscribe")
            }

            override fun onSuccess(s: String) {
                //成功的回调
                println(s)
            }

            override fun onError(e: Throwable) {
                //失败的回调
                println(e.message)
            }

            override fun onComplete() {
                //完成的回调
                println("onComplete")
            }
        })
Maybe.create(MaybeOnSubscribe<String> {
            it.onSuccess("Hello Rxjava2.x")
            //it.onError(new Throwable("Hello Rxjava2.x Error"));
            it.onComplete()
        }).subscribe({
            //成功的回调
            println(it)
        }, {
            //失败的回调
            println(it.message)
        }, {
            //完成的回调
            println("onComplete")
        })
xing.tang
关注
专栏目录
RxJava3.x入门(七)——背压策略
AthonyDavis的博客
08-02 1360
RxJava3.x入门(七)——背压策略 一、背压简介 上下游在不同的线程中，通过Observable发射，处理，响应数据流时，如果上游发射数据的速度快于下游接收处理数据的速度，这样对于那些没来得及处理的数据就会造成积压，这些数据既不会丢失，也不会被垃圾回收机制回收，而是存放在一个异步缓存池中，如果缓存池中的数据一直得不到处理，越积越多，最后就会造成内存溢出，这便是响应式编程中的背压（backpressure）问题。 背压是指在异步场景中，被观察者发送事件速度远快于观察者的处理速度的情况下，一种告诉上游的被
Android开发之RxJava 2.x
qq_36443441的博客
03-20 267
RxJava是什么 RxJava是一个实现异步操作的库，它可以通过链式调用使代码逻辑变得清晰简洁。它的github地址为： https://github.com/ReactiveX/RxJava https://github.com/ReactiveX/RxAndroid 在项目中可以通过以下方式引入依赖： compile 'io.reactivex.rxjava2:rxjava:2.2.0'...
RxJava2.x的集成
06-30
目前最新版本的rxjava的使用demo，样例写的很具体， 注释很清晰 教程地址 https://blog.csdn.net/KwunYamShan/article/details/80862724
RxJava 2.x使用详解
feather(猎羽)
03-05 1620
RxJava 2.x使用详解 文章目录RxJava 2.x使用详解基本概念新特性两种观察者模式ObservabledoOnNextConsumer线程调度subscribeOnobserveOn线程切换AndroidSchedulers.mainThread()SchedulerSubjectAsyncSubjectBehaviorSubjectPublishSubjectReplaySubjec...
RxJava
最新发布
sanzailmn的博客
07-09 565
RxJava
这可能是最好的RxJava 2.x 教程（完结版）
code_dream_wq的博客
07-04 1020
https://github.com/nanchen2251/RxJava2Examples    例子下载 为什么要学 RxJava？ 提升开发效率，降低维护成本一直是开发团队永恒不变的宗旨。近两年来国内的技术圈子中越来越多的开始提及 RxJava，越来越多的应用和面试中都会有 RxJava ，而就目前的情况，Android 的网络库基本被 Retrofit 
RxJava2.x教程
周先生丶的博客
02-13 317
一、什么是RxJava GitHub地址：https://github.com/ReactiveX/RxJava，有英文能力的小伙伴可以直接从这里入门。 直接照搬GitHub上面的定义： RxJava is a Java VM implementation of Reactive Extensions: a library for composing asynchronous and eve...
RxJava 2.x 入门
Cute_Code的博客
07-28 853
之前只大概了解RxJava,并没在实际的项目中实战过，但最近在研究讯飞语音的一个demo的时候发现，他们都在使用mvvm,dagger2,rxjava2.x, 姿态很优雅，很吸引人，心想，卧槽再不尝试一下就落后了，于是决定在项目中采用这些优秀的框架，与时俱进。在这里记录梳理一下Rxjava2.x 的知识。 RxJava的优点就不多说了，直接接入正题。 1.添加依赖 compile 'io....
RxJava2.x实现定时器的实例代码
08-30
RxJava2.x实现定时器实例代码详解 RxJava2.x是一个基于Reactive Extensions的库，提供了观察者模式的实现，用于处理异步数据流。RxJava2.x相比RxJava1.x具有更好的性能，尤其在背压支持上。本篇文章将详细介绍如何...
这可能是最好的RxJava 2.x 入门教程（一）
刘世麟的博客
06-21 569
一、前言RxJava 对大家而言肯定不陌生，其受欢迎程度不言而喻。而在去年的早些时候，官方便宣布，将在一段时间后不再对 RxJava 1.x 进行维护，而在仓库中另辟蹊径，开始对 RxJava 2.x 进行推广起来，我原本是不想写这么一套教程的，因为 RxJava 受欢迎度这么高，而且这2.x也出来了这么久，我坚信网上一定有很多超级大牛早已为大家避雷。然而很难过的是，我搜索了些时间，能搜出来的基本都
rxjava
凤舞九天的博客
07-08 934
安卓开发之rxjava，rxjava基本概念
RxJava2 使用详解一之基础教程
0729Liang
08-30 1373
目录 一、配置 二、原理 第一步：创建被观察者 第二步：创建观察者 第三步：建立订阅关系 链式操作 ObservableEmitter： Disposable： subscribe()重载方法 下篇：RxJava2 使用详解二之线程调度 一、配置 要在Android中使用RxJava2, 在app的build.gradle中添加依赖： /*导入Rxjava RxAndr...
RxJava 1.x到2.x升级：观察者模式与事件处理详解
在这个文档中，我们主要关注的是RxJava 1.x版本，尽管后来已经发展到了2.x版本，但1.x的原理和概念依然具有参考价值。 **被观察者（Observer）与Observable：** 在RxJava中，一个`Observable`是一个生产数据的源头...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值