【RxJava】map过程中各个Observable生命周期分析

这篇具有很好参考价值的文章主要介绍了【RxJava】map过程中各个Observable生命周期分析。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

map和flatMap的区别

首先说下map和flatMap的区别,防止有对RxJava还不够熟悉的小伙伴

  • map的Function指定如何将A转为B
  • flatMap的Function则指定如何将Observable<A>转为Observable<B>
  • map和flatMap最终的转换结果都是Observable<B>
  • flatMap由于可以自己创建Observable,因此更为强大灵活,map比较简单

Observable生命周期测试

下面,我们创建一个Observable,并通过map和flatMap进行多次Observable转换

分别在正常流程和异常流程下,测试map过程中各个Observable的生命周期执行流程


  import io.reactivex.rxjava3.core.Observable;

  @SuppressWarnings("all")
  public class RxJavaMapTest {

      public static class Action {

          public static String A() {
              System.out.println("A Execute");
              return "A";
          }

          public static Observable<String> B() {
              System.out.println("B Execute");
              return Observable.just("B");
          }

          public static Observable<String> C() {
              System.out.println("C Execute");
              //throw new RuntimeException("Error");
              return Observable.just("C");
          }

          public static Observable<String> D() {
              System.out.println("D Execute");
              return Observable.just("D");
          }

          public static Observable<String> E() {
              System.out.println("E Execute");
              return Observable.just("E");
          }
      }

      public static void main(String[] args) {
          Observable.just("")
                  .map(o -> Action.A())
                  .doOnSubscribe(aAction -> {
                      System.out.println("doOnSubscribe A");
                  })
                  .doOnNext(o -> {
                      System.out.println("doOnNext A1");
                  })
                  .doOnNext(o -> {
                      System.out.println("doOnNext A2");
                  })
                  .doOnError(e -> {
                      System.out.println("doOnError A");
                  })
                  .doOnComplete(() -> {
                      System.out.println("doOnComplete A");
                  })
                  .doFinally(() -> {
                      System.out.println("doOnFinally A");
                  })
                  .flatMap(o -> Action.B())
                  .doOnSubscribe(aAction -> {
                      System.out.println("doOnSubscribe B");
                  })
                  .doOnNext(o -> {
                      System.out.println("doOnNext B");
                  })
                  .doOnError(e -> {
                      System.out.println("doOnError B");
                  })
                  .doOnComplete(() -> {
                      System.out.println("doOnComplete B");
                  })
                  .doFinally(() -> {
                      System.out.println("doOnFinally B");
                  })
                  .flatMap(o -> Action.C())
                  .doOnSubscribe(o -> {
                      System.out.println("doOnSubscribe C");
                  })
                  .doOnNext(o -> {
                      System.out.println("doOnNext C");
                  })
                  .doOnError(e -> {
                      System.out.println("doOnError C");
                  })
                  .doOnComplete(() -> {
                      System.out.println("doOnComplete C");
                  })
                  .doFinally(() -> {
                      System.out.println("doOnFinally C");
                  })
                  .flatMap(o -> Action.D())
                  .doOnSubscribe(o -> {
                      System.out.println("doOnSubscribe D");
                  })
                  .doOnNext(o -> {
                      System.out.println("doOnNext D");
                  })
                  .doOnError(e -> {
                      System.out.println("doOnError D");
                  })
                  .doOnComplete(() -> {
                      System.out.println("doOnComplete D");
                  })
                  .doFinally(() -> {
                      System.out.println("doOnFinally D");
                  })
                  .flatMap(o -> Action.E())
                  .doOnSubscribe(o -> {
                      System.out.println("doOnSubscribe E");
                  })
                  .doOnNext(o -> {
                      System.out.println("doOnNext E");
                  })
                  .doOnError(e -> {
                      System.out.println("doOnError E");
                  })
                  .doOnComplete(() -> {
                      System.out.println("doOnComplete E");
                  })
                  .doFinally(() -> {
                      System.out.println("doOnFinally E");
                  })
                  .subscribe(
                          o -> System.out.println("doOnFinally X"),
                          e -> System.out.println("doOnError X"),
                          () -> System.out.println("doOnFinally X")
                  );
          System.out.println("Task Finish");
      }

  }

