RxJava2.0

最新推荐文章于 2023-07-02 13:36:15 发布
最新推荐文章于 2023-07-02 13:36:15 发布
阅读量376 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chuxue1989/article/details/88694418
版权

其中有一篇博客写的很精彩戳这里，这个非常简洁
还有一篇精彩博文戳这里，这个解释的非常通透

一、背景

无论是java8的CompletableFuture还是RxJava都是基于观察者模式的。只不过Rxjava更强大，有更好的错误处理、中断机制、完成状态

二、创建

  • Observable ( 被观察者 ) / Observer ( 观察者 )
  • Flowable （被观察者）/ Subscriber （观察者） 【支持回压】
package com.hfview;


import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import lombok.extern.slf4j.Slf4j;

/**
 * 观察者和被观察者创建
 *
 * @author: zhw
 * @since: 2019/3/15 09:36
 */
@Slf4j
public class RxJavaDemo1 {

    public static void main(String[] args) {

        //创建被观察者---方式1
        Observable<String> switcher1 = Observable.create(emitter->{
            log.debug("Observable emit 1");
            emitter.onNext("1");

            log.debug("Observable emit 2");
            emitter.onNext("2");

            log.debug("Observable emit 3");
            emitter.onNext("3");

            log.debug("Observable emit 4");
            emitter.onNext("4");

            log.debug("Observable emit onComplete ");
            emitter.onComplete();
        });

        //创建被观察者---方式2
        //Observable<String> switcher2 = Observable.just("on","off","on","on");

        //创建被观察者---方式3
        //String [] kk={"On","Off","On","On"};
        //Observable<String> switcher3 =Observable.fromArray(kk);


        //创建观察者
        switcher1.subscribe(new Observer<String>() {

            private Disposable disposable;

            @Override
            public void onSubscribe(Disposable d) {
                log.debug("     观察者onSubscribe");
                disposable = d;
            }

            @Override
            public void onNext(String s) {
                log.debug("     观察者onNext:"+s);
                if(s.equals("2")){
                    disposable.dispose();
                }
            }

            @Override
            public void onError(Throwable e) {
                log.error("     观察者onError",e);
            }

            @Override
            public void onComplete() {
                log.info("      观察者onComplete");
            }
        });

    }

}
  1. 第一种方式是最基本的，其实后面也是基于它的
  2. just方式
  3. fromArray方式

1.1 没有观察者，被观察者是不会生产事件的

假如没有 switcher1.subscribe() 这个操作，观察者不会调用各种释放Next
注意这里有个误解，应该是观察者订阅被观察者，但是为了链式调用的方便，就搞成被观察者订阅观察者了。

1.2 Disposable 方式

如果在观察者onNext方法中调用Disposable 的dispose方法，那么就可以终止获取，但是被观察者仍然继续生产，只是这个观察者不接受了
比如上面观察者中onNext方法只会打印到 观察者onNext:1 观察者onNext:2 剩下的却不打印了。

1.3 观察者onError

如果观察者在onNext中发生异常，那么会在onError自动捕获改异常

二、数据转换处理和线程切换

package com.hfview;


import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.CountDownLatch;

/**
 * 数据转换和线程切换
 *
 * @author: zhw
 * @since: 2019/3/15 09:36
 */
@Slf4j
public class RxJavaDemo2 {

    public static void main(String[] args) throws Exception{

        CountDownLatch countDownLatch = new CountDownLatch(1);
        long start = System.currentTimeMillis();

        //创建被观察者---方式2
        Observable
                .just("11011","21011","31011","41011")
                //.subscribeOn(Schedulers.newThread())//被观察者线程切换
                //.observeOn(Schedulers.io())
                    .map(s->{
                        log.debug("map操作当前线程为："+Thread.currentThread().getName());
                        return convert(s);//转换功能
                    })
                    /*.flatMap(new Function<String, ObservableSource<String>>() {
                        @Override
                        public ObservableSource<String> apply(String s) throws Exception {
                            return Observable.fromArray(s.split("0"));
                        }
                    })*/
                    .observeOn(Schedulers.computation())
                .subscribe(new Observer<String>() {
                    private Disposable disposable;

                    @Override
                    public void onSubscribe(Disposable d) {
                        log.debug("     观察者调用onSubscribe:"+Thread.currentThread().getName());
                        disposable = d;
                    }

                    @Override
                    public void onNext(String s) {
                        sleep(2000);
                        log.debug("     观察者接受数据onNext:"+s+"  "+Thread.currentThread().getName());
                    }

                    @Override
                    public void onError(Throwable e) {
                        log.error("     观察者调用onError"+Thread.currentThread().getName(),e);
                    }

                    @Override
                    public void onComplete() {
                        log.info("      观察者调用onComplete"+Thread.currentThread().getName());
                        countDownLatch.countDown();
                    }
                });

        countDownLatch.await();
        long end = System.currentTimeMillis();
        log.debug("主线程结束了,耗时:"+(end-start));
    }

