JJUG CCC 2018 Fall Lightning Talk

1. Spring WebFluxを
簡単に書きたい
前多（twitter @kencharos）
JJUG CCC 2018 Fall LT

2. About Me
• 設計と実装してる人
• Java ときどき C#
• 最近
• 「GraalVM の native image を使って Java で爆速
Lambda の夢を見る」
• https://qiita.com/kencharos/items/69e43965515f368bc4a3

3. WebFlux の使いどころ
• 複数の非同期処理のフローを簡単に記述できる
• 例えば 3つの WebAPI 呼び出しを順番に呼び出
したり、一部を並行（同時）にしたり、、
“hello” “world” “!!!"
“hello”
“world”
“!!!”
//WebAPI 呼び出しの例
public Mono<String> callApi() {
return WebClient.create("http://xxxxx/hello")
.get().retrieve().bodyToMono(String.class);
}

4. APIを逐次実行にする例
• flatMap で3つのMonoを順次実行
@GetMapping("/java/rx_seq")
public Mono<String> Seq() { // 逐次実行
Mono<String> hello = helloApi.callApi();
Mono<String> world = worldApi.callApi();
Mono<String> exclamation = exclamationApi.callApi();
return hello
.flatMap(h -> world
.flatMap(w -> exclamation
.map(e -> h + w + e)));
}

5. APIの一部を並行にする例
• Zip で2つのMonoを待ち合わせして、その後
flatMap
@GetMapping("/java/rx_seq")
public Mono<String> Par() { // 一部並列実行
Mono<String> hello = helloApi.callApi();
Mono<String> world = worldApi.callApi();
Mono<String> exclamation = exclamationApi.callApi();
return Mono.zip(hello, world)
.flatMap(hw -> exclamation
.map(e -> hw.getT1() + hw.getT2() + e));
}

6. 本当に簡単?
• スレッドとかブロッキングとかを考えなくてい
いので楽
• @Async とか使わなくていいので楽
• 非同期処理の待ち合わせも楽
• とはいえ、従来のプログラムの書き方とは結構
違う
• flatMap がネストしだすと少々見づらい
• もっと楽にできないか??

7. Kotlin のコルーチンを使う
• コルーチンは処理を途中で止めたり再開したり
する機能
• Java だと Project Loom の Fiberで入るかも?
• コルーチンはKotlin1.3 から標準化
• Spring5 から Kotlin 正式対応
• Reactor のコルーチン対応ライブラリ
kotlinx-coroutines-reactor がある

8. コルーチンで逐次処理の例
• mono スコープと awaitXxx を使うと
複数のMonoを一つに結合できる
@GetMapping("seq")
fun seqWithCoroutine():Mono<String> = GlobalScope.mono {
// awaitFirst で、 Monoを コルーチンに
val hello: String = helloApi.callApi().awaitFirst()
val world: String = worldApi.callApi().awaitFirst()
val exclamation: String = exclamationApi.callApi().awaitFirst()
"$hello $world $exclamation"
}
monoスコープ
で囲む
MonoにawaitFirstでコルーチン化。
Monoの中の結果のString を取得で
きる
この値(3 APIの呼び出し結果の連結)が
最終的な戻り値になる

9. コルーチンで並行化の例
• asyncで一部を非同期実行できる
@GetMapping("par")
fun parWithCoroutine():Mono<String> = GlobalScope.mono {
// start helloApi and worldApi tasks in asynchronous.
val helloDeferred = async { helloApi.callApi().awaitFirst() }
val worldDeferred = async { worldApi.callApi().awaitFirst() }
// join 2 tasks
val hello: String = helloDeferred.await()
val world: String = worldDeferred.await()
val exclamation = exclamationApi.callApi().awaitFirst()
"$hello $world $exclamation"
}
async スコープ
で非同期処理
開始
非同期処理の
結果は await
で取得

10. コルーチンの Pros/Cons
• Pros
• 同期処理っぽく書ける(flatMapが消えた)
• 通常の kotlinの制御構文が使える(if, for, try/catch)
• JavaScript/C# の async/await に近い感じ
• async でカジュアルに一部を非同期処理にできる
• Cons
• awaitの呼び出しごとに Rxの subscribe が実行されて
いる
• Rx の文脈をコルーチンの非同期処理に置き換えてしまう
• 他には?

11. Arrowライブラリを使う
• https://arrow-kt.io/
• Scala の関数型ライブラリ Scalaz, Cats のような
関数型プログラミングの機能(モナドとか)を
Kotlinに持ち込む
• Reactor 用の拡張を使うと、 Mono, Flux を
MonoK, FluxK に変換して モナドにできる