正常情况下的运行结果

doOnSubscribe A
doOnSubscribe B
doOnSubscribe C
doOnSubscribe D
doOnSubscribe E
A Execute
doOnNext A1
doOnNext A2
B Execute
doOnNext B
C Execute
doOnNext C
D Execute
doOnNext D
E Execute
doOnNext E
doOnFinally X
doOnComplete A
doOnComplete B
doOnComplete C
doOnComplete D
doOnComplete E
doOnFinally X
doOnFinally E
doOnFinally D
doOnFinally C
doOnFinally B
doOnFinally A
Task Finish

C发生异常时的运行结果

doOnSubscribe A
doOnSubscribe B
doOnSubscribe C
doOnSubscribe D
doOnSubscribe E
A Execute
doOnNext A1
doOnNext A2
B Execute
doOnNext B
C Execute
doOnFinally A
doOnFinally B
doOnError C
doOnFinally C
doOnError D
doOnFinally D
doOnError E
doOnError X
doOnFinally E
Task Finish

下面,我们基于以上两次运行结果进行分析

如果有其它更深层次的疑问,可以复制以上代码,自己调整继续运行文章来源地址https://www.toymoban.com/news/detail-745717.html

正常流程下的生命周期流程

  • ABCDEX依次执行onSubscribe
  • ABCDE依次执行Function和onNext
  • ABCDEX依次执行onComplete
  • XEDCBD依次执行onFinally

C发生异常时的生命周期流程

  • ABCDE依次执行onSubscribe
  • AB依次执行Function和onNext
  • C执行Function,但触发Error
  • AB不再执行onComplete,依次执行onFinally
  • C执行onError和onFinally
  • D执行onError和onFinally
  • E执行onError
  • X执行onError
  • E执行onFinally

流程分析

  • 执行subscribe方法之后,B订阅A,C订阅B。。。
  • 无异常时,onFinally是按EDCBD顺序执行的,说明Subscriber工作全部完成后,Observable才会执行onFinally
  • C触发Error后,AB都不执行onComplete,说明Subscriber处理时发生错误,Observable也会被视为工作未完成
  • C触发Error后,AB立刻执行onFinally,说明Subscriber发生异常时,Observable工作直接结束
  • C触发Error后,AB不执行onError,但DE会执行onError,说明Observable错误,会引发Subscriber错误

多次map过程中,异常处理方式可以总结为

  • 发生异常时,所有的OnSubscribe都会执行
  • 发生异常时,所有的OnFinally都会执行
  • 发生异常时,所有的OnComplete都不会执行
  • 发生异常时,后续的OnError都会执行
  • 发生异常时,后续的OnNext都不会执行
  • 发生异常时,后续的Function都不会执行

多次map过程中,Function的处理方式

  • 多次map实际上是依次订阅的关系,B订阅A,再将自己的结果发射给C
  • map方法只是创建了一个起到包装作用的Observable,将所有回调对象,和用于转换的Function保存了起来
  • Function并不会立即执行,而是等subscribe之后,等到上个Observable处理成功,才会执行

subscribe回调和doOn系列回调的区别

  • 效果一样,只是给Observable提供了不同的回调设置方式
  • subscribe回调是设置给最后一个Observable的,和前面代码没有任何关系,不要复杂化
  • 一个Observable可以有多个回调,它们都会生效,并不会相互覆盖,按设置先后顺序执行

