spring boot 2.1学习笔记【十八】reactor3 响应式编程

springboot系列学习笔记全部文章请移步值博主专栏**: spring boot 2.X/spring cloud Greenwich。
由于是一系列文章,所以后面的文章可能会使用到前面文章的项目。springboot系列代码全部上传至GitHub:https://github.com/liubenlong/springboot2_demo
本系列环境:Java11;springboot 2.1.1.RELEASE;springcloud Greenwich.RELEASE;MySQL 8.0.5;

文章目录

  • 搭建项目
  • Flux与Mono
    • 测试Flux和Mono,简单输出
  • map和filter
  • flatMap
  • 异常
  • StepVerifier单元测试
  • Flux.interval 无限流
  • zip压缩: 一对一合并数据流
  • Schedulers线程池
    • 切换调度器
  • 异常处理
    • 直接中断输出
    • onErrorReturn提供缺省值
    • onErrorResume
    • onErrorMap捕获异常
    • 捕获异常,不做处理
    • doFinally
  • 背压
  • 总结

本文介绍reactor响应式编程风格。spring 5 响应式编程底层默认首选就是reactor ,所以很有必要学习一下。

Reactor 用于创建高效的响应式系统。Reactor 是一个用于JVM的完全非阻塞的响应式编程框架,具备高效的需求管理(即对 “背压(backpressure)”的控制)能力。它与 Java 8 函数式 API 直接集成,比如 CompletableFuture, Stream, 以及 Duration。它提供了异步序列 API Flux(用于[N]个元素)和 Mono(用于 [0|1]个元素),并完全遵循和实现了“响应式扩展规范”(Reactive Extensions Specification)。

Reactor 的 reactor-ipc 组件还支持非阻塞的进程间通信(inter-process communication, IPC)。 Reactor IPC 为 HTTP(包括 Websockets)、TCP 和 UDP 提供了支持背压的网络引擎,从而适合 应用于微服务架构。并且完整支持响应式编解码(reactive encoding and decoding)。

官网地址:project reactor
官网文档:Reactor 3 Reference Guide

搭建项目

引入依赖

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-dependenciesartifactId>
            <version>2.1.1.RELEASEversion>
            <type>pomtype>
            <scope>importscope>
        dependency>

        <dependency>
            <groupId>io.projectreactorgroupId>
            <artifactId>reactor-bomartifactId>
            <version>Bismuth-RELEASEversion>
            <type>pomtype>
            <scope>importscope>
        dependency>
    dependencies>
dependencyManagement>

<dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>io.projectreactorgroupId>
            <artifactId>reactor-coreartifactId>
        dependency>
        <dependency>
            <groupId>io.projectreactorgroupId>
            <artifactId>reactor-testartifactId>
            <scope>testscope>
        dependency>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
            <scope>testscope>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <version>1.18.4version>
            <scope>providedscope>
        dependency>

        <dependency>
            <groupId>org.testnggroupId>
            <artifactId>testngartifactId>
            <version>6.8.7version>
            <scope>testscope>
        dependency>
    dependencies>

编写个main方法

@SpringBootApplication
public class Application {
	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}
}

项目搭建完成。这里我们只写test方进行测试。

Flux与Mono

flux是一个能够发出 0 到 N 个元素的标准的 Publisher,它会被一个“错误(error)” 或“完成(completion)”信号终止。
Mono 是一种特殊的 Publisher, 它最多发出一个元素,然后终止于一个 onComplete 信号或一个 onError 信号。

Flux和Mono是“数据流”的发布者,都可以发出三种“数据信号”:元素值、错误信号、完成信号,错误信号和完成信号都是终止信号,完成信号用于告知下游订阅者该数据流正常结束,错误信号终止数据流的同时将错误传递给下游订阅者。
Flux:spring boot 2.1学习笔记【十八】reactor3 响应式编程_第1张图片
Mono:spring boot 2.1学习笔记【十八】reactor3 响应式编程_第2张图片

测试Flux和Mono,简单输出

@Test
public void test1() {
    Flux.just(1, 2, 3, 4, 5, 6).subscribe(System.out::print);
    System.out.println();
    Flux.just(1, 2, 3, 4, 5, 6).subscribe(System.out::print, System.out::println, () -> System.out.println("Completed"));
    Mono.just(100).subscribe(System.out::println);
}

执行结果

11:04:52.073 [main] DEBUG reactor.util.Loggers$LoggerFactory - Using Slf4j logging framework
123456
123456Completed
100

map和filter

@Test
public void test4() {
    Flux.fromIterable(Arrays.asList(1, 2, 3, 4, 5, 6))
            .filter(i -> i % 2 == 0)//过滤
            .map(i -> i * i)//与map reduce中的map类型,逐个元素计算
            .subscribe(System.out::println);
}

输出结果

4
16
36