12. Arrowで逐次処理の例
• 大体の記述はコルーチンと似ている
• bindingスコープ(モナド記法), k(), bind() を使う
@GetMapping("monad_seq")
fun seqWithMonad():Mono<String> = MonoK.monad().binding {
// K() is buidler from Mono to MonoK. MonoK is Monad of Mono in Arrow.
// bind() is flatMap as Coroutine.
val hello: String = helloApi.callApi().k().bind()
val world: String = worldApi.callApi().k().bind()
val exclamation: String = exclamationApi.callApi().k().bind()
"$hello $world $exclamation"
}.value()
K()でMonoを
MonoKに
value()で
MonoKをMono
に戻す
最終的な
戻り値
bind() でMono
の中の String
を取得できる

13. Arrow で並行処理
• Mono.zip で待ち合わせしたMonoをbindする
• Arrowだけで 並行化する方法を調査中
@GetMapping(“monad_par”)
fun parWithMonad():Mono<String> = MonoK.monad().binding {
val hMono = helloApi.callApi()
val wMono = worldApi.callApi()
// 並列化は Mono zip を使うしかないっぽい
val helloWorld = Mono.zip(hMono, wMono).map { it.t1 + it.t2 }.k().bind()
val exclamation = exclamationApi.callApi().k().bind()
"$helloWorld $exclamation"
}.value()

14. ArrowのPros/Cons
• Pros
• bindを使って、同期処理っぽく書ける
• bind 呼び出しは flatMap の呼び出しに置き換わるの
で Rx の文脈は保たれる
• Arrowの他の機能との統合（後述）
• モナド完全に理解した
• Cons
• モナド全然わからん
• 関数型プログラミングの理解が必須
• Mono.zip の代替手段が（今のところ）なさそう
• アプリカティブなだけの Monoがなさそう

15. ここまでまとめ
• Kotlinなら WebFlux が使いやすくなるかもよ
• バックプレッシャー周りは継続調査

16. (おまけ) Arrow の Either
• Either は成功か失敗かのどちらかの表現
• 例外の代わりに使うことが多い
• ArrowのEither はモナドなので合成可能
fun aToI(s:String):Either<NumberFormatException, Int> {
if (s.matches("^[0-9]+$".toRegex())) {
return Either.right(Integer.parseInt(s))
} else {
return Either.left(NumberFormatException("invalid string"))
}
}
val result = aToI("123")
when(result) {
is Either.Right -> print("OK " + result.b)
is Either.Left -> print("NG" + result.a.message)
}
Right(成功)
Left(失敗)

17. MonoKとEitherが組み合わさると
• 非同期処理の結果に Either を使って失敗の可能
性を表現したい場合、Mono(K)とEither を組み
合わせた型ができる
fun callApiOrError(name:String):MonoK<Either<Throwable, String>> {///}

18. モナドのネストは見づらい
• MonoKのbindでEither が取れてしまう
• EitherからStringを取るとモナドがネストする
val resEither = MonoK.monad().binding {
val helloEither:Either<Throwable, String> =
helloApi.callApiOrError(query).bind()
val worldEither = worldApi.callApiOrError(query).bind()
val exclamationEither = exclamationApi.callApiOrError(query).bind()
// モナドにモナドがダブってしまう
Either.monadError<Throwable>().binding {
val hello:String = helloEither.bind()
val world:String = worldEither.bind()
val exclamation:String = exclamationEither.bind()
"$hello $world $exclamation"
}.fix()
}.value()

19. EitherT で MonoK<Either> を合体する
• EitherT （モナドトランスフォーマー）を使う
と、モナドのネストが消え、従来通りにかける
• bind でMono, Eitherの両方を一発ではがす
• bindがどこかで失敗(=Either.Leftの発生)するとその
場で評価を停止し、MonoK(Either.Left)を返す
• 全て成功した場合は、MonoK(Either.Right)を返す
val result = EitherT.monad<ForMonoK, Throwable>(MonoK.monad()).binding {
val hello:String = EitherT(helloApi.callApiOrError(query)).bind()
val world:String = EitherT(worldApi.callApiOrError(query)).bind()
val exclamation = EitherT(exclamationApi.callApiOrError(query)).bind()
"$hello $world $exclamation"
}

20. 最終的な変換処理は必要
• 最終的に Mono<Either<T>> をちゃんと変換する
コードは必要
• 機械的に書ける内容なので、 Mono<Either<T>> をコ
ントローラの戻り値にして、Spring 側でハンドリン
グするようにできるはず
val res:Mono<Either<Throwable, String>> = result.fix().value().value()
return res.map { when(it){
is Either.Right -> ResponseEntity.ok().body(it.b)
is Either.Left -> ResponseEntity.badRequest().body(it.a.message)
} }

21. おしまい
• Kotlin + Arrow で Functional Reactive Spring の夢
が見よう！
• ソース
• https://github.com/kencharos/webflux-coroutine-
arrow-sample
• Arrow の Either についてはアドカレ書いてます
• https://qiita.com/kencharos/items/6fd0a9e92363b08c0340
• 「例外だけに頼らない Kotlinのエラーハンドリング」