03-Mono & Flux操作

最新推荐文章于 2024-05-14 11:19:53 发布
最新推荐文章于 2024-05-14 11:19:53 发布
阅读量3.9k 收藏 14
点赞数 2
分类专栏： spring-reactive 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tong_Rui/article/details/115417029
版权

上一节主要介绍了如何基于Mono和Flux构建一个数据流，Mono是Flux的特例，但大部分API 都是一致的所以重点讲的是Flux。本章将讲Flux和Mono的操作符，如 转换、过滤、异常处理、日志、Debug等一些API。

1. buffer

buffer方法相当于将序列中的一部分数据收集到一个集合中，并作为一个新的流元素发送到下游。
在这里插入图片描述
这里看buffer的重载方法特别多啊，基本功能肯定是一样的只是多了一些附加条件。我们加单示例几种。
示例1： 指定收集的元素个数

public static void test_01(){
        Flux.just(1,2,3,4,5,6).buffer(2).subscribe(System.out::println);
    }

结果：

 [1, 2]
 [3, 4]
 [5, 6]

示例2：当断言为true时 buffer中断收集元素， 但包含最后一个元素。

public static void test_39(){
    Flux.range(1, 10)
            .bufferUntil(i->i>5)
            .subscribe(System.out::println);
}

结果:

 [1, 2, 3, 4, 5, 6]
 [7]
 [8]
 [9]
 [10]

示例3： 收集返回true的元素，当返回false时中断流，并不包含返回false的元素。

public static void test_40(){
        Flux.range(1, 10)
                .bufferWhile(i->i>5)
                .subscribe(System.out::println);
    }

结果：

[6, 7, 8, 9, 10]

2. window

字面意思窗口，功能跟buffer类似。区别是window将元素分成一个个Flux对象而不是一个Flux中的集合元素。
示例：

public static void test_04(){
   Flux.just(1,2,3,4,5,6).window(2).toIterable().forEach(f->{
       f.subscribe(System.out::println);
       System.out.println("--------------------");
   });
}

结果:

 1
 2
 --------------------
 3
 4
 --------------------
 5
 6
 --------------------

这里将每个Flux对象转成了集合进行了遍历打印。

3. map

转换方法，将每一个元素按map中定义的Function函数进行转换。
示例：

public static void test_41(){
    Flux.range(1,5)
            .map(i -> i*i)
            .subscribe(System.out::println);
}

结果:

1
4
9
16
25

4. flatmap

也是一个转换方法，跟Java 中lambda中的flatmap类似，它会将元素转成一个流或者说Flux对象，然后对流进行合并。对于lambda中flatmap常见的案例就是将[“hello”, “world”] 转成单个字母。这里同样适用。

public static void test_42(){
     Flux.just("hello", "world")
             .flatMap(w->Flux.just(w.split("")))
             .subscribe(System.out::print);
 }

结果：

helloworld

5. filter

过滤方法，对元素序列中的所有元素进行过滤。重载方法也非常多， 这里只简单介绍。
案例:

 public static void test_08(){
        Flux.just(1,2,3,4,5,6).filter(i->i%2==0).subscribe(System.out::println);
    }

结果:

2
4
6

7. block

阻塞等待获取元素
示例:

// 取第一个元素
System.out.println(Flux.just(1, 2, 3, 4, 5, 6).blockFirst());
// 取最后一个元素
System.out.println(Flux.just(1, 2, 3, 4, 5, 6).blockLast());

8. skip

在这里插入图片描述
跳过指定个数或时间或者断言的元素。

  • 跳过两个元素后取第一个元素。
System.out.println(Flux.just(1, 2, 3, 4, 5, 6).skip(2).blockFirst());
  • 当skipUntil返回True时，停止跳过元素。
 public static void test_26(){
	Flux.range(1, 100)
	          .skipUntil(i->i > 10)
	          .subscribe(System.out::println);
	}

结果：

11
12
13
14
15
16
...

9. then

then()返回一个Mono 也就是说它会忽略上游的流数据，但其它的重载方法可以重新生成新的数据流。
在这里插入图片描述

public static void test_11(){
	Flux.just(1, 2, 3, 4, 5, 6)
        // 返回 Flux<Void>
        .then()
        .subscribe(System.out::println);
}

实际上并不会打印任何东西。

10. when

