RxJava 基本介绍

最新推荐文章于 2024-05-15 16:56:07 发布
最新推荐文章于 2024-05-15 16:56:07 发布
阅读量491 收藏
点赞数
分类专栏： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tiger10100/article/details/94383000
版权

RxJava

Rxjava 介绍

RxJava是ReactiveX(反应性扩展)的Java VM实现:一个库，用于使用可观察序列组合异步和基于事件的程序。

RxJava 起步

Gradle 集成

compile 'io.reactivex.rxjava2:rxjava:2.2.0'

RxJava 的使用

先看一个简单demo：

相关代码如下：

public class RxJavaUse {
    public static String TAG = RxJavaUse.class.getSimpleName();
    public static void hello(String... args){
        Disposable subscribe = Flowable.fromArray(args).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i(TAG, "accept:Hello "+ s);
            }
        });
    }
}

执行调用：

 RxJavaUse.hello(new String[]{"RxJava","is","Used"});

结果输出

2019-06-29 10:05:06.785 5158-5158/com.union.rxjava I/RxJavaUse: accept:Hello RxJava
2019-06-29 10:05:06.785 5158-5158/com.union.rxjava I/RxJavaUse: accept:Hello is
2019-06-29 10:05:06.786 5158-5158/com.union.rxjava I/RxJavaUse: accept:Hello Use

创建被观察者：

创建一个被观察者，你可以使用create() 方法，你也可以根据已有的数据去创建

1、根据已有的数据创建被观察者

使用 just(),from 方法 转换对象

   public static void createObservable(){
        String  data [] = {"this","is","RxJava","demo"};
        Observable<ArrayList> just = Observable.just(new ArrayList());
        Observable<String[]> dataArray = Observable.just(data);
        Observable<String> stringObservable = Observable.fromArray();
    }
2、create()方法创建被观察者

demo1、

 public static void createObservableByNone(){
        Observable<String> objectObservable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("hello");
                emitter.onNext("World");
            }
        });
        objectObservable.subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i(TAG, "accept:Hello "+ s);
            }
        });
    }

方法调用：

 RxJavaUse.createObservableByNone();

输出结果：

2019-06-29 11:01:18.905 23009-23009/com.union.rxjava I/RxJavaUse: accept:Hello hello
2019-06-29 11:01:18.906 23009-23009/com.union.rxjava I/RxJavaUse: accept:Hello World

demo2：

  public static void createObservableByNone(){
        Observable<String> objectObservable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("hello");
                emitter.onNext("World");
            }
        });
        objectObservable.subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

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

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, "onError "+ e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.i(TAG, "onComplete ");
            }
        });
    }

方法调用：

RxJavaUse.createObservableByNone();

输出结果：

2019-06-29 11:03:06.931 23871-23871/com.union.rxjava I/RxJavaUse: onNext hello
2019-06-29 11:03:06.931 23871-23871/com.union.rxjava I/RxJavaUse: onNext World
3、使用操作符

skip(10)跳过前 10 条

take(5) 获取下五条数据

map 进行数据变换

 public static void createObservableSkip(){
        Observable<String> stringObservable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("value1");
                emitter.onNext("value2");
                emitter.onNext("value3");
                emitter.onNext("value4");
                emitter.onNext("value5");
                emitter.onNext("value6");
                emitter.onNext("value7");
                emitter.onNext("value8");
                emitter.onNext("value9");
                emitter.onNext("value10");
                emitter.onNext("value11");
                emitter.onNext("value12");
                emitter.onNext("value13");
                emitter.onNext("value14");
                emitter.onNext("value15");
                emitter.onNext("value16");
                emitter.onNext("value17");
            }
        });
         stringObservable.skip(10).take(5).map(new Function<String, String>() {
            @Override
            public String apply(String s) throws Exception {
                return s+"skip_take";
            }
        }).subscribe(new Observer<String>() {
             @Override
             public void onSubscribe(Disposable d) {
                 Log.i(TAG, "onSubscribe");
             }

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

             @Override
             public void onError(Throwable e) {
                 Log.i(TAG, "onError "+ e.getMessage());
             }

             @Override
             public void onComplete() {
                 Log.i(TAG, "onComplete");
             }
         });
    }

方法调用：

RxJavaUse.createObservableSkip();

结果输出：

