RxJava 之 create操作符 源码解析

最新推荐文章于 2024-05-03 12:23:04 发布
原创 最新推荐文章于 2024-05-03 12:23:04 发布 · 606 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#RxJava #create操作符 #RxJava源码解析

深入探讨RxJava2中create操作符的工作原理，包括其内部实现机制、关键方法调用流程以及与其他组件如ObservableEmitter、Disposable接口的交互。

转载请以链接形式标明出处：
本文出自:103style的博客

本文基于 RxJava 2.x 版本

create操作符例子：
Observable
        .create(new ObservableOnSubscribe<Object>() {
            @Override
            public void subscribe(ObservableEmitter<Object> emitter) throws Exception {

            }
        })
        .subscribe(new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Object o) {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

首先我们看create 方法:

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
    ObjectHelper.requireNonNull(source, "source is null");
    return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}

RxJavaPlugins 类的 onAssembly 方法：

static volatile Function<? super Observable, ? extends Observable> onObservableAssembly;

public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
    Function<? super Observable, ? extends Observable> f = onObservableAssembly;
    if (f != null) {
        return apply(f, source);
    }
    return source;
}

在源码中查看引用可知 onObservableAssembly 只有在测试的时候才不为 null。
所以Observable.create(ObservableOnSubscribe<T> source)实际上就是返回了 ObservableCreate对象

ObservableCreate 类，可以看到 ObservableCreate 是 Observable 的子类，并实现了父类的 subscribeActual 方法。

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }

    @Override
    protected void subscribeActual(Observer<? super T> observer) {...}
    ...
}

然后我们看subscribe方法: 实际上是调用了 Observable 的抽象方法 subscribeActual(observer);

public final void subscribe(Observer<? super T> observer) {
    ...
    subscribeActual(observer);
    ...
}

protected abstract void subscribeActual(Observer<? super T> observer);

又因为 create操作符返回的 ObservableCreate 是 Observable 的子类，
所以实际上调用的是ObservableCreate 的 subscribeActual(observer);

具体可阅读 Observable subscribe流程介绍

ObservableCreate 的 subscribeActual(observer)方法：

@Override
protected void subscribeActual(Observer<? super T> observer) {
    CreateEmitter<T> parent = new CreateEmitter<T>(observer);
    observer.onSubscribe(parent);

    try {
        source.subscribe(parent);
    } catch (Throwable ex) {
        Exceptions.throwIfFatal(ex);
        parent.onError(ex);
    }
}
  • 首先创建了 CreateEmitter对象，
  • 然后调用了 subscribe 方法传进来的 Observer 对象的 onSubscribe() 方法
  • 然后调用了create 操作符 传进来的 ObservableOnSubscribe 对象的 subscribe(ObservableEmitter<T> emitter)方法

因为 CreateEmitter 类实现了 ObservableEmitter<T> 和 Disposable 接口，
所以我们可以在 create 操作符 传进来的 ObservableOnSubscribe 对象的 subscribe(ObservableEmitter<T> emitter)方法里调用onNext、onError、onComplete等方法。

static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
    ...
    final Observer<? super T> observer;

    CreateEmitter(Observer<? super T> observer) {
        this.observer = observer;
    }
    ...
}

ObservableEmitter 接口：

public interface ObservableEmitter<T> extends Emitter<T> {
    void setDisposable(@Nullable Disposable d);
    void setCancellable(@Nullable Cancellable c);
    boolean isDisposed();
    ObservableEmitter<T> serialize();
    boolean tryOnError(@NonNull Throwable t);
}

public interface Emitter<T> {
    void onNext(@NonNull T value);
    void onError(@NonNull Throwable error);
    void onComplete();
}

Disposable 接口：

public interface Disposable {
    void dispose();
    boolean isDisposed();
}

因为CreateEmitter 又重写了onNext、onError、onComplete等方法。
所以 create 操作符 传进来的 ObservableOnSubscribe 对象的 subscribe(ObservableEmitter<T> emitter)方法里调用onNext、onError、onComplete等方法实际上调用了 CreateEmitter 的 onNext、onError、onComplete等方法。