在这里插入图片描述
这个一个聚合操作，将等待一个或者多个Publisher执行完成之后在进行加下来的操作。

    public static void test_12(){
        Flux.just(1, 2, 3, 4, 5, 6)
                .flatMap(i->{
                    System.out.println(i);
                    return Mono.when(s->{
                        System.out.println("all done");
                        s.onComplete();
                    },
                    s->{
                        System.out.println("all done-2");
                        s.onComplete();
                    });
                }).subscribe();
    }

1
all done
all done-2
2
all done
all done-2
3
all done
all done-2

11. merge 合并多个流

在这里插入图片描述
每个Publisher将返回一个Flux流，merge将多个流合并成一个流。合并的方式是交错的方式。
示例：

public static void test_13(){
    Flux.merge(Flux.interval(Duration.ofMillis(0), Duration.ofMillis(100)).take(2),
            Flux.interval(Duration.ofMillis(50), Duration.ofMillis(100)).take(2))
            .subscribe(System.out::println);
}

第一个Flux延时0毫秒每100毫秒生成一个元素，返回一个只有两个元素的流。第二个Flux延时50毫秒每100毫秒生成一个元素也返回由两个元素的流。这样算一下其实是每50秒生成一个元素。
结果如下:

0
0
1
1

也就说明合并两个流时是按照它们生成的顺序合并的。

12 mergeSequential

    public static void test_14(){
        Flux.mergeSequential(Flux.interval(Duration.ofMillis(0), Duration.ofMillis(100)).take(3),
                Flux.interval(Duration.ofMillis(50), Duration.ofMillis(100)).take(2))
                .subscribe(System.out::println);
    }

结果:

0
1
2
0
1

说明mergeSequential 是按Pulisher的顺序合并流的。

13 zip

这也是一个合并方法，不过它是按一对一匹配的，如果序列中有对应不上的元素会被丢弃。

public static void test_15(){
        Flux.zip(Flux.just(1, 2, 5), Flux.just(3, 4)).subscribe(System.out::println);
    }

结果:

[1,3]
[2,4]

14 异常处理

14.1 onErrorReturn

    public static void test_18(){

        Flux.range(1, 6)
                .map(i -> 10/(i-3))
                .onErrorReturn(5)   // 出错后给一个默认值 然后序列就终端了 元素序列只剩出错前的一段
                .map(i -> i*i)
                .subscribe(System.out::println, System.err::println);
    }

25
100
25

onErrorReturn异常发生时返回一个给定的默认值，然后后面的元素就丢掉了。

14.2 subscribe

public static void test_19(){
    Flux.range(1, 6)
            .map(i -> 10/(i-3))
            .map(i -> i*i)
            .subscribe(System.out::println, System.err::println);
}

这里并没有显示的处理异常，只是通过subscribe的第二个参数将异常打印出来。

14.3 onErrorResume

public static void test_20(){

        Flux.range(1, 6)
                .map(i -> 10/(i-3))
                .onErrorResume(e->{
                    e.printStackTrace();
                    return Mono.just(10);
                })
                .map(i -> i*i)
                .subscribe(System.out::println, System.err::println);
    }

结果:

25
100
java.lang.ArithmeticException: / by zero
	at com.spring.reactive.OperateApiTest.lambda$test_20$16(OperateApiTest.java:231)
	at reactor.core.publisher.FluxMapFuseable$MapFuseableSubscriber.onNext(FluxMapFuseable.java:113)
	at reactor.core.publisher.FluxRange$RangeSubscription.fastPath(FluxRange.java:130)
	at reactor.core.publisher.FluxRange$RangeSubscription.request(FluxRange.java:108)
	at reactor.core.publisher.FluxMapFuseable$MapFuseableSubscriber.request(FluxMapFuseable.java:169)
	at reactor.core.publisher.Operators$MultiSubscriptionSubscriber.set(Operators.java:2154)
	at reactor.core.publisher.FluxOnErrorResume$ResumeSubscriber.onSubscribe(FluxOnErrorResume.java:74)
	at reactor.core.publisher.FluxMapFuseable$MapFuseableSubscriber.onSubscribe(FluxMapFuseable.java:96)
	at reactor.core.publisher.FluxRange.subscribe(FluxRange.java:68)
	at reactor.core.publisher.Flux.subscribe(Flux.java:8095)
	at reactor.core.publisher.Flux.subscribeWith(Flux.java:8268)
	at reactor.core.publisher.Flux.subscribe(Flux.java:8065)
	at reactor.core.publisher.Flux.subscribe(Flux.java:7989)
	at reactor.core.publisher.Flux.subscribe(Flux.java:7959)
	at com.spring.reactive.OperateApiTest.test_20(OperateApiTest.java:237)
	at com.spring.reactive.OperateApiTest.main(OperateApiTest.java:541)