2019-06-29 11:14:42.474 7359-7359/com.union.rxjava I/RxJavaUse: onSubscribe
2019-06-29 11:14:42.474 7359-7359/com.union.rxjava I/RxJavaUse: onNext value11skip_take
2019-06-29 11:14:42.474 7359-7359/com.union.rxjava I/RxJavaUse: onNext value12skip_take
2019-06-29 11:14:42.475 7359-7359/com.union.rxjava I/RxJavaUse: onNext value13skip_take
2019-06-29 11:14:42.475 7359-7359/com.union.rxjava I/RxJavaUse: onNext value14skip_take
2019-06-29 11:14:42.475 7359-7359/com.union.rxjava I/RxJavaUse: onNext value15skip_take
2019-06-29 11:14:42.475 7359-7359/com.union.rxjava I/RxJavaUse: onComplete

响应流（Reactive Streams + RxJava）

响应流是一项协作工作，旨在标准化JVM上异步流的协议。RxJava团队从一开始就是工作的一部分，并支持使用响应流api，最终支持Java 9流api，这是响应流工作成功的结果。

RxJava 2。x将直接针对Java 8+的反应流api。该计划还将支持Java 9 j.u.c。在使用RxJava 2时，通过利用新的Java多版本jar来支持流类型。x在Java 9中，同时还在Java 8中工作。

RxJava 2将真正成为“反应性扩展”，因为现在有一个接口需要扩展。RxJava 1没有要扩展的基本接口或契约，因此必须从头定义它。RxJava 2的目标是成为高性能、经过战斗测试的轻量级(对响应流的单一依赖)、响应流和j.u.c的非自定义实现。流，它提供具有参数化并发性的高阶函数库。

Rx1转换响应流代码：

public abstract class RxReactiveStreams {
    abstract <T> Publisher<T> toPublisher(Observable<T> observable) ;

    abstract <T> Observable<T> toObservable(Publisher<T> publisher);
}

反应流和流发布器接口不提供任何操作符的实现，比如flatMap、merge、filter、take、zip和许多其他用于组合和转换异步流的操作符。发布者只能订阅。需要像RxJava这样的具体实现来提供组合。

RxJava和Akka Streams一直是十分优秀的响应流实现库。

Rx2：响应流代码：

 public io.reactivex.Observable getValue(String key);

Scheduler

用来切换线程

demo:

 public static void scheduler(){
        Observable.create(new ObservableOnSubscribe<Object>() {
            @Override
            public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
                emitter.onNext("hello");
                Log.i(TAG, " subscribe -ThreadName "+ Thread.currentThread().getName());
            }
        }).subscribeOn(Schedulers.newThread()).doOnSubscribe(new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                Log.i(TAG, "accept - ThreadName "+ Thread.currentThread().getName());
            }
        }).subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object o) throws Exception {
                Log.i(TAG, "ThreadName "+ Thread.currentThread().getName());
            }
        });
    }

控制台输出结果：

2019-07-01 10:27:25.776 27711-27711/com.union.rxjava I/RxJavaUse: accept - ThreadName main
2019-07-01 10:27:25.779 27711-27753/com.union.rxjava I/RxJavaUse: ThreadName RxNewThreadScheduler-1
2019-07-01 10:27:25.779 27711-27753/com.union.rxjava I/RxJavaUse:  subscribe -ThreadName RxNewThreadScheduler-1

Subject

Subject可以看成是一个桥梁或者代理，在某些ReactiveX实现中（如RxJava），它同时充当了Observer和Observable的角色。因为它是一个Observer，它可以订阅一个或多个Observable；又因为它是一个Observable，它可以转发它收到(Observe)的数据，也可以发射新的数据。

由于一个Subject订阅一个Observable，它可以触发这个Observable开始发射数据（如果那个Observable是”冷”的–就是说，它等待有订阅才开始发射数据）。因此有这样的效果，Subject可以把原来那个”冷”的Observable变成”热”的。

Subject的种类

针对不同的场景一共有四种类型的Subject。他们并不是在所有的实现中全部都存在，而且一些实现使用其它的命名约定（例如，在RxScala中Subject被称作PublishSubject）

1、AsyncSubject

一个AsyncSubject只在原始Observable完成后，发射来自原始Observable的最后一个值。（如果原始Observable没有发射任何值，AsyncObject也不发射任何值）它会把这最后一个值发射给任何后续的观察者。

然而，如果原始的Observable因为发生了错误而终止，AsyncSubject将不会发射任何数据，只是简单的向前传递这个错误通知。

2、BehaviorSubject

当观察者订阅BehaviorSubject时

  • 它开始发射订阅原始Observable前，发射的最后一个数据（如果此时还没有收到任何数据，它会发射一个默认值），
  • 然后继续发射任何来自原始Observable的数据。

然而，如果原始的Observable因为发生了一个错误而终止，BehaviorSubject将不会发射任何数据，只是简单的向前传递这个错误通知。