Flux.just(1, 2, 3, 4, 5, 6)仅仅声明了这个数据流,此时数据元素并未发出,只有subscribe()方法调用的时候才会触发数据流。订阅前什么都不会发生

flatMap

/**
     * flatMap操作可以将每个数据元素转换/映射为一个流,然后将这些流合并为一个大的数据流。
     * 流的合并是异步无序的
     *
     * @throws InterruptedException
     */
    @Test
    public void test5() throws InterruptedException {
        Flux.just("flux", "mono")
                .flatMap(s -> Flux.fromArray(s.split("\\s*"))//java中的future可以用这个替换。比如多个请求合并,串行改并行
                        .delayElements(Duration.ofMillis(100)))
                .subscribe(System.out::println);
        TimeUnit.SECONDS.sleep(1);//主线程阻塞1秒,因为是异步的,如果不阻塞则会等不到上面处理结果程序就结束了
    }

输出结果

f
m
l
o
u
n
x
o

如果一个服务中需要调用多个独立的外部服务,然后组装结果返回。这种情况过去通常使用future,学习了reactor以后就可以使用flux的flatMap方法来实现了。

异常

@Test
    public void test2() {
        Mono.error(new Exception("my error")).subscribe(
                System.out::print,
                System.out::println,
                () -> System.out.println("Completed"));
    }

输出java.lang.Exception: my error

StepVerifier单元测试

响应式异步编程最麻烦的就是调试了。这里简单介绍一下使用StepVerifier进单元行测试。

@Test
public void testViaStepVerifier() {
    StepVerifier.create(Flux.just(1, 2, 3, 4, 5, 6))
            .expectNext(1, 2, 3, 4, 5, 6)//下一个期望的数据元素
            .expectComplete()//测试下一个元素是否为完成信号
            .verify();
    StepVerifier.create(Mono.error(new Exception("some error")))
            .expectErrorMessage("some error")//校验下一个元素是否为错误信号
            .verify();
}

Flux.interval 无限流

Flux.interval(Duration) 生成的是一个 Flux, 是一个无限地周期性发出规律 tick 的时钟序列。

@Test
    public void test7() throws InterruptedException {
        Flux.interval(Duration.ofSeconds(1))
                .map(aLong -> "a" + aLong) // 类似于map reduce 中的map,对flux发出的消息逐个处理
                .subscribe(System.out::println);
        TimeUnit.SECONDS.sleep(10);
    }

这里设置了每隔1秒生成一个Long数据。由于这里sleep了10秒,所以会输出a0-a9。

zip压缩: 一对一合并数据流

@Test
    public void testSimpleOperators() throws InterruptedException {
        String desc = "zip: 将多个流一对一的合并起来";
        // 使用这个来控制程序结束,替换之前的sleep操作
        CountDownLatch countDownLatch = new CountDownLatch(1);  
        Flux.zip(
                Flux.fromArray(desc.split("\\s+")),
                // 使用Flux.interval声明一个每1000ms发出一个元素的long数据流;因为zip操作是一对一的,故而将其与字符串流zip之后,字符串流也将具有同样的速度;
                Flux.interval(Duration.ofMillis(1000)))  
                // zip之后的流中元素类型为Tuple2,使用getT1方法拿到字符串流的元素
                .subscribe(t -> System.out.println(t.getT1() + "  " + t.getT2()), null, countDownLatch::countDown);    
        countDownLatch.await();     // 5
    }

输出

Reactor  0
is  1
a  2
fully  3
non-blocking  4
reactive  5
//省略后续输出

使用zip将连个输出流进行压缩,一对一的组装成新的数据流。由于其中一个数据流树一秒发送一个,所以合并后的数据流也具有了相同的速度。

Schedulers线程池

Reactor, 就像 RxJava,也可以被认为是 并发无关(concurrency agnostic) 的。意思就是, 它并不强制要求任何并发模型。更进一步,它将选择权交给开发者。不过,它还是提供了一些方便 进行并发执行的库。

在 Reactor 中,执行模式以及执行过程取决于所使用的 Scheduler。 Scheduler 是一个拥有广泛实现类的抽象接口。 Schedulers 类提供的静态方法用于达成如下的执行环境:

当前线程(Schedulers.immediate())

可重用的单线程(Schedulers.single())。注意,这个方法对所有调用者都提供同一个线程来使用, 直到该调度器(Scheduler)被废弃。如果你想使用专一的线程,就对每一个调用使用 Schedulers.newSingle()。