    /**
     * 模拟耗时操作
     * @param s
     * @return
     */
    public static String convert(String s){
        //sleep(2000);
        return s+"1";
    }

    public static void sleep(int n){
        try {
            Thread.sleep(n);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

如果清楚java中Stream中的流处理，那么这里他它差不多

2.1 Map

public final <R> Observable<R> map(Function<? super T, ? extends R> mapper)

在函数式编成中也有这个接口Function，他基本就是负责转换，他需要一个入参? super T 和一个出参 ? extends R

.map(s->{
       log.debug("map操作当前线程为："+Thread.currentThread().getName());
       return convert(s);//转换功能
  })
 public static String convert(String s){
        return s+"1";
  }

比如上面就是完成将当前字符串+“1”。

2.2 filter

public final Observable<T> filter(Predicate<? super T> predicate);

和函数式接口Predicate一样一个入参，然后返回boolean。true就保留，false就剔除

2.3 线程切换

  • 简单地说，subscribeOn() 指定的就是发射事件的线程，observerOn 指定的就是订阅者接收事件的线程。
  • 多次指定发射事件的线程只有第一次指定的有效，也就是说多次调用 subscribeOn() 只有第一次的有效，其余的会被忽略。
  • 但多次指定订阅者接收线程是可以的，也就是说每调用一次 observerOn()，下游的线程就会切换一次。

关于Schedulers的解释
在这里插入图片描述

三、支持回压的模式

3.1 回压

回压或者背压：主要是处理如果被观察者产生时间过快，而观察者来不及处理，导致堆积，导致OOM的事情。

下面是一个例子:

package com.hfview;


import io.reactivex.Flowable;
import lombok.extern.slf4j.Slf4j;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;

import java.util.concurrent.CountDownLatch;

/**
 * 支持回压的Flowable
 *
 * @author: zhw
 * @since: 2019/3/15 09:36
 */
@Slf4j
public class RxJavaDemo3 {

    public static void main(String[] args) throws Exception{

        CountDownLatch countDownLatch = new CountDownLatch(1);
        long start = System.currentTimeMillis();

        final int length  = 100000;
        String[] arr = new String[length];
        for(int i=0;i<length;i++){
            arr[i] = (i+1)+"";
        }

        //创建被观察者---方式2
        Flowable.fromArray(arr)
                .subscribe(new Subscriber<String>() {
                    private Subscription subscription;
                    private int count = 0;

                    @Override
                    public void onSubscribe(Subscription s) {
                        log.debug("     观察者调用onSubscribe"+Thread.currentThread().getName());
                        subscription = s;
                        s.request(10);
                    }

                    @Override
                    public void onNext(String s) {
                        count++;
                        //sleep(200);
                        log.debug("     观察者接受数据onNext:"+s+"  "+Thread.currentThread().getName());

                        if(count!=0&&count%10==0){
                            log.debug("观察者再次请求数据10条,当前已经处理了:"+count+"条");
                            subscription.request(10);
                        }
                    }

                    @Override
                    public void onError(Throwable e) {
                        log.error("     观察者调用onError"+Thread.currentThread().getName(),e);
                    }

                    @Override
                    public void onComplete() {
                        log.info("      观察者调用onComplete"+Thread.currentThread().getName());
                        countDownLatch.countDown();
                    }
                });

        countDownLatch.await();
        long end = System.currentTimeMillis();
        log.debug("主线程结束了,耗时:"+(end-start));
    }

    /**
     * 模拟耗时操作
     * @param s
     * @return
     */
    public static String convert(String s){
        return s+"1";
    }

    public static void sleep(int n){
        try {
            Thread.sleep(n);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

用法基本和Observable。
区别:

  • 观察者onSubscribe中会传递一个类Subscription，他有两个方法public void request(long n) 和public void cancel()，意思也很明显，调用request(10),意思我只需要10个事件处理，被观察者收到命令后就产生10个。 cancel就是取消。

四、一个简单例子

package com.hfview;


import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;
import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;

/**
 * //TODO 写注释
 *
 * @author: zhw
 * @since: 2019/3/15 15:54
 */
@Slf4j
public class RxJavaDemo4 {

    public static void main(String[] args) throws Exception{

        long start =  System.currentTimeMillis();
        CountDownLatch countDownLatch = new CountDownLatch(1);

        Observable observable1 = Observable.fromCallable(new Callable<String>() {
            @Override
            public String call() throws Exception {
                log.debug("被观察者生成字符串1");
                sleep(3000);
                return "1";
            }
        }).subscribeOn(Schedulers.newThread());

        Observable observable2 = Observable.fromCallable(new Callable<String>() {
            @Override
            public String call() throws Exception {
                log.debug("被观察者生成字符串2");
                sleep(3000);
                return "2";
            }
        }).subscribeOn(Schedulers.newThread());;

        Observable observable3 = Observable.fromCallable(new Callable<String>() {
            @Override
            public String call() throws Exception {
                log.debug("被观察者生成字符串3");
                sleep(3000);
                return "3";
            }
        }).subscribeOn(Schedulers.newThread());;


        //Observable<String> unionObservable = observable1.concatWith(observable2).concatWith(observable3);
        Observable<String> unionObservable = observable1.mergeWith(observable2).mergeWith(observable3);


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

            }

            @Override
            public void onNext(String s) {
               log.debug("      观察者获取数据:"+s);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {
                countDownLatch.countDown();
            }
        });


        countDownLatch.await();
        long end = System.currentTimeMillis();
        log.debug("主线程结束了,耗时:"+(end-start));

    }


    public static void sleep(int n){
        try {
            Thread.sleep(n);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

一共三个事件各自需要3S，现在使用响应式编成，最后只需要3S就完成操作

诛仙89
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxJava 2.0学习文档
06-29
RxJava 2.0的基本概念，使用方法，网络请求步骤，自己使用过程中经常使用的部分，适合初用者
RxJava2.0——从放弃到入门
weixin_34087503的博客
04-02 158
前言 终于到了讲RxJava这一期，RxJava是笔者个人非常喜欢的一个开源库，它很好的将链式编程风格和异步结合在一起。RxJava其实已经推出很久了，可以说是已经很火了，但是目前仍然还有相当一部分Android开发者没有使用过，甚至说是想用，却不知道怎么用，或者不知道自己的项目哪里可以用到，本着让广大开发者...
RxJava 2.0
Kiven 每天都需要有所获，每天都需要进步.........
03-20 575
前言 之前写RxJava相关文章的时候，就有人想让我谈谈RxJava2.0的新特性，说实话，一开始我是拒绝的。因为在我看来，RxJava2.0虽然是版本的重大升级，但总归还是RxJava，升级一个版本还能上天是咋的？了解一下它的更新文档不就好了么？真的有必要单出一篇文章来谈这个么？ 但是详细的了解了RxJava2.0以及部分源码之后，我觉得还是有必要对RxJava2.0做一个说明，帮助大
给初学者的RxJava2.0教程(二)
weixin_33957648的博客
12-08 138
Outline [TOC] 前言 上一节教程讲解了最基本的RxJava2的使用, 在本节中, 我们将学习RxJava强大的线程控制. 正题 还是以之前的例子, 两根水管: RxJava 正常情况下, 上游和下游是工作在同一个线程中的, 也就是说上游在哪个线程发事件, 下游就在哪个线程接收事件. 怎么去理解呢, 以Android为例, 一个Activity的所有动作默认都是在主线程中运行的, ...
RxJava2.0（一）
m0_49508485的博客
09-22 144
首先需要说明的是，RxJava2.0和RxJava1.0是不冲突的，如果学过RxJava1.0，那么只需要在关注下更新内容即可。不过如果没学过RxJava1.0也没关系，直接学习RxJava2.0也是一样的，本文中所有的名词都属于RxJava2.0，并不涉及RxJava1。
word源码java-RxJava2.0:RxJava2.0使用介绍，官方文档翻译
06-05
RxJava2.0使用介绍，参考官方文档，每个操作符对应一个示例，帮助更好理解RxJava2.0 RxJava是什么？ Rx（Reactive Extensions）历史 是LINQ的一个扩展，由微软的架构师Erik Meijer领导的团队开发，在2012年11月开源...
RxJava2.0在android开发中的实用操作符总结
04-14
RxJava2.0在android开发中的实用操作符总结.............
RxJava2.0 结合Retrofit2.0 的简单的封装
06-14
RxJava2.0 结合Retrofit2.0 的简单的封装.主要是网络的封装起来
Rxjava 2.0+Retrofit 2.0+Mvp架构研究
02-06
次文章结合目前主流技术Rxjava 2.0+Retrofit 2.0+Mvp架构 ，欢迎下载
RxJava2.0（学习）
蓝家彬的博客
07-07 752
零、来源 来源：Carson_Ho-简书 一、基础知识 角色 作用 类比 被观察者（Observable） 产生事件 顾客 观察者（Observer） 接收事件，并给出响应动作 厨房 订阅（Subscribe） 连接 被观察者 & 观察者 服务员 事件（Event） 被观察者 & 观察者 沟通的载体 菜式 二、基础使用 1.导入连接 implementation 'io.reactivex.rxjava2:rxjava:2.2.19' impl
jsjava2.0(修改版)
11-18
jsjava2类库,修改了jsjava-2.0.js文件中的错误
RxJava2.0简介（一）
WillScorpio
04-17 1521
本文参考：https://www.jianshu.com/p/464fa025229e 这个作者写的特别好。
RxJava2.0 初识
Ricky_Ling的博客
05-18 1026
RxJava2.0 初识前言 RxJava现在已经是家喻户晓了，其里面的链式编写，可以帮助我们简化代码逻辑，提高代码阅读性。一直流行这么一句话，作为一个程序猿要学会“偷懒”，RxJava大大的提升了开发效率，和降低了后期的维护成本。不得不令人垂涎它的“魅力”。 于是，走上了学习Rxjava之路，为什么一来就用Rxjava2.0而不是最初的RxJava开始说起，原因其实是小弟之前有接触过
RxJava 2.0 全体系梳理(持续更新ing)
化身孤岛的瓜
07-02 1515
只有观察者订阅了，才开始执行发射数据的代码。并且Cold Observable和Observer只能是一对一的关系。当有多个不同的订阅者时，消息是重新完整发送的，也就是说，对于Cold Observeable来说，有多个Observer存在的时候，各自的事件是独立的。多个订阅的sunbscribe（或者说观察者）事件各自独立。Hot Observable 无论有没有观察者订阅，事件始终都会发生。当Hot Observable有多个订阅者时，Hot Observable与订阅者们的关系是一对多的关系。
Java基础2.0
qq_42226696的博客
05-07 158
运算符 概念 ​ ·对常量进行加减乘除 常用的运算符 ​ ·算术运算符 ​ 如果++或–单独操作，前后都一样 ​ 如果++或–参与运算的话，如果++或–在变量前，先++或–再参与运算 eg：++y； ​ 如果++或–在变量后，先参与运算再++ eg：y++ ​ ·赋值运算符 ​ ·关系运算符 ​ ·逻辑运算符 && 和 || ​ &a...
手把手教你使用 RxJava 2.0（一）
LRH0211的博客
06-02 1614
网上有很多关于RxJava的技术文章，大多数是关于1.x版本的。随着 RxJava 2.0 的推出，有些文章也介绍了2.x版本新增的内容以及与1.x版本的对比。有些同学如果刚刚接触RxJava，仅仅看RxJava 1.x 的一些技术文章，有时候会有些出入。因此本篇文章基于RxJava 2.0 进行由浅入深的学习，逐步掌握RxJava。 1.作用RxJava的目的就是异步。 RxJava的特点就是可
Java 2.0--基础阶段（建立编程思想）
Sunblogy的博客
07-26 1391
@TOCJava重学 第二章 Java了解 一、Java诞生 1、1995 年 sun正式发布Java第一个版本（创始人：gosling） 2、最新版本Java15（使用时期不长） 3、Java现在属于甲骨文公司
android rxjava
最新发布
11-11
Android中的RxJava是一个流行的响应式编程库，它使得异步数据流的处理变得更加简单和高效。RxJava基于观察者模式，可以轻松地处理异步操作、事件和数据流，提供了丰富的操作符和线程调度的支持，使得代码更加清晰和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值