Android:这是一篇 清晰 易懂的Rxjava 入门教程

作者:Carson_Ho

地址:http://www.jianshu.com/p/a406b94f3188

声明:本文是Carson_Ho原创,已获其授权发布,未经原作者允许请勿转载

前言

  • Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点,深受各大 Android开发者的欢迎。

本文主要:

1、面向 刚接触Rxjava的初学者

2、提供了一份 清晰、简洁、易懂的Rxjava入门教程

3、解决的是初学者不理解Rxjava原理 & 不懂得如何使用的问题

希望你们会喜欢

1、本文主要基于Rxjava 2.0

2、如果读者还没学习过Rxjava 1.0也没关系,因为Rxjava 2.0只是在Rxjava 1.0上增加了一些新特性,本质原理 & 使用基本相同

3、接下来的时间,我将持续推出 Android中 Rxjava 2.0 的一系列文章,包括原理、操作符、应用场景、背压等等 ,有兴趣可以继续关注Carson_Ho的安卓开发笔记!!

目录

定义

  • RxJavaGitHub 的介绍:

RxJava:a library for composing asynchronous and event-based programs using observable sequences for the Java VM

// 翻译:RxJava 是一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库

  • 总结:RxJava 是一个 基于事件流、实现异步操作的库

作用

实现异步操作

类似于 Android中的 AsyncTaskHandler作用

由于 RxJava的使用方式是:基于事件流的链式调用,所以使得 RxJava

  • 逻辑简洁
  • 实现优雅
  • 使用简单

更重要的是,随着程序逻辑的复杂性提高,它依然能够保持简洁 & 优雅

原理

4.1 生活例子引入

  • 我用一个生活例子引入 & 讲解 Rxjava原理: 顾客到饭店吃饭

4.2 Rxjava原理介绍

  • Rxjava原理 基于 一种扩展的观察者模式
  • Rxjava的扩展观察者模式中有4个角色:

角色

作用

类比

被观察者(Observable)

产生事件

顾客

观察者(Observer)

接收事件,并给出响应动作

厨房

订阅(Subscribe)

连接 被观察者 & 观察者

服务员

事件(Event)

被观察者 & 观察者 沟通的载体

菜式

  • 具体原理

请结合上述 顾客到饭店吃饭 的生活例子理解:

RxJava原理可总结为:被观察者 (Observable) 通过 订阅(Subscribe) 按顺序发送事件 给观察者 (Observer), 观察者(Observer) 按顺序接收事件 & 作出对应的响应动作。具体如下图:

至此,RxJava原理讲解完毕。

基本使用

  • 本文只关注 RxJava的基本使用,更深入的RxJava使用请继续关注Carson_Ho的安卓开发笔记
  • Rxjava的使用方式有两种:
    1. 分步骤实现:该方法主要为了深入说明Rxjava的原理 & 使用,主要用于演示说明
    2. 基于事件流的链式调用:主要用于实际使用

5.1 方式1:分步骤实现

5.1.1 使用步骤

5.1.2 步骤详解

步骤1:创建被观察者 (Observable )& 生产事件
  • 即 顾客入饭店 - 坐下餐桌 - 点菜
  • 具体实现