CreateEmitter 的 onNext、onError、onComplete方法：

    @Override
    public void onNext(T t) {
        if (t == null) {
            onError(new NullPointerException("..."));
            return;
        }
        if (!isDisposed()) {
            observer.onNext(t);
        }
    }

    @Override
    public void onError(Throwable t) {
        if (!tryOnError(t)) {
            RxJavaPlugins.onError(t);
        }
    }

    @Override
    public boolean tryOnError(Throwable t) {
        if (t == null) {
            t = new NullPointerException("...");
        }
        if (!isDisposed()) {
            try {
                observer.onError(t);
            } finally {
                dispose();
            }
            return true;
        }
        return false;
    }

    @Override
    public void onComplete() {
        if (!isDisposed()) {
            try {
                observer.onComplete();
            } finally {
                dispose();
            }
        }
    }
  • 对onNext、onError传进来的值做了空判断。
  • 如果 !isDisposed() 则继续执行 observer 对象的 onNext、onError、onComplete等方法。
    ( observer 对象为 create操作符 之后的 subscribe()方法传进来的 Observer<T> 对象)
  • 并在 onComplete 和 onError 方法最后执行 dispose() 方法。

接下来我们来看 CreateEmitter 的 dispose() 和 isDisposed()方法

    @Override
    public void dispose() {
        DisposableHelper.dispose(this);
    }

    @Override
    public boolean isDisposed() {
        return DisposableHelper.isDisposed(get());
    }

继续看 get()方法，看下面代码可知 get() 返回的是一个 Disposable 对象

static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {...}


public class AtomicReference<V> implements Serializable {
    private volatile V value;

    public AtomicReference(V var1) {
        this.value = var1;
    }

    public AtomicReference() {
    }

    public final V get() {
        return this.value;
    }

继续看 DisposableHelper 的 isDisposed(Disposable d) 和 dispose(AtomicReference<Disposable> field)方法：

public enum DisposableHelper implements Disposable {
    /**
     * The singleton instance representing a terminal, disposed state, don't leak it.
     */
    DISPOSED
    ;

    public static boolean isDisposed(Disposable d) {
        return d == DISPOSED;
    }
    ...
    public static boolean dispose(AtomicReference<Disposable> field) {
        Disposable current = field.get();
        Disposable d = DISPOSED;
        if (current != d) {
            current = field.getAndSet(d);
            if (current != d) {
                if (current != null) {
                    current.dispose();
                }
                return true;
            }
        }
        return false;
    }
    ...
}
  • isDisposed(Disposable d) 则是判断 d 是否和枚举值 DISPOSED 相等。
  • dispose(AtomicReference<Disposable> field) 方法即是 将 CreateEmitter 的 isDisposed() 中调用 get() 获取的对象赋值为 DisposableHelper 的枚举值 DISPOSED 。
    所以调用dispose(AtomicReference<Disposable> field)方法后， isDisposed(Disposable d)即返回true。

CreateEmitter 的 setDisposable(Disposable d) 和 setCancellable(Cancellable c)：

static final class CreateEmitter<T> 
        extends AtomicReference<Disposable>
        implements ObservableEmitter<T>, Disposable {
    ...
    @Override
    public void setDisposable(Disposable d) {
        DisposableHelper.set(this, d);
    }
    ...
    @Override
    public void setCancellable(Cancellable c) {
        setDisposable(new CancellableDisposable(c));
    }
    ...
}

get()方法返回的 Disposable需要在 setDisposable 或者 setCancellable 设置。
所以如果没有调用这两个方法，get()方法返回的值为 null。

所以 isDisposed(Disposable d) 为 true.

dispose(AtomicReference<Disposable> field) 方法中因为 current 为 null, 所以直接返回 false。

如果我们在create操作符中调用了 setDisposable 或者 setCancellable 方法，如下：

Observable
        .create(new ObservableOnSubscribe<Object>() {
            @Override
            public void subscribe(ObservableEmitter<Object> emitter) throws Exception {
                emitter.setCancellable(new Cancellable() {
                    @Override
                    public void cancel() throws Exception {}
                });
                 //or
                emitter.setDisposable(new Disposable() {
                    @Override
                    public void dispose() { }

                    @Override
                    public boolean isDisposed() {
                        return false;
                    }
                }); 
            }
        })
        .subscribe(new Observer<Object>() {...});

emitter.setCancellable 最后也是调用了 setDisposable(new CancellableDisposable(c)); 方法。
所以emitter.setDisposable or emitter.setCancellable 都是通过 DisposableHelper.set(this, d); 去赋值 CreateEmitter 中的 value 值，我们可以通过 上述的get()获取。

DisposableHelper.set(this, d)：

public static boolean set(AtomicReference<Disposable> field, Disposable d) {
    for (;;) {
        Disposable current = field.get();  
        if (current == DISPOSED) {
            if (d != null) {
                d.dispose();
            }
            return false;
        }
        if (field.compareAndSet(current, d)) {
            if (current != null) {
                current.dispose();
            }
            return true;
        }
    }
}