弹性线程池(Schedulers.elastic()。它根据需要创建一个线程池,重用空闲线程。线程池如果空闲时间过长 (默认为 60s)就会被废弃。对于 I/O 阻塞的场景比较适用。 Schedulers.elastic() 能够方便地给一个阻塞 的任务分配它自己的线程,从而不会妨碍其他任务和资源,见 如何包装一个同步阻塞的调用?。

固定大小线程池(Schedulers.parallel())。所创建线程池的大小与 CPU 个数等同。

使用Schedulers将同步阻塞的getStringSync方法提交到异步线程池中执行:

/**
     * Schedulers线程池
     *
     * @return
     */
    private String getStringSync() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "Hello, Reactor!";
    }

    @Test
    public void testSyncToAsync() throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(1);
        Mono.fromCallable(() -> getStringSync())    // 声明一个异步回调的mono
                .subscribeOn(Schedulers.elastic())  // 将任务提交到内置的弹性线程池中执行
                .subscribe(System.out::println, null, countDownLatch::countDown);
        countDownLatch.await();
    }

切换调度器

Reactor 提供了两种在响应式链中调整调度器 Scheduler的方法:publishOn和subscribeOn。它们都接受一个 Scheduler作为参数,从而可以改变调度器。
但是两者的作用范围是不同的,具体情况代码注释:

/**
     * 切换调度器的操作符
     * 

* publishOn会影响链中其后的操作符,比如第一个publishOn调整调度器为elastic,则filter的处理操作是在弹性线程池中执行的; * 同理,flatMap是执行在固定大小的parallel线程池中的; * subscribeOn无论出现在什么位置,都只影响源头的执行环境,也就是range方法是执行在单线程中的, * 直至被第一个publishOn切换调度器之前,所以range后的map也在单线程中执行。 * * @throws InterruptedException */ @Test public void test6() throws InterruptedException { CountDownLatch countDownLatch = new CountDownLatch(1); Flux.range(1, 1000) .map(i -> i * i) .publishOn(Schedulers.elastic()).filter(i -> i % 2 == 0) .publishOn(Schedulers.parallel()).flatMap(i -> Flux.just(i).delayElements(Duration.ofMillis(1000))) .subscribeOn(Schedulers.single()) .subscribe(System.out::println, null, countDownLatch::countDown); countDownLatch.await(); }

异常处理

直接中断输出

/**
     * 异常处理
     * 错误和完成两个都是终止符,不可同时存在
     */
    @Test
    public void testErrorHandling() {
        Flux.range(1, 6)
                .map(i -> 10 / (i - 3)) // 1
                .map(i -> i * i)
                .subscribe(System.out::println, System.err::println, () -> System.err.println("ok"));
    }

输出:

25
100
java.lang.ArithmeticException: / by zero

错误和完成两个都是终止符,不可同时存在

onErrorReturn提供缺省值

onErrorReturn方法能够在收到错误信号的时候提供一个缺省值。此时终止信号不是error,而是complete

@Test
    public void testErrorHandling1() {
        Flux.range(1, 6)
                .map(i -> 10 / (i - 3)) // 1
                .onErrorReturn(0)
                .map(i -> i * i)
                .subscribe(System.out::println, System.err::println, () -> System.err.println("ok"));
    }

输出

25
100
0    //这个是出错后的缺省值
ok  //终止信号编程了complete!!

onErrorResume

onErrorResume:在收到错误信号的时候提供一个新的数据流。
可用于fallback处理, 类似于hystrix的fallback。或者类似于读取不到缓存则读取DB。

@Test
    public void testErrorHandling2() {
        Flux.range(1, 6)
                .map(i -> 10 / (i - 3))
                .onErrorResume(e -> Mono.just(new Random().nextInt(6))) // 提供新的数据流
                .map(i -> i * i)
                .subscribe(System.out::println, System.err::println, () -> System.err.println("ok"));
    }

输出

25
100
25  //这个是新的数据源,或者说重新执行错误信号
ok  //这里终止信号是complete

onErrorMap捕获异常

onErrorMap可以捕获异常,并再包装为某一个业务相关的异常,然后再抛出业务异常

public Flux callExternalService(String str) {
        return Flux.range(1, 6)
                .map(i -> 10 / (i - 3)) // 1
                .map(i -> i * i);
    }
    /**
     * 捕获,并再包装为某一个业务相关的异常,然后再抛出业务异常
     * @throws InterruptedException
     */
    @Test
    public void testErrorHandling3() throws InterruptedException {
        Flux.just("a")
                .flatMap(k -> callExternalService(k))
                // 重新包装
                .onErrorMap(original -> new Exception("business  error"))
                .subscribe(System.out::println, System.err::println, () -> System.err.println("ok"));
        TimeUnit.SECONDS.sleep(2);
    }

输出

25
100
java.lang.Exception: business  error

捕获异常,不做处理

这里写一个捕获异常,记录错误日志,然后继续抛出的例子。

doOnXxx是只读的,对数据流不会造成影响

@Test
    public void testErrorHandling4() {
        Flux.range(1, 6)
                .map(i -> 10 / (i - 3))
                .doOnError(throwable -> log.error(throwable.getMessage()))
                .map(i -> i * i)
                .subscribe(System.out::println, System.err::println, () -> System.err.println("ok"));
    }

