【RxJava2.0】基本使用（一）

最新推荐文章于 2024-01-11 17:31:41 发布
最新推荐文章于 2024-01-11 17:31:41 发布
阅读量492 收藏
点赞数 1
分类专栏： Android Android实例 文章标签： RxJava2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013293125/article/details/97687723
版权

文章目录


本文主要参考 这里，因为之前没用过RxJava2.0，最近想学习学习，这位大神写得很不错，但是光看看难以记牢，就自己敲文字加代码加强记忆。

RxJava2已经出来很久了，网上的博客很多，现在RxJava3都出来了，本文算是学习笔记。

1 Gradle配置

要在Android中使用RxJava2，先添加Gradle配置：

    implementation 'io.reactivex.rxjava2:rxjava:2.0.1'
    implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'

2 基本原理

借用Season_zlc的管道原理来讲解。用两根水管代替观察者和被观察者，将从事件流这个角度来说明RxJava的基本工作原理。

先假设有两根水管：
在这里插入图片描述
上面一根水管为事件产生的水管，叫它上游，下面一根水管为事件接收的水管叫它下游吧。两根水管通过一定的方式连接起来，使得上游每产生一个事件，下游就能收到该事件。

这里的上游和下游就分别对应着RxJava中的Observable和Observer，它们之间的连接就对应着subscribe()，因此这个关系用RxJava来表示就是：

package com.example.rxjava2demo;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "[MainActivity]";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        loadData();
    }

    private void loadData(){
        //创建一个上游 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);
    }
}

运行结果

07-29 23:21:32.549 6129-6129/com.example.rxjava2demo D/[MainActivity]: subscribe
07-29 23:21:32.549 6129-6129/com.example.rxjava2demo D/[MainActivity]: 1
07-29 23:21:32.549 6129-6129/com.example.rxjava2demo D/[MainActivity]: 2
07-29 23:21:32.549 6129-6129/com.example.rxjava2demo D/[MainActivity]: 3
07-29 23:21:32.549 6129-6129/com.example.rxjava2demo D/[MainActivity]: complete

只有当上游和下游建立连接之后, 上游才会开始发送事件. 也就是调用了subscribe() 方法之后才开始发送事件，该代码还可以进行链式操作：

package com.example.rxjava2demo;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "[MainActivity]";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        loadData();
    }

    private void loadData(){
        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();
            }
        }).subscribe(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");
            }
        });
    }
}

3 ObservableEmitter和Disposable

ObservableEmitter：是用来发出事件的，它可以发出三种类型的事件，通过调用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分别发出next事件、complete事件和error事件。

但是，发送的事件需要满足一定的规则：

  • 上游可以发送无限个onNext, 下游也可以接收无限个onNext.
  • 当上游发送了一个onComplete后, 上游onComplete之后的事件将会继续发送, 而下游收到onComplete事件之后将不再继续接收事件.
  • 当上游发送了一个onError后, 上游onError之后的事件将继续发送, 而下游收到onError事件之后将不再继续接收事件.
  • 上游可以不发送onComplete或onError.
  • 最为关键的是onComplete和onError必须唯一并且互斥, 即不能发多个onComplete, 也不能发多个onError, 也不能先发一个onComplete, 然后再发一个onError, 反之亦然

关于onComplete和onError唯一并且互斥这一点, 是需要自行在代码中进行控制, 如果你的代码逻辑中违背了这个规则, **并不一定会导致程序崩溃. ** 比如发送多个onComplete是可以正常运行的, 依然是收到第一个onComplete就不再接收了, 但若是发送多个onError, 则收到第二个onError事件会导致程序会崩溃.

Disposable： 这个单词的字面意思是一次性用品,用完即可丢弃的，对应于上面的水管的例子, 我们可以把它理解成两根管道之间的一个机关, 当调用它的dispose()方法时, 它就会将两根管道切断, 从而导致下游收不到事件。

关于Disposable，如下例子，我们让上游依次发送1,2,3,complete,4,在下游收到第二个事件之后, 切断水管

package com.example.rxjava2demo;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "[MainActivity]";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        loadData();
    }

    private void loadData(){
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<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();
                Log.d(TAG, "emit 4");
                emitter.onNext(4);
            }
        }).subscribe(new Observer<Integer>() {
            private Disposable mDisposable;
            private int i;

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "subscribe");
                mDisposable = d;
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "onNext: " + value);
                i++;
                if (i == 2) {
                    Log.d(TAG, "dispose");
                    mDisposable.dispose();
                    Log.d(TAG, "isDisposed : " + mDisposable.isDisposed());
                }
            }

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

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