// 1. 创建被观察者 Observable 对象

Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() { // create() 是 RxJava 最基本的创造事件序列的方法 // 此处传入了一个 OnSubscribe 对象参数 // 当 Observable 被订阅时,OnSubscribe 的 call() 方法会自动被调用,即事件序列就会依照设定依次被触发 // 即观察者会依次调用对应事件的复写方法从而响应事件 // 从而实现被观察者调用了观察者的回调方法 & 由被观察者向观察者的事件传递,即观察者模式 // 2. 在复写的subscribe()里定义需要发送的事件 @Override public void subscribe(ObservableEmitter<Integer> emitter) throws Exception { // 通过 ObservableEmitter类对象产生事件并通知观察者 // ObservableEmitter类介绍 // a. 定义:事件发射器 // b. 作用:定义需要发送的事件 & 向观察者发送事件 emitter.onNext(1); emitter.onNext(2); emitter.onNext(3); emitter.onComplete(); } }); <--扩展:RxJava 提供了其他方法用于 创建被观察者对象Observable --> // 方法1:just(T...):直接将传入的参数依次发送出来 Observable observable = Observable.just("A", "B", "C"); // 将会依次调用: // onNext("A"); // onNext("B"); // onNext("C"); // onCompleted(); // 方法2:from(T[]) / from(Iterable<? extends T>) : 将传入的数组 / Iterable 拆分成具体对象后,依次发送出来 String[] words = {"A", "B", "C"}; Observable observable = Observable.from(words); // 将会依次调用: // onNext("A"); // onNext("B"); // onNext("C"); // onCompleted();

步骤2:创建观察者 (Observer )并 定义响应事件的行为
  • 即 开厨房 - 确定对应菜式
  • 发生的事件类型包括:Next事件、Complete事件 & Error事件。具体如下:
  • 具体实现 <--方式1:采用Observer 接口 --> // 1. 创建观察者 (Observer )对象 Observer<Integer> observer = new Observer<Integer>() { // 2. 创建对象时通过对应复写对应事件方法 从而 响应对应事件 // 观察者接收事件前,默认最先调用复写 onSubscribe() @Override public void onSubscribe(Disposable d) { Log.d(TAG, "开始采用subscribe连接"); } // 当被观察者生产Next事件 & 观察者接收到时,会调用该复写方法 进行响应 @Override public void onNext(Integer value) { Log.d(TAG, "对Next事件作出响应" + value); } // 当被观察者生产Error事件& 观察者接收到时,会调用该复写方法 进行响应 @Override public void onError(Throwable e) { Log.d(TAG, "对Error事件作出响应"); } // 当被观察者生产Complete事件& 观察者接收到时,会调用该复写方法 进行响应 @Override public void onComplete() { Log.d(TAG, "对Complete事件作出响应"); } }; <--方式2:采用Subscriber 抽象类 --> // 说明:Subscriber类 = RxJava 内置的一个实现了 Observer 的抽象类,对 Observer 接口进行了扩展 // 1. 创建观察者 (Observer )对象 Subscriber<String> subscriber = new Subscriber<Integer>() { // 2. 创建对象时通过对应复写对应事件方法 从而 响应对应事件 // 观察者接收事件前,默认最先调用复写 onSubscribe() @Override public void onSubscribe(Subscription s) { Log.d(TAG, "开始采用subscribe连接"); } // 当被观察者生产Next事件 & 观察者接收到时,会调用该复写方法 进行响应 @Override public void onNext(Integer value) { Log.d(TAG, "对Next事件作出响应" + value); } // 当被观察者生产Error事件& 观察者接收到时,会调用该复写方法 进行响应 @Override public void onError(Throwable e) { Log.d(TAG, "对Error事件作出响应"); } // 当被观察者生产Complete事件& 观察者接收到时,会调用该复写方法 进行响应 @Override public void onComplete() { Log.d(TAG, "对Complete事件作出响应"); } }; <--特别注意:2种方法的区别,即Subscriber 抽象类与Observer 接口的区别 --> // 相同点:二者基本使用方式完全一致(实质上,在RxJava的 subscribe 过程中,Observer总是会先被转换成Subscriber再使用) // 不同点:Subscriber抽象类对 Observer 接口进行了扩展,新增了两个方法: // 1. onStart():在还未响应事件前调用,用于做一些初始化工作 // 2. unsubscribe():用于取消订阅。在该方法被调用后,观察者将不再接收 & 响应事件 // 调用该方法前,先使用 isUnsubscribed() 判断状态,确定被观察者Observable是否还持有观察者Subscriber的引用,如果引用不能及时释放,就会出现内存泄露 Subscribe 即 顾客找到服务员 - 点菜 - 服务员下单到厨房 - 厨房烹调 具体实现 observable.subscribe(observer); // 或者 observable.subscribe(subscriber); 扩展说明 <-- Observable.subscribe(Subscriber) 的内部实现 --> public Subscription subscribe(Subscriber subscriber) { subscriber.onStart(); // 步骤1中 观察者 subscriber抽象类复写的方法,用于初始化工作 onSubscribe.call(subscriber); // 通过该调用,从而回调观察者中的对应方法从而响应被观察者生产的事件 // 从而实现被观察者调用了观察者的回调方法 & 由被观察者向观察者的事件传递,即观察者模式 // 同时也看出:Observable只是生产事件,真正的发送事件是在它被订阅的时候,即当 subscribe() 方法执行时 }

5.2 方式2:优雅的实现方法 - 基于事件流的链式调用

  • 上述的实现方式是为了说明Rxjava的原理 & 使用
  • 在实际应用中,会将上述步骤&代码连在一起,从而更加简洁、更加优雅,即所谓的 RxJava基于事件流的链式调用

// RxJava的链式操作

Observable.create(new ObservableOnSubscribe<Integer>() { // 1. 创建被观察者 & 生产事件 @Override public void subscribe(ObservableEmitter<Integer> emitter) throws Exception { emitter.onNext(1); emitter.onNext(2); emitter.onNext(3); emitter.onComplete(); } }).subscribe(new Observer<Integer>() { // 2. 通过通过订阅(subscribe)连接观察者和被观察者 // 3. 创建观察者 & 定义响应事件的行为 @Override public void onSubscribe(Disposable d) { Log.d(TAG, "开始采用subscribe连接"); } // 默认最先调用复写的 onSubscribe() @Override public void onNext(Integer value) { Log.d(TAG, "对Next事件"+ value +"作出响应" ); } @Override public void onError(Throwable e) { Log.d(TAG, "对Error事件作出响应"); } @Override public void onComplete() { Log.d(TAG, "对Complete事件作出响应"); } }); } } 注:整体方法调用顺序:观察者.onSubscribe()> 被观察者.subscribe()> 观察者.onNext()>观察者.onComplete()

这种 基于事件流的链式调用,使得RxJava

  • 逻辑简洁
  • 实现优雅
  • 使用简单

更重要的是,随着程序逻辑的复杂性提高,它依然能够保持简洁 & 优雅。所以,一般建议使用这种基于事件流的链式调用方式实现RxJava

特别注意

RxJava 2.x 提供了多个函数式接口 ,用于实现简便式的观察者模式。具体如下:

Consumer为例:实现简便式的观察者模式

Observable.just("hello").subscribe(new Consumer<String>() {

// 每次接收到Observable的事件都会调用Consumer.accept() @Override public void accept(String s) throws Exception { System.out.println(s); } });

我将用一个实际工程实例来演示 Rxjava的使用

实例说明

6.1 方式1:分步骤实现

步骤1:加入依赖

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

compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

步骤2:直接在MainActivity.java中实现下述步骤

  1. 创建被观察者 (Observable )& 生产事件
  2. 创建观察者 (Observer )并 定义响应事件的行为
  3. 通过订阅(Subscribe)连接观察者和被观察者 public class MainActivity extends AppCompatActivity { private static final String TAG = "Rxjava"; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // 步骤1:创建被观察者 Observable & 生产事件 // 即 顾客入饭店 - 坐下餐桌 - 点菜 // 1. 创建被观察者 Observable 对象 Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() { // 2. 在复写的subscribe()里定义需要发送的事件 @Override public void subscribe(ObservableEmitter<Integer> emitter) throws Exception { // 通过 ObservableEmitter类对象产生事件并通知观察者 // ObservableEmitter类介绍 // a. 定义:事件发射器 // b. 作用:定义需要发送的事件 & 向观察者发送事件 emitter.onNext(1); emitter.onNext(2); emitter.onNext(3); emitter.onComplete(); } }); // 步骤2:创建观察者 Observer 并 定义响应事件行为 // 即 开厨房 - 确定对应菜式 Observer<Integer> observer = new Observer<Integer>() { // 通过复写对应方法来 响应 被观察者 @Override public void onSubscribe(Disposable d) { Log.d(TAG, "开始采用subscribe连接"); } // 默认最先调用复写的 onSubscribe() @Override public void onNext(Integer value) { Log.d(TAG, "对Next事件"+ value +"作出响应" ); } @Override public void onError(Throwable e) { Log.d(TAG, "对Error事件作出响应"); } @Override public void onComplete() { Log.d(TAG, "对Complete事件作出响应"); } }; // 步骤3:通过订阅(subscribe)连接观察者和被观察者 // 即 顾客找到服务员 - 点菜 - 服务员下单到厨房 - 厨房烹调 observable.subscribe(observer);
  • 测试结果

6.2 方式2:基于事件流的链式调用方式

public class MainActivity extends AppCompatActivity {

private static final String TAG = "Rxjava"; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // RxJava的流式操作 Observable.create(new ObservableOnSubscribe<Integer>() { // 1. 创建被观察者 & 生产事件 @Override public void subscribe(ObservableEmitter<Integer> emitter) throws Exception { emitter.onNext(1); emitter.onNext(2); emitter.onNext(3); emitter.onComplete(); } }).subscribe(new Observer<Integer>() { // 2. 通过通过订阅(subscribe)连接观察者和被观察者 // 3. 创建观察者 & 定义响应事件的行为 @Override public void onSubscribe(Disposable d) { Log.d(TAG, "开始采用subscribe连接"); } // 默认最先调用复写的 onSubscribe() @Override public void onNext(Integer value) { Log.d(TAG, "对Next事件"+ value +"作出响应" ); } @Override public void onError(Throwable e) { Log.d(TAG, "对Error事件作出响应"); } @Override public void onComplete() { Log.d(TAG, "对Complete事件作出响应"); } }); } }

  • 测试效果 实现效果同上
  • Demo 下载地址 Carson_Ho的Github地址 = RxJava2系列:基础使用:https://github.com/Carson-Ho/RxJava_Operators

喜欢的麻烦点个star

额外说明

7.1 观察者 Observer的subscribe()具备多个重载的方法

public final Disposable subscribe() {}

// 表示观察者不对被观察者发送的事件作出任何响应(但被观察者还是可以继续发送事件) public final Disposable subscribe(Consumer<? super T> onNext) {} // 表示观察者只对被观察者发送的Next事件作出响应 public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {} // 表示观察者只对被观察者发送的Next事件 & Error事件作出响应 public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {} // 表示观察者只对被观察者发送的Next事件、Error事件 & Complete事件作出响应 public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {} // 表示观察者只对被观察者发送的Next事件、Error事件 、Complete事件 & onSubscribe事件作出响应 public final void subscribe(Observer<? super T> observer) {} // 表示观察者对被观察者发送的任何事件都作出响应

7.2 可采用 Disposable.dispose() 切断观察者 与 被观察者 之间的连接

  • 即观察者 无法继续 接收 被观察者的事件,但被观察者还是可以继续发送事件
  • 具体使用 // 主要在观察者 Observer中 实现 Observer<Integer> observer = new Observer<Integer>() { // 1. 定义Disposable类变量 private Disposable mDisposable; @Override public void onSubscribe(Disposable d) { Log.d(TAG, "开始采用subscribe连接"); // 2. 对Disposable类变量赋值 mDisposable = d; } @Override public void onNext(Integer value) { Log.d(TAG, "对Next事件"+ value +"作出响应" ); if (value == 2) { // 设置在接收到第二个事件后切断观察者和被观察者的连接 mDisposable.dispose(); Log.d(TAG, "已经切断了连接:" + mDisposable.isDisposed()); } } @Override public void onError(Throwable e) { Log.d(TAG, "对Error事件作出响应"); } @Override public void onComplete() { Log.d(TAG, "对Complete事件作出响应"); } };
  • 效果图
  • 本文主要对 Rxjava 的入门知识进行讲解,包括基本介绍、原理 & 具体使用等
  • 接下来,我将持续推出 AndroidRxjava 2.0 的一系列文章,包括原理、操作符、应用场景、背压等等 ,有兴趣可以继续关注Carson_Ho的安卓开发笔记!!

原文发布于微信公众号 - Android先生(cyg_24kshign)

原文发表时间:2017-10-31

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Android先生

RxJava2 实战知识梳理(5) - 简单及进阶的轮询操作

今天,我们介绍一种新的场景,轮询操作。也就是说,我们会尝试间隔一段时间就向服务器发起一次请求,在使用RxJava之前,该需求的实现一般有两种方式:

24420
来自专栏非著名程序员

这是一篇清晰易懂的 Rxjava 入门教程

? 原文作者:Carson_Ho 原文地址:http://www.jianshu.com/p/a406b94f3188 特别声明:本文为Carson_Ho原创...

1.2K60
来自专栏三流程序员的挣扎

RxJava Single Completable Maybe 使用和源码阅读

Single 用于只发射一次数据就结束了,所以无需通过 onComplete 通知观察者,要么 onSuccess 要么 onError。

23620
来自专栏刘晓杰

retrofit的使用

366140
来自专栏流媒体

Android RTMP推流之MediaCodec硬编码一(H.264进行flv封装)

在前面Android平台下使用FFmpeg进行RTMP推流(摄像头推流)的文章中,介绍了如何使用FFmpeg进行H264编码和Rtmp推流。接下来讲分几篇文章来...

93130
来自专栏好好学java的技术栈

java实现手机短信验证全过程

55530
来自专栏码字搬砖

kafka权限认证

背景: 最近公司因为用的云服务器,需要保证kafka的安全性。可喜的是kafka0.9开始,已经支持权限控制了。网上中文资料又少,特此基于kafka0.9,...

66730
来自专栏QQ空间开发团队的专栏

RxJava && Agera 从源码简要分析基本调用流程(1)

相信很多做Android或是Java研发的同学对RxJava应该都早有耳闻了,尤其是在Android开发的圈子里,RxJava渐渐开始广为流行。同样有很多同学已...

8.6K10
来自专栏酷玩时刻

Android版-微信APP支付

服务端源码地址:http://git.oschina.net/javen205/weixin_guide 客户端源码地址:https://github.com...

1.2K20
来自专栏代码GG之家

RxAndroid完全教程

不知现在的编辑,能否好用一些呢?希望大家有什么意见,在公众号直接回复即可,想了解哪些知识点,也可以直接留言了。 炎炎夏日,清凉一夏 这章节主要介绍下Rx系列的经...

32790

扫码关注云+社区

领取腾讯云代金券