输出

25
100
11:35:19.195 [main] ERROR helloworld.MyTest - / by zero     //这个是log.error打印的
java.lang.ArithmeticException: / by zero

doFinally

doFinally在序列终止(无论是 onComplete、onError还是取消)的时候被执行

@Test
    public void testErrorHandling5() {
        Flux.range(1, 6)
                .map(i -> 10 / (i - 3)) // 1
                .map(i -> i * i)
                .doFinally(type -> {//doFinally在序列终止(无论是 onComplete、onError还是取消)的时候被执行
                    if (type == SignalType.CANCEL)  // 2
                        log.info("SignalType.CANCEL");
                    else if(type == SignalType.ON_ERROR)
                        log.info("SignalType.ON_ERROR");
                })
                .take(1)//能够在发出N个元素后取消流。
                .subscribe(System.out::println, System.err::println, () -> System.err.println("ok"));
    }

输出

25
11:37:05.735 [main] INFO helloworld.MyTest - SignalType.CANCEL
ok

背压

背压(backpressure) 具体来说即 消费者能够反向告知生产者生产内容的速度的能力

订阅者可以无限接受数据并让它的源头 “满负荷”推送所有的数据,也可以通过使用 request 机制来告知源头它一次最多能够处理 n 个元素

上游数据源可以根据下游处理的速度进行生产数据,其实是一种“推送+拉取”的混合模式。

我们通过BaseSubscriber来实现该功能。前面讲到的所有subscribe方法都最终会转换为subscribe(BaseSubscriber)来执行。hookOnSubscribe和hookOnNext方法时必须要重写的,保证至少获取一个上游发送的一条数据。hookOnSubscribe用来获取第一个元素,hookOnNext配合request来逐个获取剩下的元素。

/**
     * 背压测试:
     * BaseSubscriber 是顶层的抽象类,上面介绍的所有subscribe方法最终都会转化为 subscribe(BaseSubscriber)执行
     * BaseSubscriber 最少要重写hookOnSubscribe和hookOnNext
     */
    @Test
    public void testBackpressure() {
        Flux.range(1, 6)
                .doOnRequest(n -> System.out.println("Request " + n + " values..."))
                .subscribe(new BaseSubscriber<>() {
                    @Override
                    protected void hookOnSubscribe(Subscription subscription) {
                        System.out.println("Subscribed and make a request...");
                        request(1); //发起第一个请求
                    }

                    @Override
                    protected void hookOnNext(Integer value) {  // 逐个处理剩余请求
                        try {
                            TimeUnit.SECONDS.sleep(1);  // 模拟耗时操作
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("Get value [" + value + "]");
                        request(1); // 随着接收到新的值,我们继续以每次请求一个元素的节奏从源头请求值。  这是背压核心
                    }
                });
    }

输出

Subscribed and make a request...
Request 1 values...
Get value [1]
Request 1 values...
Get value [2]
Request 1 values...
Get value [3]
Request 1 values...
Get value [4]
Request 1 values...
Get value [5]
Request 1 values...
Get value [6]
Request 1 values...

总结

从命令式编程到响应式编程的切换并不是一件容易的事,需要一个适应的过程。不过相信你通过本节的了解和实操,已经可以体会到使用Reactor编程的一些特点:

  • 相对于传统的基于回调和Future的异步开发方式,响应式编程更加具有可编排性和可读性,配合lambda表达式,代码更加简洁,处理逻辑的表达就像装配“流水线”,适用于对数据流的处理;
  • 在订阅(subscribe)时才触发数据流,这种数据流叫做“冷”数据流,就像插座插上电器才会有电流一样,还有一种数据流不管是否有订阅者订阅它都会一直发出数据,称之为“热”数据流,Reactor中几乎都是“冷”数据流;
  • 调度器对线程管理进行更高层次的抽象,使得我们可以非常容易地切换线程执行环境;
  • 灵活的错误处理机制有利于编写健壮的程序;
  • “回压”机制使得订阅者可以无限接受数据并让它的源头“满负荷”推送所有的数据,也可以通过使用request方法来告知源头它一次最多能够处理 n 个元素,从而将“推送”模式转换为“推送+拉取”混合的模式。

springboot系列学习笔记全部文章请移步值博主专栏**: spring boot 2.X/spring cloud Greenwich。
由于是一系列文章,所以后面的文章可能会使用到前面文章的项目。springboot系列代码全部上传至GitHub:https://github.com/liubenlong/springboot2_demo
本系列环境:Java11;springboot 2.1.1.RELEASE;springcloud Greenwich.RELEASE;MySQL 8.0.5;

你可能感兴趣的:(springboot,spring,boot,2.X/spring,cloud,Greenwich)