结果：

07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: subscribe
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: emit 1
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: onNext: 1
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: emit 2
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: onNext: 2
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: dispose
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: isDisposed : true
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: emit 3
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: emit complete
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: emit 4

从运行结果我们看到, 在收到onNext 2这个事件后, 切断了水管, 但是上游仍然发送了3, complete, 4这几个事件, 而且上游并没有因为发送了onComplete而停止. 同时可以看到下游的onSubscribe()方法是最先调用的。

另外, subscribe()有多个重载的方法:

 	public final Disposable subscribe() {}
    public final Disposable subscribe(Consumer<? super T> onNext) {}
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {} 
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}
    public final void subscribe(Observer<? super T> observer) {}

带一个参数的写法如下所示，其它可以仿照此写法即可：

        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<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();
                Log.d(TAG, "emit 4");
                emitter.onNext(4);
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "onNext: " + integer);
            }
        });
It一zhai男
关注
专栏目录
RxJava2.0使用指南
程序员光剑
10-14 286
RxJava (Reactive Extensions) 是 ReactiveX （Reactive Extensions） 的 Java 版本实现。它提供了很多类似于 LINQ 的高阶函数和操作符，可用于处理异步数据流、事件流和基于回调的编程模式。虽然它的名字叫做 RxJava ，但是实际上，它不是一个独立的项目，而是由微软在.Net 框架中实现并开源发布的一组扩展库，包括 C#、F# 和 Visual Basic。
Android RxJava第一弹之原理详解、使用详解、常用场景（基于Rxjava2.0）
qq_28195645的博客
09-17 9207
Android RxJava第一弹之原理详解、使用详解、常用场景（基于Rxjava2.0） Android RxJava第二弹之RxJava封装库 RxJava+Animation RxJava+Glide Android RxJava第三弹之RxJava2.0尝鲜本人参考以下文章给 Android 开发者的 RxJava 详解—扔物线Rxjava 2.0 与 Rxjava 1.0有什么不同
RxJava 2.0学习文档
06-29
RxJava 2.0的基本概念，使用方法，网络请求步骤，自己使用过程中经常使用的部分，适合初用者
RxJava的使用与深入学习
evan_man的专栏
05-01 1万+
转载请注明出处：http://blog.csdn.net/evan_man 简单介绍     可以将RxJava是一种观察者设计模式的升级版本。使用Rxjava的好处在于，我们可以方便的切换方法的执行线程，对线程动态切换，该过程无需我们自己手动创建和启动线程。使用Rxjava创建的代码虽然出现在同一个线程中，但是我们可以设置使得不同方法在不同线程中执行。上述功能的实现主要归功于RxJava
Carson带你学Android：手把手带你入门神秘的Rxjava
热门推荐
Carson带你学Android
10-09 3万+
前言 Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。本文主要：面向 刚接触Rxjava的初学者 提供了一份 清晰、简洁、易懂的Rxjava入门教程 涵盖 基本介绍、原理 & 具体使用等解决的是初学者不理解Rxjava原理 & 不懂得如何使用的问题 希望你们会喜欢。 本文主要基于Rxjava 2.0 如果读者还没学习过Rx
RxJava2.0——从放弃到入门
weixin_34087503的博客
04-02 173
前言 终于到了讲RxJava这一期，RxJava是笔者个人非常喜欢的一个开源库，它很好的将链式编程风格和异步结合在一起。RxJava其实已经推出很久了，可以说是已经很火了，但是目前仍然还有相当一部分Android开发者没有使用过，甚至说是想用，却不知道怎么用，或者不知道自己的项目哪里可以用到，本着让广大开发者...
RxJava的使用
qq_40447795的博客
12-07 291
1、github网址：https://github.com/ReactiveX/RxJava 2、添加依赖： implementation "io.reactivex.rxjava3:rxjava:3.x.y" 3、使用方法： Observable.create(new ObservableOnSubscribe<Object>() { @Override public void subscribe(ObservableEmitter&
RxJava2.0在android开发中的实用总结
12-05
RxJava 2.0与RxJava 1.0在基本思想上保持一致，但是对架构进行了全面重设计。它改变了依赖仓库的地址和包名，两者互不兼容，不能共存。由于RxJava 1.0即将停止维护，推荐开发者尽快迁移到RxJava 2.0。对于RxJava的...
安卓开发框架工具类相关-eclipse版本的Rxjava2.0dome.rar
07-29
《安卓开发框架工具类：Eclipse版RxJava2.0实战指南》 在安卓应用开发中，框架工具类起着至关重要的作用，它们能够帮助开发者更高效、更便捷地完成复杂的任务。其中，RxJava是一个备受瞩目的响应式编程库，它引入了...
【RxJava】使用
yang553566463的博客
01-22 1095
虽说Rxjava显然已经有些过时了，但是有些公司还在使用，为了能适应更多的业务代码，并提高自己的开发效率，所以这里仅做个Rxjava使用的总结，不涉及Rxjava内部的实现原理。 RxJava的核心就是异步数据流和响应式编程。 我们平时开发过程中的网络请求、数据库读写、文件读写、定时任务等各种耗时操作，都可以使用RxJava来完成。 在平时的开发中，我们可以把所有的事件（数据）我们都可以看成是一条河流，它可以被观察，被过滤等操作，也可以将多条河流汇合成一条新河流。
RxJava
04-01 1114
RxJava 简单实用 来源：http://blog.csdn.net/qq_35064774/article/details/53057332 1、app build.gradle中添加 dependencies { compile 'io.reactivex.rxjava2:rxjava:2.0.0' compile 'org.reactivestreams:rea
android——rxjava的使用(连续多个弹窗的处理)
最新发布
wy313622821的博客
01-11 2919
本文介绍项目开发中使用到rxjava的情形，以及详细的代码。RxJava是一个基于Java语言的Reactive Extensions库，它用于实现异步编程和流式处理，通过将事件和数据流以数据序列的形式进行处理，提高了代码的可读性和可维护性。
RxJava 使用及思想1
qq_44076155的博客
12-06 153
Rx 思维：响应式编程 生活中的例子： 起点（分发事件(PATH)：我饿了）----------下楼-------去餐厅--------点餐----------> 终点（吃饭 消费事件） 程序中的例子： 起点（分发事件：点击登录）----------登录API-------请求服务器--------获取响应码----------> 终点（更新UI登录成功 消费事件） Rx思维，从一个点（生产事件，需要处理的事件，对象）开始，中间可以使用各种操作符不断对这个点进行处理操作，进行完所.
RxJava的简单使用
Jannolan的博客
09-08 607
为什么要用RxJava
RxJava基本使用
子孟的博客
03-16 307
RxJava定义： RxJava 在 GitHub 的介绍： RxJava：a library for composing asynchronous and event-based programs using observable sequences for the Java VM // 翻译：RxJava 是一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库 ...
Android开发之RxJava使用
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
11-11 2337
RxJava是响应式编程，也可以理解为流式编程，核心是观察者模式。Rx是微软.Net的一个响应式扩展，Rx借助可观测的序列提供一种简单的方式来创建异步的，基于事件驱动的程序。2012年Netflix为了应对不断增长的业务需求开始将.NET Rx迁移到JVM上面。并于13年二月份正式向外展示了RxJava。使用RxJava可以是编程更加简洁、易懂，避免出现回调地狱。
RxJava应用
肇秋贰拾捌的博客
05-19 517
【代码】RxJava应用。
RxJava2.0——入门教程
Errol's Blog
11-24 744
文章目录观察者模式RxJava 基本使用 观察者模式 简单介绍一下，A和B两个，A是被观察者，B是观察者，B对A进行观察，B并不是需要时刻盯着A，而是A如果发生了变化，会主动通知B，B会对应做一些变化。举个例子，假设A是连载小说，B是读者，读者订阅了连载小说，当小说出现了新的连载的时候，会推送给读者。读者不用时刻盯着小说连载，而小说有了新的连载会主动推送给读者。这就是观察者模式。而RxJava正是基于观察者模式开发的 RxJava 基本使用 首先引入RxJava2.0相关的类库 implementatio
RxJava学习之基本使用
老胡
10-30 1505
欢迎访问我的个人独立博客 ittiger.cn，原创文章，未经允许不得随意转载。RxJava现在在Android开发中越来越流行，作为一个Android开发者我也必须紧跟步伐学习学习RxJava，这篇文章就记录了RxJava`中我认为比较常用的一些场景。也给大伙推荐篇比较好的RxJava文章 * 给 Android 开发者的 RxJava 详解RxJava基础大家都知道JDK中提供了观察者模式的实
RxJava2.0在Android开发中的实战与源码解析
"RxJava2.0在Android开发中的实用经验分享，包括操作符的总结和源码分析，以及与RxJava1.0的关系" 在Android开发中，...无论是对于个人技能提升还是团队协作效率，掌握RxJava2.0都是Android开发者的必备技能之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值