RxJava原理探究

最新推荐文章于 2024-08-21 01:00:00 发布
最新推荐文章于 2024-08-21 01:00:00 发布
阅读量426 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012366540/article/details/103805303
版权

前言
Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。
在这里插入图片描述

本文主要：
面向 刚接触Rxjava的初学者
提供了一份 清晰、简洁、易懂的Rxjava入门教程
涵盖 基本介绍、原理 & 具体使用等

解决的是初学者不理解Rxjava原理 & 不懂得如何使用的问题
希望你们会喜欢。

本文主要基于Rxjava 2.0
如果读者还没学习过Rxjava 1.0也没关系，因为Rxjava 2.0只是在Rxjava 1.0上增加了一些新特性，本质原理 & 使用基本相同
接下来的时间，我将持续推出 Android中 Rxjava 2.0 的一系列文章，包括原理、操作符、应用场景、背压等等 ，有兴趣可以继续关注Carson_Ho的安卓开发笔记！！
在这里插入图片描述

示意图
目录
在这里插入图片描述

示意图

  1. 定义
    RxJava 在 GitHub 的介绍：
    RxJava：a library for composing asynchronous and event-based programs using observable sequences for the Java VM
    // 翻译：RxJava 是一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库
    1
    2
    1
    2
    总结：RxJava 是一个 基于事件流、实现异步操作的库
  2. 作用
    实现异步操作

类似于 Android中的 AsyncTask 、Handler作用

  1. 特点
    由于 RxJava的使用方式是：基于事件流的链式调用，所以使得 RxJava：

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

  1. 原理
    4.1 生活例子引入
    我用一个生活例子引入 & 讲解 Rxjava原理： 顾客到饭店吃饭
    在这里插入图片描述

示意图
在这里插入图片描述

流程图
4.2 Rxjava原理介绍
Rxjava原理 基于 一种扩展的观察者模式

Rxjava的扩展观察者模式中有4个角色：

角色 作用 类比
被观察者（Observable） 产生事件 顾客
观察者（Observer） 接收事件，并给出响应动作 厨房
订阅（Subscribe） 连接 被观察者 & 观察者 服务员
事件（Event） 被观察者 & 观察者 沟通的载体 菜式
具体原理
请结合上述 顾客到饭店吃饭 的生活例子理解：
在这里插入图片描述

示意图
在这里插入图片描述

流程图
即RxJava原理可总结为：被观察者 （Observable） 通过 订阅（Subscribe） 按顺序发送事件 给观察者 （Observer）， 观察者（Observer） 按顺序接收事件 & 作出对应的响应动作。具体如下图：

在这里插入图片描述

示意图
至此，RxJava原理讲解完毕。

  1. 基本使用
    本文只关注 RxJava的基本使用，更深入的RxJava使用请继续关注Carson_Ho的RxJava系列
    Rxjava的使用方式有两种：
    分步骤实现：该方法主要为了深入说明Rxjava的原理 & 使用，主要用于演示说明
    基于事件流的链式调用：主要用于实际使用
    5.1 方式1：分步骤实现
    5.1.1 使用步骤

在这里插入图片描述

示意图
**

5.1.2 步骤详解

**
步骤1：创建被观察者 （Observable ）& 生产事件
即 顾客入饭店 - 坐下餐桌 - 点菜
具体实现
// 1. 创建被观察者 Observable 对象
Observable observable = Observable.create(new ObservableOnSubscribe() {
// 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的引用，如果引用不能及时释放，就会出现内存泄露
步骤3：通过订阅（Subscribe）连接观察者和被观察者
即 顾客找到服务员 - 点菜 - 服务员下单到厨房 - 厨房烹调
具体实现

observable.subscribe(observer);
 // 或者 observable.subscribe(subscriber)；
 
扩展说明
<-- Observable.subscribe(Subscriber) 的内部实现 -->
 
public Subscription subscribe(Subscriber subscriber) {
subscriber.onStart();

// 步骤1中 观察者 subscriber抽象类复写的方法，用于初始化工作
onSubscribe.call(subscriber);
// 通过该调用，从而回调观察者中的对应方法从而响应被观察者生产的事件
// 从而实现被观察者调用了观察者的回调方法 & 由被观察者向观察者的事件传递，即观察者模式
// 同时也看出：Observable只是生产事件，真正的发送事件是在它被订阅的时候，即当 subscribe() 方法执行时
}
<–方式2：采用Subscriber 抽象类 -->
// 说明：Subscriber类 = RxJava 内置的一个实现了 Observer 的抽象类，对 Observer 接口进行了扩展

// 1. 创建观察者 （Observer ）对象
Subscriber subscriber = new Subscriber() {

// 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的引用，如果引用不能及时释放，就会出现内存泄露
步骤3：通过订阅（Subscribe）连接观察者和被观察者
即 顾客找到服务员 - 点菜 - 服务员下单到厨房 - 厨房烹调
具体实现
observable.subscribe(observer);
// 或者 observable.subscribe(subscriber)；

扩展说明
<-- Observable.subscribe(Subscriber) 的内部实现 -->
1
1
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);
            }
        });
  1. 实例说明
    我将用一个实际工程实例来演示 Rxjava的使用