100

这里和onErrorReturn类似，只不过这里可以获取到异常信息。

14.4 onErrorMap

public static void test_21(){
   Flux.range(1, 6)
           .map(i -> 10/(i-3))
           .onErrorMap(e-> {throw new RuntimeException("111");})
           .map(i -> i*i)
           .subscribe(System.out::println, System.err::println);

}

25
100
java.lang.RuntimeException: 111

它可以获取到异常信息，但返回值也必须是一个异常。

14.5 doOnError

public static void test_22(){

        Flux.range(1, 6)
                .map(i -> 10/(i-3))
                .doOnError(e->{
                    System.out.println(e.getLocalizedMessage());
                })
                .onErrorMap(e-> {throw new RuntimeException("111");})
                .map(i -> i*i)
                .subscribe(System.out::println, System.err::println);

    }

相当于异常发生时的一个回调，不会返回任何东西，可以打印一下异常信息或者异常通知等等。

15. defaultIfEmpty 默认返回值

public static void test_23(){

        Flux.just().defaultIfEmpty(0).subscribe(System.out::println);

    }

在流为空的时候，相当于给一个默认值。

16. any 流中是否有符合条件的任意一个元素

    public static void test_28(){
        Flux.range(1, 20)
                .any(i->i %2 == 0)
                .subscribe(System.out::println);
    }

结果是true，有任意一个结果满足即可。

17. all 流中所有元素是否都满足条件

    public static void test_29(){

        Flux.just("abc", "ela", "ade", "pqa", "kang")
        .all(a -> a.contains("a"))
        .subscribe(System.out::println);

    }

18. subscribe

订阅流，也可以说消费流。最简单的方式就是给一个Consumer实现来消费消费流。同时它还有许多重载方法。
在这里插入图片描述
如果选择空参方法就是丢弃流。除了使用Consumer参数还可以实现一个Subscribe来消费流。

 public static void test_33(){

        Flux.just(1,2,3,4)
                .subscribe(new Subscriber<Integer>() {
                    Subscription sub;
                    @Override
                    public void onSubscribe(Subscription s) {
                        System.out.println("onSubscribe");;
                        sub = s;
                        // 每次消费一个元素
                        sub.request(1);
                    }
                    @Override
                    public void onNext(Integer integer) {
                        System.out.println("onNext");
                        System.out.println(integer);
                        sub.request(1);
                    }
                    @Override
                    public void onError(Throwable t) {
                        System.out.println("onError");;
                        t.printStackTrace();
                    }
                    @Override
                    public void onComplete() {
                        System.out.println("onComplete");;
                    }
                });
    }

当如果有比较复杂的订阅需求时可以使用这种方式来实现自己的消费逻辑。同时还可以使用有默认实现方法的BaseSubscribe来实现。

public static void test_34(){

        Flux.just(1,2,3,4)
                .subscribe(new BaseSubscriber<Integer>() {
                    Subscription sub;

                    @Override
                    protected void hookOnSubscribe(Subscription s) {
                        System.out.println("onSubscribe");;
                        sub = s;
                        // 每次消费一个元素
                        sub.request(1);
                    }

                    @Override
                    protected void hookOnNext(Integer value) {
                        System.out.println("onNext");
                        System.out.println(value);
                        sub.request(1);
                    }

                    @Override
                    protected void hookOnComplete() {
                        System.out.println("onComplete");;
                    }
                });

    }

总结

本章介绍了大部分比较常用的Reactor方法，满足基本使用情况。熟练的掌握这些方法可以更快速的进行响应式编码。当然还有一些如Debug、log等等都是辅助开发的手段有需要大家可以自行了解。