  • 首先获取当前的 value值 current, 由上面的分析我们得知 默认为 null。
    所以直接走到 field.compareAndSet(current, d)，表示更新 CreateEmitter 的 value 为 d ，返回 true则表示 传递的参数 current 和 d 值 not equal。
    又因为current 为 null。所以直接 return true。

  • 当我们调用了 setDisposable 或者 setCancellable之后， 再次调用 setDisposable 或者 setCancellable。
    此时 current 的值则不为 null。
    如果在此之前调用过 dispose()方法，则 current 即为 DISPOSED。所以再次 setDisposable 则无效。
    否则 比较 当前的 value 是否和 d 相等，如果不相等 field.compareAndSet(current, d)则返回 true，更新 CreateEmitter 的 value 为 d，并释放 current。

所以我们多次调用 setDisposable 或者 setCancellable ，如果中间没有调用 dispose(); ，后一次设置会覆盖前面一次设置，最后有效的为最后一次设置。

以上

参考文章
【RxJava】Observable.create()链式编程下释放资源或状态
资深全栈开发工程师
06-15 1401
在 RxJava 中，方法用于创建一个新的 Observable 对象。这个方法需要一个对象作为参数，用于定义 Observable 的行为。对象通常会包含一些资源或状态，例如网络连接、文件句柄、线程等。因此，当 Observable 不再需要时，需要手动释放这些资源或状态，以避免内存泄漏或资源浪费的问题。要释放dispose()Observable需要注意的是，在使用方法创建 Observable 对象时，需要确保正确释放所有资源，以避免内存泄漏或资源浪费的问题。
Rxjava源码分析&实践（八）【源码环节：Rxjava 常见创建操作符原理解析】
itbird的专栏
01-04 1054
总体来说， Rxjava的常见操作符分为创建操作符、转换操作符、过滤操作符、合并操作符、 条件操作符、功能操作符.我们常见的创建型操作符有 create、 just 、fromArray、interval、range 、timer。 1.2 源码 我们看一下create函数源码 看到包装为了ObservableCreate对象，继续看一下 source是上游的observable，也就是我们刚开始调用函数的crreate中创建的对象 所以这里绕回到开头，也就是走到订阅流的 ObservableOnSubsc
RxJava2.0-Observable原理分析之Create操作符
热门推荐
fengluoye2012的博客
01-24 2万+
简介 RxJava一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库；扩展了观察者模式以支持数据/事件的序列，并添加操作符，允许您以声明的方式组合序列，同时抽象出对诸如低层次线程、同步、线程安全和conc等问题的关注。 相关的入门的介绍有很多，可参考https://www.jianshu.com/p/15b2f3d7141a系列的文章介绍的非常全面；这篇文章的主要介绍相...
RxJava操作符——Observable.create
野猿新一
02-17 9286
使用 通过Observable.create()方法传入一个Observable.OnSubscribe对象来创建Observable Observable.create(new Observable.OnSubscribe<String>() { @Override public void call(Subscriber<? super String&gt...
create操作符
zhuxuliao的专栏
05-28 710
Create操作符1. 作用 创建一个简单的Observable对象，当observer订阅到此Observable时产生订阅关系，该订阅关系又Subscription对象管理（即取消订阅）。当Observer和Observable之间产生订阅关系时，OnSubscribe对象的call方法被回调执行一些操作，在call方法结束之前需要显示调用subscriber.next()和subscrib
操作符 ---- create
Joker_z的博客
06-02 221
create 最基本的创造类操作符, 基本使用方法 Observable.create(new ObservableOnSubscribe&lt;String&gt;() { @Override public void subscribe(ObservableEmitter&lt;String&gt; emitter) throws Exc...
RxJava2极速入门——Rxjava操作符详解之创建操作符
易庞宙的博客
03-22 1229
目录 RxJava操作符——创建操作符 create操作符 defer操作符 from操作符 fromArray操作符 fromIterable操作符 fromFuture操作符 interval操作符 just操作符 range操作符 repeat操作符 repeat操作符分析 repeatWhen操作符 repeatUntil操作符 timer操作符 empty...
Android之Rxjava2-源码解析
最新发布
2401_84003733的博客
05-03 657
各行各样都会淘汰一些能力差的，不仅仅是IT这个行业，所以，不要被程序猿是吃青春饭等等这类话题所吓倒，也不要觉得，找到一份工作，就享受安逸的生活，你在安逸的同时，别人正在奋力的向前跑，这样与别人的差距也就会越来越遥远，加油，希望，我们每一个人，成为更好的自己。BAT大厂面试题、独家面试工具包,资料包括 数据结构、Kotlin、计算机网络、Framework源码、数据结构与算法、小程序、NDK、Flutter《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》点击传送门，即可获取！
RxJava2 Flowable 静态操作符
无问西东的博客
10-02 6900
RxJava的学习成本其实蛮高的，我写RxJava这个系列是希望缩短学习RxJava的时间，我这里完全根据官网来学习一遍，写用例，做笔记，对于对英文不太感冒的同学，我相信看我的博客可以舒服不少！ 国庆两天假初步整理了一下Flowable的静态操作符，后续将会继续写Flowable的实例操作符，Observable、Single、Completable、Maybe操作符以及对各操作符的分类和总结，...
RxJava2 源码解析（二）
zxt0601的博客
03-20 8339
概述 承接上一篇RxJava2 源码解析（一）， 本系列我们的目的： 知道源头(Observable)是如何将数据发送出去的。 知道终点（Observer）是如何接收到数据的。 何时将源头和终点关联起来的 知道线程调度是怎么实现的 知道操作符是怎么实现的 本篇计划讲解一下4,5. RxJava最强大的莫过于它的线程调度 和 花式操作符。 map操作符 map是一个高频的操作符，我
RxJava2复习笔记一、操作符Create
haoyuegongzi的博客
09-03 338
create操作符应该是最常见的操作符，主要是观察者Observer（我们也称为下游事件）用来创建一个被观察者对象Obserable（我们也称为上游事件）。被观察者对象Obserable用于发送事件，观察者Observer用于接收事件。 好了，废话不多说，直接上代码： //创建一个上游 Observable： Observable&amp;amp;lt;Integer&amp;amp;gt; observab...
RxJava2.0中create操作符用法和源码分析
yuminfeng728的博客
08-21 841
create基本使用create是用来从头开始创建一个Observable的对象，应该调用ObservableEmitter的onNext, onError 和onComplete方法
RxJava（一） create 操作符的用法和源码分析
Chiclaim
05-28 1万+
RxJava系列文章目录导读： 一、RxJava create操作符的用法和源码分析 二、RxJava map操作符用法详解 三、RxJava flatMap操作符用法详解 四、RxJava concatMap操作符用法详解 五、RxJava onErrorResumeNext操作符实现app与服务器间token机制 六、RxJava retryWhen操作符...
RxJava2在Android中的使用之一 ----- 创建Observable
weixin_42504805的博客
10-21 1963
RxJava2在Android中的使用之一 ----- 创建Observable
RxJava 系列-1：一篇的比较全面的 RxJava2 方法总结
weixin_34411563的博客
08-14 432
看了许多讲解RxJava的文章，有些文章讲解的内容是基于第一个版本的，有些文章的讲解是通过比较常用的一些API和基础的概念进行讲解的。 但是每次看到RxJava的类中的几十个方法的时候，总是感觉心里没底。所以，我打算自己去专门写篇文章来从API的角度系统地梳理一下RxJava的各种方法和用法。 1、RxJava 基本 1.1 RxJava 简介 RxJava是一个在Java VM上使用可观测的序列...
Rxjava温故知新（十）------100行代码实现RxJava的Observable.create（简版）
xiaxiayige的专栏
11-06 667
1.前言 前面讲解了一些操作符的使用，现在我们看一下部分源码，实现一个简单版本Rxjava的Observable.create到订阅的动作。 2.实现简版RxJava 2.1 代码分析 首先我们来看看RxJava里面的源码走向是怎么的，从Observable.create到subscribe里面做了些什么操作，最后消息会发送到我们的观察者里面 我们知道RxJava Observable是一个被观...
两种创建Observable的方法（转）
SharkArmy
08-15 133
转自：http://blog.csdn.net/nicolelili1/article/details/52038211 Observable.create() create()方法使开发者有能力从头开始创建一个Observable。它需要一个OnSubscribe对象,这个对象继承Action1,当观察者订阅我们的Observable时，它作为一个参数传入并执行call()函数。 ...
RxJava 操作符篇 - 创建操作符
doris_d的专栏
09-27 359
Create 创建Observable。 Observable.create(new ObservableOnSubscribe<Integer>() { @Override public void subscribe(@NonNull ObservableEmitter<Integer> emitter) throws Throwable { try { for (int i=0; i<10; i++) {
一、RxJava基础 ---创建操作（Creating Observables）
FDoubleman的博客
05-23 2000
前言在学习RxJava 的过程中，每次想使用Rx的时候都不知道 应该如何下手，以此篇文章记录 备忘。
Android项目中RxJava等技术栈源码解析
Retrofit 2.0后支持多种自定义适配器，如RxJava适配器，将HTTP响应转换为Observable对象，从而可以享受RxJava带来的链式调用和组合各种操作符的强大功能。 **OkHttp3** OkHttp是一个高效的HTTP客户端，它被设计...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值