6.1 方式1：分步骤实现
步骤1：加入依赖

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




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

创建被观察者 （Observable ）& 生产事件
创建观察者 （Observer ）并 定义响应事件的行为
通过订阅（Subscribe）连接观察者和被观察者

```java
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 observable = Observable.create(new ObservableOnSubscribe() {
// 2. 在复写的subscribe（）里定义需要发送的事件
@Override
public void subscribe(ObservableEmitter 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() {

    // 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事件作出响应");
            }
        });
    }
}
 
 // 步骤3：通过订阅（subscribe）连接观察者和被观察者
// 即 顾客找到服务员 - 点菜 - 服务员下单到厨房 - 厨房烹调
observable.subscribe(observer);

测试效果
实现效果同上
在这里插入图片描述

在这里插入图片描述

示意图
Demo 下载地址
Carson_Ho的Github地址 = RxJava2系列：基础使用

喜欢的麻烦点个star！

  1. 额外说明
    7.1 被观察者 Observable的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事件作出响应");
            }
        };

效果图

在这里插入图片描述

示意图
8. 总结
本文主要对 Rxjava 的入门知识进行讲解，包括基本介绍、原理 & 具体使用等
接下来，我将持续推出 Android中 Rxjava 2.0 的一系列文章，包括原理、操作符、应用场景、背压等等

在这里插入图片描述

示意图

王墨予
关注
Java 的 RxJava 库高级进阶：刨根问底的深度解析
java专栏
08-25 392
好了，我们已经一起探索了 RxJava 的一些高级概念，包括热观察者、错误处理和背压。通过这些示例代码，我们不仅了解了 RxJava 的基本用法，还深入到了一些高级技巧。希望这篇文章能够帮助你在 RxJava 的旅途中更进一步！🌟。
RxJava 入门详解
一名互联网时代苟且偷生的 Android码农
05-13 486
RxJava——入门篇一、ReactiveX简介二、RxJava的使用1、RxJava的优势2、RxJava的配置三、RxJava的不完整回调1、不完整回调的代码示例2、不完整回调的原理分析四、RxJava的线程切换1、Scheduler线程调度器2、线程控制五、总结 一、ReactiveX简介 在学习RxJava前首先需要了解ReactiveX，因为RxJava是ReactiveX的一种Java的实现形式。 ReactiveX的官网地址为：ReactiveX的官网 ReactiveX官网对于自身的介绍是：
RxJava 入门
Mr.傅的专栏
11-11 908
原文地址：RxJava 入门 翻译原文：Getting Started with RxJava and Android 什么是 ReactiveX？ReactiveX 是一个专注于异步编程与控制可观察数据（或者事件）流的API。它组合了观察者模式，迭代器模式和函数式编程的优秀思想。实时数据处理是一件普通的现象，有一个高效、干净和可扩展的方式来处理这些情景是重要的。使用 Observable
RxJava入门指南
东子的博客 细节决定成败，点滴铸就辉煌。
03-21 2608
RxJava是 ReactiveX 在JVM上的一个实现，ReactiveX使用Observable序列组合异步和基于事件的程序。更多关于ReactiveX的资料，可以查看 ReactiveX 介绍 页面。RxJava介绍RxJava 是轻量级的RxJava尽力做到非常轻巧。它仅关注Observable的抽象和与之相关的高层函数，实现为一个单独的JAR文件。RxJava 是一个多语言实现RxJava
Rxjava：基础入门
MagicSound的博客
08-29 742
Rxjava基于事件流、实现异步操作。采用Observer接口实现Log . d("main" , "开始采用subscribe连接");Log . d("main" , "对Error事件作出响应");} };
Rxjava入门与基础内容
baidu_24743861的博客
01-07 874
RxJava2.0与RxJava3.0 差异化。2.基础相关的资料与博客。
深入探究rxJava在Java应用程序中的应用实例
rxJava 是一个基于Reactive Extensions (响应式扩展)原理的Java编程库，它允许开发者能够以声明式的方式编写异步和基于事件的程序，从而极大地简化了在Java虚拟机上处理异步操作和事件驱动程序的复杂性。Reactive ...
[Android+JetPack] (Java实现) Retrofit2+RxJava3+Paging3+RecyclerView 实现加载网络数据例子 记录
iOSTianNan的博客
04-13 1797
1.完成一个无限上拉加载的列表(Paging3 + RecicleView)2.加载的是网络数据, 要采用主流的 Retrofit+okhttp方式3.在了解了RxJava之后,也希望用上Rxjava4.用到ViewModel来配合,以及一些jetpack的东西都用上(为什么不用Paging2?这里主要是看说3比2还要方便些,所以就偷懒没去用Paging2以上就是这样了.SmartRefreshLayout 也可以结合Paging3这个有空也看一下,
深入探究withObservables源码实现原理
这种模式广泛应用于前端框架（如RxJS、ReactiveUI），以及后端服务（如***、RxJava）。 3. RxJS（Reactive Extensions for JavaScript）：这是一个使用可观察序列来编写异步和基于事件的程序库。RxJS为JavaScript...
给初学者的RxJava2.0教程（一）：【入门】
飞渡浮舟
02-04 734
CSDN转载地址：http://blog.csdn.net/qq_23179075/article/details/79255971 作者：Season_zlc 链接：https://www.jianshu.com/p/464fa025229e 來源：简书 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 前言 上个月RxJav
Java Reactor 入门指南
最新发布
java专栏
08-21 403
通过以上的步骤，我们已经了解了如何使用Reactor来执行基本的异步操作。Reactor是一个非常强大的工具，支持多种复杂的异步场景。你可以根据需要添加更多的功能，以满足各种并发需求。希望这篇俏皮可爱的指南对你有所帮助，如果你还有任何疑问，欢迎随时留言哦！😊注意：上面的代码示例是为了教学目的而编写的，实际使用时请根据你的项目环境进行适当的调整。为了给这次的学习之旅增添一点趣味，这里有一张俏皮可爱的程序员正在编写Reactor。
RxJava
SammeryD的博客
01-01 448
RXJAVA笔记
RxJava入门
不止于代码
06-29 700
参考文档RxJava-Android开发_Essentials中文翻译版_官方中文版-Android文档类资源-CSDN下载包含：Android开发-RxJava详解.pdf（偏向于Android开发的指导）RxJava Essentials_中文翻译版.pdf（国外大牛Ivan.Morgillo编写的RxJava教程）RxJava官方中文文档.pdf（比较全面，包含所有操作符的说明）1 RxJava基本介绍1.1 概念 RxJava是采用响应式编程思想的异步操作框架，设计初衷是让异步编程变得
RXJava入门
HIMan
06-06 899
现在RXJava可谓是赤手可热，没接触过的同学见了RXJava风格代码会不会吐槽？“TMD这个是什么？和屎一样”哈哈，我初次见反正吐槽了，看不明白什么意思，但是经过了解以后看到了它的魅力，简直是代码中的宋仲基啊。帅的一逼。首先感谢抛物线大大谢了这么好的文章，供我们充分了解RXJava，原谅博主的愚笨看了好多遍,千万不要嘲笑朕，所以做一个笔记我们一起交流。 ….博主总结的或许还是不是那么容易全, 但
RxJava的简单入门
一头暴走的次果子
02-24 376
RxJava的简单入门
rxjava的入门
打工仔的博客
03-31 82
https://www.jianshu.com/p/a406b94f3188 【传送门】(https://www.jianshu.com/p/a406b94f3188)
RXJava原理
luweicheng24的博客
12-09 846
RXJava简单理解首先，rxjava是什么？其实对于刚接触rxjava的宝宝而言，只需要掌握两点： 观察者模式 异步处理 观察上图，清楚生动刻画出了rxjava的观察者模式： 开关(被观察者)作为的是事件的产生方（产生“on”和“off”这两个 Event），有它发起这起开关的事件。 台灯（观察者）作为事件的处理方（处理的是“on”和“off”这两个事件），被动的执行on和off。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值