到了这里,关于【RxJava】map过程中各个Observable生命周期分析的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Android Jetpack中Lifecycle使用生命周期感知型组件处理生命周期

    在使用Kotlin实现Android Jetpack中Lifecycle使用生命周期感知型组件处理生命周期的功能时,你需要以下步骤: 首先,在app的build.gradle文件中添加Lifecycle相关库的依赖项: 然后,在你的Activity或Fragment中创建一个LifecycleObserver对象,并使用@OnLifecycleEvent注解来实现相应的生命周期方法

    2024年01月21日
    浏览(48)
  • “Spring管理JavaBean的过程及Bean的生命周期“

    Spring框架是一个非常流行的Java应用程序框架,它提供了一种简单而强大的方式来管理JavaBean。在本文中,我们将深入探讨Spring管理JavaBean的过程,并重点关注Bean的生命周期。此外,我们还将介绍Spring中的单例模式和原型模式,以及它们在JavaBean管理中的应用。 Spring框架通过一

    2024年02月12日
    浏览(41)
  • Angular--父子组件生命周期钩子(lifecycle hooks)执行过程

    组件初始化过程中,生命周期钩子执行顺序: constructor()构造函数,初始化class,(constructor不属于Angular生命周期钩子的范畴,这里只是说明组件组件初始化会先调用构造函数)。 ngOnChanges()--如果组件没有输入属性(@Input()),或者使用时没有提供任何输入属性,那么angular不会调用它

    2024年01月20日
    浏览(51)
  • 微信小程序的生命周期函数有哪些,以及执行过程?

    目录 1、应用的生命周期  2、页面的生命周期 3、组件的生命周期  4、执行顺序  小程序中,生命周期主要分成了三部分: ① 应用的生命周期        ② 页面的生命周期        ③ 组件的生命周期 1、应用的生命周期  在 app.js 里面调用,通过 App(Object) 函数用来注册一个小

    2024年02月08日
    浏览(47)
  • Android启动之生命周期流程

    目录 一、简述 二、启动流程说明(一) 三、启动流程说明(二) 四、ServerThread常用组件的功能介绍 第一步:启动Linux: 1.Bootloader 2.kernel 第二步:Android系统启动:入口为Init.rc(system/core/rootdir) 1./system/bin/servicemanager:Binder守护进程; 2.Runtime; 3.Zygote:app_process/App_main; 4.Start VM;

    2024年02月09日
    浏览(51)
  • Android生命周期:理解与应用

    摘要:Android生命周期是开发Android应用程序时至关重要的概念。本文将介绍Android生命周期的概念、生命周期方法的执行顺序以及如何在应用程序中正确地管理生命周期。我们还将讨论生命周期对于应用程序的重要性,并提供一些实际应用中的最佳实践和注意事项。 引言(10

    2024年02月05日
    浏览(38)
  • Android基础之Activity生命周期(一)

    Activity是Android四大组件之一、称为之首也恰如其分。 Activity直接翻译为中文叫活动。在Android系统中Activity就是我看到的一个完整的界面。 界面中看到的TextView(文字)、Button(按钮)、ImageView(图片)都是需要Activity来承载的。 总结一句话,Activity负责界面的呈现和用户的交互。

    2024年02月10日
    浏览(42)
  • 分析Vue3生命周期

    在Vue中,生命周期是组件从创建到销毁的整个过程中的不同阶段。Vue组件的生命周期主要由一系列的钩子函数(hook functions)组成。 以下是Vue组件生命周期的主要阶段: 1. 创建阶段:    - beforeCreate:在实例被创建之前调用,此时组件的响应式属性和事件还未初始化。    

    2024年01月25日
    浏览(34)
  • Android入门教程之Activity(生命周期,启动...)

    Activity 是一个应用组件,用户可与其提供的屏幕进行交互,以执行拨打电话、拍摄照片、发送电子邮件或查看地图等操作。 每个 Activity 都会获得一个用于绘制其用户界面的窗口。窗口通常会充满屏幕,但也可小于屏幕并浮动在其他窗口之上。 Activity 1. Activity 的使用 我们新建

    2024年02月04日
    浏览(61)
  • 【Spring】Bean的作用域与生命周期详情:请简述Spring的执行流程并分析Bean的生命周期?

     我们都知道,Spring框架为开发人员提供了很多便捷,这使得开发人员能够更加专注于应用程序的核心业务逻辑,而不需要花费大量时间和精力在技术细节上。作为一个包含众多工具方法的IoC容器,存取JavaBean是其极为重要的一个环节。本文就对Spring中的Bean的作用域和生命周

    2024年02月12日
    浏览(48)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包