3、PublishSubject

PublishSubject只会把在订阅发生的时间点之后来自原始Observable的数据发射给观察者。需要注意的是，PublishSubject可能会一创建完成就立刻开始发射数据（除非你可以阻止它发生），因此这里有一个风险：在Subject被创建后到有观察者订阅它之前这个时间段内，一个或多个数据可能会丢失。如果要确保来自原始Observable的所有数据都被分发，你需要这样做：或者使用Create创建那个Observable以便手动给它引入”冷”Observable的行为（当所有观察者都已经订阅时才开始发射数据），或者改用ReplaySubject。

如果原始的Observable因为发生了一个错误而终止，PublishSubject将不会发射任何数据，只是简单的向前传递这个错误通知。

4、ReplaySubject

ReplaySubject会发射所有来自原始Observable的数据给观察者，无论它们是何时订阅的。也有其它版本的ReplaySubject，在重放缓存增长到一定大小的时候或过了一段时间后会丢弃旧的数据（原始Observable发射的

如果你把ReplaySubject当作一个观察者使用，注意不要从多个线程中调用它的onNext方法（包括其它的on系列方法），这可能导致同时（非顺序）调用，这会违反Observable协议，给Subject的结果增加了不确定性。

RxJava的对应类

假设你有一个Subject，你想把它传递给其它的代理或者暴露它的Subscriber接口，你可以调用它的asObservable方法，这个方法返回一个Observable。具体使用方法可以参考Javadoc文档。

串行化

如果你把 Subject 当作一个 Subscriber 使用，注意不要从多个线程中调用它的onNext方法（包括其它的on系列方法），这可能导致同时（非顺序）调用，这会违反Observable协议，给Subject的结果增加了不确定性。

要避免此类问题，你可以将 Subject 转换为一个 SerializedSubject ，类似于这样：

