1. リアクティブプログラミングの概要
1.1 背景知識
同時実行性の高いサーバー側の開発シナリオに対処するために、Microsoft は 2009 年に、非同期プログラミングを実装するためのより洗練された方法であるリアクティブ プログラミング (これをリアクティブ プログラミングと呼んでいます) を提案しました。その後、Netflix や LightBend が RxJava や Akka Stream などのテクノロジーを提供し、Java プラットフォームにもリアクティブ プログラミングを実装できるフレームワークが備わるようになりました。
2017 年 9 月 28 日、Spring 5 が正式にリリースされました。Spring 5 のリリースの最大の意義は、リアクティブ プログラミング テクノロジの普及が大きく前進したことです。同時に、Spring 5 リアクティブ プログラミングをサポートするフレームワークである Spring Reactor もマイルストーン バージョン 3.1.0 に入りました。
1.2 リアクティブプログラミングとは
リアクティブ プログラミングは、データ フローと変更の伝播を重視したプログラミング パラダイムです。これは、静的または動的データ フローをプログラミング言語で簡単に表現でき、関連するコンピューティング モデルがデータ フローを通じて変化する値を自動的に伝播することを意味します。
リアクティブ プログラミングは、リアクター (Reactor は Java8 上で動作するリアクティブ フレームワーク) の考え方に基づいており、返される前に一定の遅延を持って io 操作を実行すると、ブロックされずにすぐにストリームを返します。そして、このストリームにサブスクライブします。このストリームで戻りデータが生成されると、すぐに通知され、コールバック関数を呼び出してデータを処理できます。
スプレッドシート プログラムはリアクティブ プログラミングの一例です。セルにはリテラル値または「=B1+C1」のような数式を含めることができ、数式を含むセルの値は他のセルの値の変化に基づいて変化します。
応答性の高い通信の中核機能の 1 つは次のとおりです。 変更の伝播: セルが変更されると、ドミノのように、セルを直接および間接的に参照する他のセルにも対応する変更が発生します。
1.3 Reactorに基づく実装
Reactor は、Java 8 上で実行され、Reactice 仕様を満たしているリアクティブ フレームワークであり、リアクティブ スタイルの API のセットを提供します。
Reactor には Flux と Mono という 2 つのコア クラスがあり、どちらも Publisher インターフェイスを実装します。
Flux は RxJava の Observable に似ており、実際の状況に応じて 0 ～ 複数のイベントをトリガーし、処理を終了したりエラーをトリガーしたりできます。
Mono は最大でも 1 つのイベントしかトリガーできないため、Mono を使用して非同期タスクが完了したことを通知できます。
Flux と Mono はどちらもデータ ストリームのパブリッシャーです。Flux と Mono はどちらも 3 つのデータ信号を送信できます: 要素値、エラー信号、完了信号です。エラー信号と完了信号は両方とも終了信号を表し、終了信号はサブスクライバーに通知するために使用されますストリームが終了すると、エラー信号によってデータ フローが終了し、エラー メッセージが加入者に配信されます。
3 つの信号の特徴:
エラー信号と完了信号は両方とも終了信号であり、共存できません。
要素値が送信されず、エラー信号または完了信号が直接送信された場合は、データ ストリームが空であることを意味します。
エラーがない場合は、信号はありますが、完了信号はありません。これは、無制限のデータ ストリームであることを意味します。
Mono の回路図は次のとおりです。
磁束の概略図は次のとおりです。
上の 2 つの図を組み合わせると、Mono と Flux が非常に似ていることがわかります。Mono は 1 つの要素のみを受け取りますが、Flux は複数の要素を受け取ります。
2. サンプルコード
2.1 モノラル
package com.reactor.demo;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import reactor.core.publisher.Mono;
import java.time.Duration;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
@Slf4j
public class MonoTest {
@Test
public void test1() {
//just用法
Mono.just("hello world").subscribe(System.out::println);
//runnable创建mono
Mono<Void> sinkMono = Mono.fromRunnable(() -> System.out.println("runnable"));
//这句不会输出
sinkMono.doOnNext(unused -> System.out.println("void success"));
//这句也不会输出
sinkMono.subscribe(o -> System.out.println("void result" + o));
//创建一个不包含任何元素，只发布结束消息的序列。，这里的hello empty是不会输出的。
Mono.empty()
//输出“empty的入参是null”
.doOnSuccess(o -> System.out.println("empty的入参是" + o))
//这句不会输出
.subscribe(o -> System.out.println("hello empty"));
//empty里面至少还有一个结束消息，而never则是真的啥都没有。"never的入参是"不会输出 ，这里的hello never也不会输出
Mono.never().doOnSuccess(o -> System.out.println("never的入参是" + o)).subscribe(o -> System.out.println("hello never"));
}
@Test
public void test2() {
//传入supplier
Mono.fromSupplier(() -> "Hello supplier").subscribe(System.out::println);
//传入optional
Mono.justOrEmpty(Optional.of("Hello optional")).subscribe(System.out::println);
//通过sink来创建一个正常执行的Mono
Mono.create(sink -> sink.success("Hello sink")).subscribe(System.out::println);
//通过sink来创建一个抛出异常的Mono
Mono.create(sink -> sink.error(new RuntimeException("sink error"))).subscribe(System.out::println);
//defer的入参实际上是一个Mono工厂
Mono.defer(() -> Mono.just("hello defer")).subscribe(System.out::println);
}
@Test
public void test3() {
//callable，有返回值
Mono.fromCallable(() -> "callable").subscribe(System.out::println);
//runnable无返回值
Mono<Void> mono = Mono.fromRunnable(() -> System.out.println("run"));
//下面的hello runnable是不会输出的。因为subscribe一个Mono<Void>,不会产生任何结果
mono.subscribe(o -> System.out.println("hello runnable"));
}
@Test
public void test4() {
//延迟3秒输出
Mono.delay(Duration.ofSeconds(3)).doOnNext(new Consumer<Long>() {
@Override
public void accept(Long aLong) {
System.out.println(aLong);
}
}).block();
}
@Test
public void test5() {
//直接输出了异常
Mono.error(new RuntimeException("这是一个异常")).subscribe(new Consumer<Object>() {
@Override
public void accept(Object o) {
System.out.println("error:" + o);
}
});
Mono.defer(() -> {
return Mono.error(new RuntimeException("这是第二个异常"));
}).subscribe(new Consumer<Object>() {
@Override
public void accept(Object o) {
System.out.println("defer error:" + o);
}
});
}
@Test
public void test6() {
//通过map可以对元素进行转换
Mono.just("just one").map(new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return 1;
}
}).doOnNext(new Consumer<Integer>() {
@Override
public void accept(Integer integer) {
System.out.println("转换后的结果：" + integer);
}
}).subscribe();
}
}
2.1 フラックス
package com.reactor.demo;
import org.junit.Test;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.Duration;
import java.util.Arrays;
import java.util.function.Consumer;
public class FluxTest {
/**
* 基本用法
*/
@Test
public void test1() {
//通过just传入可变的参数，依次输出
Flux.just("hello", "world", "just").doOnNext(System.out::println)
.doOnComplete(() -> System.out.println("just over")).subscribe();
//传入一个范围
Flux.range(100, 10)
.doOnNext(System.out::println).doOnComplete(() -> System.out.println("OK")).subscribe();
//传入list
Flux.fromIterable(Arrays.asList("01", "02", "03")).doOnNext(System.out::println).subscribe();
//传入一个数组
Flux.fromArray(new Object[]{
"obj1", "obj2"}).doOnNext(System.out::println).subscribe();
}
/**
* 处理空值
*/
@Test
public void testEmpty() {
//如果序列是个空的，就给个默认值
Flux.empty().defaultIfEmpty(1).doOnNext(System.out::println).subscribe();
//如果序列是空的，就用新序列代替
Flux.empty().switchIfEmpty(Mono.just("100")).doOnNext(System.out::println).subscribe();
}
/**
* 序列在执行时的一些监听方法doOnXXXX
*/
@Test
public void testDoOn() {
System.out.println("----------");
Flux.range(100, 10)
.doOnNext(System.out::println).doOnComplete(() -> System.out.println("OK"));
System.out.println("----------");
Flux.range(100, 10).doFirst(() -> System.out.println("第一个执行开始")).subscribe();
System.out.println("----------");
Flux.range(100, 10).doFinally(it -> System.out.println("终止信号的类型为" + it.name())).subscribe();
System.out.println("----------");
Flux.range(100, 10).doOnSubscribe(it -> System.out.println("该序列已被订阅")).subscribe();
System.out.println("----------");
Flux.range(100, 10).doOnRequest(value -> System.out.println("doOnRequest:" + value)).subscribe();
//在完成或者error时，也就是序列终止时执行runnable
System.out.println("----------");
Flux.range(100, 10).doOnTerminate(() -> System.out.println("doOnTerminate")).subscribe();
//doOnEach每次向下游传播，都会得到一个信号类型，可以根据该信号类型执行一些操作
System.out.println("----------");
Flux.range(100, 10).doOnEach(it -> System.out.println("doOnEach:" + it)).subscribe();
}
/**
* filter用法
*/
@Test
public void testFilter() {
System.out.println("----------");
//将上游的数据进行类型判断，符合该类型的数据将流向下游
Flux.just(new Object(), "Hello", 1)
.ofType(String.class).doOnNext(System.out::println)
.doOnComplete(() -> System.out.println("过滤String示例")).subscribe();
System.out.println("----------");
//过滤数据
Flux.range(100, 10)
.filter(it -> it > 105)
.doOnComplete(() -> System.out.println("取出大于105示例")).subscribe();
System.out.println("----------");
//将重复数据过滤,重复数据在整个序列中只保留一个
Flux.range(100, 10)
.concatWith(Flux.just(100, 100, 100))
.distinct().doOnNext(System.out::println)
.doOnComplete(() -> System.out.println("去除重复数字示例")).subscribe();
System.out.println("----------");
//将后来的重复数据过滤，如下，第二个flux拼接到第一个序列时，只会把第二个元素本身的重复元素过滤
Flux.range(100, 10)
.concatWith(Flux.just(100, 100, 100))
.distinctUntilChanged().doOnNext(System.out::println)
.doOnComplete(() -> System.out.println("将后来的重复数据过滤")).subscribe();
System.out.println("----------");
//在序列的开始获取5个元素，
// limitRequest为true时，则不管该序列会发射多少元素，该参数会向上传递背压，则上游序列只会发出设定的5个元素
//为false时，则不控制上有元素可以发出N个元素
Flux.range(100, 10).take(5, false)
.doOnComplete(() -> System.out.println("在序列的开始获取5个元素")).subscribe();
System.out.println("----------");
//参数为时间单位，意味着take获取元素，只会在该时间限制内获取。
Flux.range(100, 10).take(Duration.ofSeconds(10))
.doOnNext(new Consumer<Integer>() {
@Override
public void accept(Integer integer) {
System.out.println("当前时间戳为：" + System.currentTimeMillis() + "，数字为：" + integer);
}
})
.doOnComplete(() -> System.out.println("在指定时间内获取元素"))
.subscribe(System.out::println);
System.out.println("----------");
//获取最后的N位元素
Flux.range(100, 10).takeLast(2)
.doOnComplete(() -> System.out.println("获取最后的2位元素"))
.subscribe(System.out::println);
System.out.println("----------");
//获取元素，知道符合条件后停止向下游发送数据,包括条件本身，也就是当it>105的元素也会被发布至下游
Flux.range(100, 10).takeUntil(it -> it > 105)
.doOnComplete(() -> System.out.println("一直取数，直到大于105结束"))
.subscribe(System.out::println);
System.out.println("----------");
//获取元素，当元素符合该断言时，如果不符合直接终止,不包含条件本身
Flux.range(100, 10).takeWhile(it -> it < 105)
.doOnComplete(() -> System.out.println("取出小于105示例"))
.subscribe(System.out::println);
System.out.println("----------");
//获取指定某个位置的一个元素
Flux.range(100, 10).elementAt(0)
.doOnSuccess(new Consumer<Integer>() {
@Override
public void accept(Integer i) {
System.out.println("获取指定某个位置的一个元素:" + i);
}
})
.subscribe();
System.out.println("----------");
//获取最后一个元素，last()如果为空则抛出异常，last(1)如果为空则发出默认值
Flux.range(100, 10)
.takeWhile(it -> it > 105).last(1)
.subscribe(System.out::println);
System.out.println("----------");
//跳至第几秒开始执行
Flux.range(100, 10)
.skip(Duration.ofSeconds(5)).subscribe(System.out::println);
System.out.println("----------");
//跳至第几个元素开始执行
Flux.range(100, 10)
.skip(5).subscribe(System.out::println);
System.out.println("----------");
//从开始跳到最后第N个元素结束
Flux.range(100, 10).skipLast(5).subscribe(System.out::println);
System.out.println("----------");
//跳至满足条件的地方开始执行,从第一个元素开始，知道满足条件，开始发送至下游
Flux.range(100, 10).skipUntil(it -> it > 105).subscribe(System.out::println);
System.out.println("----------");
//每隔一段时间抽取样本数(取在这个时间的最后一个元素)，如果相隔实现大于序列的执行时间，则去最后一元素
Flux.range(100, 100000000).sample(Duration.ofMillis(100)).subscribe(System.out::println);
System.out.println("----------");
//每隔一段时间抽取样本数(取在这个时间的第一个元素)，如果相隔实现大于序列的执行时间，则取第一个元素
Flux.range(100, 10).sampleFirst(Duration.ofMillis(100)).subscribe(System.out::println);
System.out.println("----------");
//只获取一个元素，single()如果为空或者超多一个，抛出异常，single(1)如果为空返回默认值，如果多个抛出异常,singleOrEmpty()可以允许为空
Flux.range(100, 10).single(1).subscribe(System.out::println);
}
/**
* 当被订阅后如果发生异常，则stream会停止运行
* 此时可以通过处理error来决定如何处理异常
* 可以将异常跳过、将异常替换等
*/
@Test
public void testErrorHandle() {
System.out.println("----------");
Flux.just(1, 2, 3, 0, 5, 4).map(it -> {
it = 100 / it;
return it;
})
//报错后返回，并停止运行
.onErrorResume(e -> {
return Mono.just(10000);
})
.doFinally(type -> {
System.out.println(type);
})
.subscribe(System.out::println);
System.out.println("----------");
Flux.just(1, 2, 3).doOnNext(new Consumer<Integer>() {
@Override
public void accept(Integer integer) {
System.out.println(integer);
if (integer == 2) {
throw new RuntimeException("触发异常");
}
}
}).doOnError(new Consumer<Throwable>() {
@Override
public void accept(Throwable throwable) {
System.out.println("doOnError：" + throwable.getMessage());
}
}).subscribe();
System.out.println("----------");
Flux.just(1, 2, 3, 0, 5, 4).map(it -> {
it = 100 / it;
return it;
})
//报错后继续运行，并执行相关操作
.onErrorContinue((e, it) -> {
System.out.println(e.getMessage());
})
.doFinally(type -> {
System.out.println(type);
})
.subscribe(System.out::println);
}
@Test
public void flatMapTest() {
//输出50，100
Flux.just(5, 10).flatMap(x -> Flux.just(x * 10)).toStream().forEach(System.out::println);
}
}