TongRui乀
关注
  • 2
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Reactor | Flux和Mono如何分辨如何使用——超详细易懂
资深全栈开发工程师
07-07 1936
Reactive Stream 规范中将这种定义为Publisher， 允许提供0-N个序列元素的提供者， 根据其订阅者Subscriber的需求来提供推送的元素， 一个Publisher可以支持多个订阅者，根据订阅者的喜好和逻辑推送序列元素。Flux和Mono都是Publisher在Reactor 3实现。 Publisher提供了subscribe方法，允许消费者在有结果可用时进行消费。 如果没有消费者Publisher不会做任何事情，他根据消费情况进行响应。 Publisher可能返回零或者多个，甚至
响应式编程二Mono，Flux简单介绍
lsd&xql的博客
12-19 1665
响应式编程是一种面向数据流和变化传播的声明式的编程范式1）Publisher，发布者2）Subscriber，订阅者3）Subscription，发布者和订阅者直接的关系，订阅多少数据4）Processor （reactor 3.5取消）1）对响应式流规范的一种实现2）Spring WebFlux默认的响应式框架3）完全异步非阻塞，对背压的支持4）提供两个异步序列API：Flux[N]和Mono[0|1]5）提供对响应式流的操作。
JAVA Reactor API ( Flux和Mono)的简单使用
热门推荐
weixin_47951400的博客
04-21 1万+
1. 创建Flux及Mono 1.1 使用just从现有的已知内容和大小的数据创建Flux或Mono Flux.just(new Integer[]{1, 2, 3, 4}) //观察者监听被观察者(消费者) .subscribe(System.out::println); //使用可变参数创建Flux Flux.just(1, 2, 3, 4) .subscribe(System.out::println); //使用just创建Mono Mono.just("1s") .subscribe(
webFlux中的then和thenReturn的区别
最新发布
weixin_44304605的博客
05-14 300
webFlux中的then和thenReturn方法，响应式编程
响应式编程详解，带你熟悉Reactor响应式编程
weixin_36873225的博客
11-07 222
【代码】当涉及到上位机通信时。
【Reactor】学习笔记-基本概念和Mono、Flux
weixin_42305433的博客
01-03 3658
Reactor基本概念和Mono、Flux概述Reactor的简介使用场景 概述 JAVA8的函数式编程我们都比较熟悉，将一段对数据的操作逻辑，通过map、reduce、group、join、foreach、limit、count等算子进行表达最终得出结果，类似于Spark中提供的算子，虽然长的一样，但原理不同，而且Hadoop中也有对应的MapReduce写法，感觉也差不多的样子，现在又有了Reactor，也是一长串函数式编程的代码风格，那区别在哪里； 代码虽然看起来很像，有两点区别： 1、核心实现上
附2：Reactor 3 之选择合适的操作符——响应式Spring的道法术器
刘康的专栏
03-19 1万+
本系列其他文章见：《响应式Spring的道法术器》。 前情提要：Reactor3快速上手 | 深入理解响应式流规范 | Reactor3操作符 本节的内容来自我翻译的Reacto 3 参考文档——如何选择操作符。由于部分朋友打开github.io网速比较慢或上不去，贴出来方便大家查阅。 如果一个操作符是专属于 Flux 或 Mono 的，那么会给它注明前缀。 公共的操...
spring-webflux-mono-flux-router-handler:使用Flux和Mono的Spring进行响应式编程，使用MongoDB的Router和Handler
05-03
使用Flux和Mono的Spring进行响应式编程，使用MongoDB的Router和Handler 使用Spring 5 Reactive Programming和MongoDB数据库的CRUD REST API。 先决条件：安装和配置MongoDB，数据库名称为active，集合名称为...
Reactor教程Mono和Flux例子
11-20
在Reactor教程中，你可能会学习如何使用Mono和Flux来创建异步操作。例如，你可以使用`Mono.fromFuture`将Java的Future转换为Mono，从而使得基于回调的API能够与Reactor的响应式流协同工作。Flux也可以通过`Flux....
react-demo-web-flux
05-18
Spring Web Flux提供了Flux和Mono两种类型来处理0个到多个和0个或1个数据的响应式流。Flux可以用于处理HTTP响应，而Mono则适用于处理单个结果。我们需要创建一个RESTful API，通过Flux来发布实时数据。 接下来，...
reactor &amp; flux jar包
09-27
Reactor提供了两个核心概念：Mono和Flux。Mono代表0个或1个元素的序列，而Flux则代表0到N个元素的序列。这两个类型都支持多种操作符，如map、filter、concat、merge等，使开发者能够构建复杂的反应式数据流。 Flux ...
spring-boot-web-flux-operators:举例说明Spring Boot Web Flux
03-25
在这个项目中，我们将深入探讨Spring Boot Web Flux的使用和核心特性，以及如何利用其操作符来处理数据流。 首先，Spring Boot Web Flux基于Reactor库，这是Java 8和Project Reactor框架的一部分，它遵循Reactive ...
Reactor手册
啊浪的博客
12-12 1716
reactor详细手册
05-流式操作：使用 Flux 和 Mono 构建响应式数据流
JavaEdge全是干货的技术号
07-10 3054
本文介绍了如何创建 Flux 和 Mono 对象，以及如何订阅响应式流的系统方法。想要创建响应式流，可以利用 Reactor 框架所提供的各种工厂方法来达到静态创建的效果，同时也可以使用更加灵活的编程式方式来实现动态创建。而针对订阅过程，Reactor 框架也提供了一组面向不同场景的 subscribe 方法。
java reactor 实例_等待运行Reactor Mono实例完成
weixin_42505576的博客
02-28 873
我写了这段代码来分拆大量的WebClients(受 reactor.ipc.netty.workerCount 限制)，立即启动Mono，等待所有Monos完成：List&gt;&gt; monos = new ArrayList&lt;&gt;(metricConfigs.size());for (MetricConfig metricConfig : metricConfigs) {try {...
spring响应式编程06 流式操作：如何使用 Flux 和 Mono 高效构建响应式数据流？
sucaiwa的博客
03-31 3323
在上一讲中，我为你介绍了 Reactor 响应式编程框架，该框架实现了响应式流规范。我们知道在响应式流规范中，存在代表发布者的 Publisher 接口，而 Reactor 提供了这一接口的两种实现，即 Flux 和 Mono，它们是我们利用 Reactor 框架进行响应式编程的基础组件。在引入 Flux 和 Mono 的概念之后，这一讲的内容将围绕如何创建这两个组件展开。
响应式编程简介
weixin_45577053的博客
01-29 4301
对于响应式编程的解释 个人理解： Java中传统的线程接口有两种，一种是Runable,一种是Callable；一个没有返回值，一个有返回值；Callable的返回值用Future来接收。无论是Runable还是Callable，都要等线程执行完才能继续操作下去，这个过程中就造成了阻塞。 如果想我把任务分配下去，并且告诉他任务执行完成就怎么怎么样，然后我就不用管了，这样一种思想可以理解成是响应式编程，就像是“好莱坞原则”（演员不用主动联系导演，导演会去联系演员，也就是你不要来找我，我会去找你）。 响
springboot webflux flux 使用示例（创建操作）
weixin_43931625的博客
06-27 1576
springbootwebfluxflux使用示例（创建操作）
springboot webflux mono 使用说明
weixin_43931625的博客
06-23 9732
springbootwebfluxmono使用说明
webflux的mono和flux的用法
01-14
WebFlux是Spring框架的一部分，它提供了一种响应式编程的方式来构建基于非阻塞I/O的应用程序。在WebFlux中，我们可以使用两种主要的数据类型：Mono和Flux。 1. Mono： Mono是一种包含零个或一个元素的响应式流。它类似于Java 8中的Optional，但具有更多的操作符和功能。下面是一些使用Mono的示例： ```java Mono&lt;String&gt; mono = Mono.just(&quot;Hello&quot;); // 创建一个包含单个元素的Mono mono.subscribe(System.out::println); // 订阅并打印元素 Mono&lt;Integer&gt; emptyMono = Mono.empty(); // 创建一个空的Mono emptyMono.subscribe(System.out::println); // 不会输出任何内容 Mono&lt;String&gt; errorMono = Mono.error(new RuntimeException(&quot;Error&quot;)); // 创建一个包含错误的Mono errorMono.subscribe(System.out::println, Throwable::printStackTrace); // 打印错误信息 ``` 2. Flux： Flux是一种包含零个或多个元素的响应式流。它类似于Java 8中的Stream，但具有更多的操作符和功能。下面是一些使用Flux的示例： ```java Flux&lt;String&gt; flux = Flux.just(&quot;Hello&quot;, &quot;World&quot;); // 创建一个包含多个元素的Flux flux.subscribe(System.out::println); // 订阅并打印元素 Flux&lt;Integer&gt; emptyFlux = Flux.empty(); // 创建一个空的Flux emptyFlux.subscribe(System.out::println); // 不会输出任何内容 Flux&lt;String&gt; errorFlux = Flux.error(new RuntimeException(&quot;Error&quot;)); // 创建一个包含错误的Flux errorFlux.subscribe(System.out::println, Throwable::printStackTrace); // 打印错误信息 ``` 通过使用Mono和Flux，我们可以在WebFlux中处理异步和非阻塞的操作，例如处理HTTP请求和响应。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值