mySafeSubject = new SerializedSubject( myUnsafeSubject );
醉相逢
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxJava之七——RxJava 2.0 图文分析create()、 subscribe()、map()、observeOn()、subscribeOn()源码
薛瑄的博客
05-19 1846
Rxjava的使用流程，相信大家都很清楚了，就是 以下面这个简单的demo，重点分析一下map()、observeOn()、subscribeOn()源码 Observable.create(object : ObservableOnSubscribe<Int> { override fun subscribe(emitter: ObservableEmitter<Int>) { }}) .map
RxJava详解
weixin_40387773的博客
03-20 3810
1. Schedulers.io(): I/O 操作（读写文件、数据库、网络请求等），与newThread()差不多，区别在于io() 的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 效率比 newThread() 更高。传统的嵌套请求，一般都是在前一个请求的 onSuccess() 回调里面发起新的请求，这样一旦嵌套多个的话，缩进就是大问题了，而且严重的影响代码的可读性。为什么需要返回值呢？不难发现，上述的 map 操作符，是一对一的变换，并且返回的是变换后的对象。
RxJava介绍及基本原理
极客专栏
10-11 992
RxJava是ReactiveX家族的重要一员,ReactiveX是的缩写，一般简写为Rx。ReactiveX官方给RxRx是一个使用可观察数据流进行异步编程的编程接口。ReactiveX不仅仅是一个编程接口，它是一种编程思想的突破，它影响了许多其它的程序库和框架以及编程语言。它拓展了观察者模式，使你能够自由组合多个异步事件，而不需要去关心线程同步，线程安全并发数据以及I/O阻塞。RxJava在Java环境下使用，它通过Observable（可观测对象）和Subscriber（订阅者）来实现异步编程模型。
2024年安卓最全详细的 RxJava 学习攻略 & 指南(5)，2024年最新腾讯字节等大厂面试真题汇总
最新发布
2401_84520150的博客
05-15 333
我希望通过我自己的学习方法来帮助大家去提升技术：1、多看书、看源码和做项目，平时多种总结2、不能停留在一些基本api的使用上，应该往更深层次的方向去研究，比如activity、view的内部运行机制，比如Android内存优化，比如aidl，比如JNI等，并不仅仅停留在会用，而要通过阅读源码，理解其实现原理3、同时对架构是有一定要求的，架构是抽象的，但是设计模式是具体的，所以一定要加强下设计模式的学习。
RxJava2源码分析——Map操作符
07-23 313
本文章用的RxJava和RxAndroid版本如下： implementation 'io.reactivex.rxjava2:rxjava:2.2.6' implementation 'io.reactivex.rxjava2:rxandroid:2.1.1' 复制代码 我们先写段示例代码，为了方便理解，在调用map方法的时候，我就不用上Lambda和链式调用了，代码如下： Observable.create((ObservableOnSubscribe<Integer>) emit
RxJava入门之介绍与基本运用
09-01
对于Android开发者来说，当有一天打开技术论坛、博客满屏都是各种Rx的时候，心里是很慌的。所以趁着现在跟着小编通过这篇文章先来简单认识下RxJava，以及RxJava的基本运用。对这感兴趣的朋友下面来一起看看吧。
RxJava的简单介绍Demo
05-17
[Android]RxJava的简单介绍和基本使用(二)：retrofit2的简单介绍.博文测试代码，下载须谨慎，原文链接：http://blog.csdn.net/jan_s/article/details/70576992
Rxjava2最新视频教程
08-10
RxJava2 视频教程目录： 1.观察者模式理论篇.mp4 2.观察者模式动手篇.mp4 3.课程大纲介绍.mp4 4.基本使用.mp4 5.线程控制.mp4 6.操作符介绍.mp4 7.登录后获取用户信息.mp4 8.关键词搜索案例.mp4 9.防止按钮重复点击...
Retrofit+Rxjava实现文件上传和下载功能
08-28
它们可以结合使用来实现文件上传和下载功能，下面我们来详细介绍如何使用 Retrofit+Rxjava 实现文件上传和下载功能。 Retrofit 介绍 Retrofit 是一个基于 OkHttp 的网络请求框架，由 Square 公司推出。 OkHttp ...
史上超详细的RxJava2使用和RxLifecycle生命周期管理，解决RxJava内存泄漏
chuyouyinghe的专栏
02-07 1451
这篇文章基于RxJava2.0 RxJava是什么？ 官网说RxJava是一个可观测的序列来组成异步的额，基于事件的库，简单来说，它就是一个实现异步的库，可以代替Android的API如AsyncTask ，Handler等等。 RxJava为什么好？ RxJava其实就是提供一套异步编程的API，这套API是基于观察者模式的，而且是链式调用的，所以使用RxJava编写的代码逻辑会非常简洁。 观察者模式： 定义：对象间一种一对多的关系，使得每当一个对象改变，则所有依赖于它的对象都会得到通知并被自动更新
RxJava讲解视频
11-09
里面有百度云盘的视频下载地址。用五节课让你对RxJava有一个全面的认识。
1. RxJava概述
NorthStar的博客
07-30 669
RxJava概述
给 Android 开发者的 RxJava 详解
weixin_34204722的博客
10-12 734
2019独角兽企业重金招聘Python工程师标准>>> ...
深入浅出RxJava就这一篇就够了
热门推荐
比较喜欢、笑的博客专栏
07-13 4万+
前言： 第一次接触RxJava是在前不久，一个新Android项目的启动，在评估时选择了RxJava。RxJava是一个基于事件订阅的异步执行的一个类库。听起来有点复杂，其实是要你使用过一次，就会大概明白它是怎么回事了！为是什么一个Android项目启动会联系到RxJava呢？因为在RxJava使用起来得到广泛的认可，又是基于Java语言的。自然会有善于组织和总结的开发者联想到Android！没
Java响应式(反应式)编程——RxJava
OneFine的技术博客
03-21 9636
响应式编程是一种基于异步数据流概念的编程模式
RxJava使用介绍-概念
Dream It Possible
05-23 7785
RxJava系列教程：1. RxJava使用介绍 【视频教程】 2. RxJava操作符   • Creating Observables(Observable的创建操作符) 【视频教程】   • Transforming Observables(Observable的转换操作符) 【视频教程】   • Filtering Observables(Observable的过滤操
千道Java面试真题整理系列：微服务灵魂五十问，助你吊打面试官！
aixuexidemomo的博客
11-26 1927
1、您对微服务有何了解？ 微服务：又称微服务 架构，是一种架构风格，它将应用程序构建为以业务领域为模型的小型自治服务集合 。 通俗地说，你必须看到蜜蜂如何通过对齐六角形蜡细胞来构建它们的蜂窝状物。他们最初从使用各种材料的小部分开始，并继续从中构建一个大型蜂箱。这些细胞形成图案，产生坚固的结构，将蜂窝的特定部分固定在一起。这里，每个细胞独立于另一个细胞，但它也与其他细胞相关。这意味着对一个细胞的损...
android rxjava
11-11
Android中的RxJava是一个流行的响应式编程库，它使得异步数据流的处理变得更加简单和高效。RxJava基于观察者模式，可以轻松地处理异步...但是一旦掌握了RxJava的基本用法，将会大大提高Android应用的开发效率和质量。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值