SpringBootでSpring WebFluxを試してみた

# 背景・目的
過去に、Spring Bootについて下記の記事にまとめました。今回は、Spring WebFluxを試してみます。

- [Spring BootでDAOからデータベースにアクセスしてみた-その2（クライテリア）](https://qiita.com/zumax/items/0eab43e74eb76143530e)
- [Spring BootでDAOからデータベースにアクセスしてみた-その1（DAOとアノテーション）](https://qiita.com/zumax/items/4dd856cd108d23a15188)
- [Spring Bootでバリデーションを試してみた](https://qiita.com/zumax/items/f09bacf18f3bb96d1331)
- [Spring Bootでデータを保存する-その2](https://qiita.com/zumax/items/06d0465218478840a949)
- [Spring Bootでデータを保存する-その1](https://qiita.com/zumax/items/2e387254c736659bf20c)
- [Spring Bootでデータベースへのアクセスを試してみた](https://qiita.com/zumax/items/7487b86f56ea12c31d44)
- [Sprint Bootの環境を構築したときのメモ](https://qiita.com/zumax/items/8effa97f338dd0224b22)

# まとめ
下記に特徴をまとめます。
|特徴|説明|
|:--|:--|
|Spring WebFlux|・完全なノンブロッキング<BR>・Reactive Streamsバックプレッシャーをサポート<BR>・Netty、Undertow、サーブレットコンテナなどのサーバ上で実行される|
|リアクティブ|データストリームと変更の伝播に関係する宣言型 プログラミングの一種|
|ノンブロッキング|・プログラミング処理のこと<BR>・処理の進捗を確認しながら同時に並行して複数の処理が可能<BR>・入力に対して、待ち時間がないのでスループットが向上する|
|適用範囲|Spring MVC、WebFluxのどちらを利用するかということ。<BR>ただし、相互の継続性と一貫性を考慮して設計されており、並行して使用できる|
|使用できるサーバ|サーブレットコンテナ<BR>・Tocat<BR>・Jetty<BR>非サーブレットコンテナ<BR>・Netty<BR>・Undertow|
|パフォーマンス|リアクティブ&ノンブロッキングでは、アプリケーションの実行速度は向上しない<BR>WebClientを使って、リモート呼び出しを並列で実行すると、場合によっては高速化する<BR>ただし、ノンブロッキング方式で処理にするには、より多くの作業が必要になり、必要な処理時間はわずかに長くなる<BR><BR>メリットは、少数の固定スレッドと少ないメモリで拡張できる点|
|スレッドモデル|・サーバ用に1つのスレッド<BR>・リクエスト用に複数のスレッド（通常はCPUコアと同数）<BR><BR>これに対して、サーブレットコンテナでは、サーブレットI/O（ブロッキング）とサーブレット3.1（非ブロッキング）I/Oの両方をサポートするので、より多くのスレッドで開始される|
|設定|Spring Framework は、 サーバーの起動と停止をサポートしていない|

# 概要
[Spring WebFlux](https://docs.spring.io/spring-framework/reference/web/webflux.html)を基に整理します。

- Spring WebFluxは、Springバージョン5.0から追加された
- 完全なノンブロッキング
- Reactive Streamsバックプレッシャーをサポート
- Netty、Undertow、サーブレットコンテナなどのサーバ上で実行される
- spring-webmvcとspring-webfluxは、Spring Framework内で共存する

## Overview
### 背景
作成された背景について、下記に記載いたします。
1. 少数のスレッドで並行処理し、少ないHWリソースで拡張できるノンブロッキングWebスタックが必要だった
    - サーブレットAPIの場合、下記の特徴がある
        - 同期的なFilter、Servlet
        - ブロッキングなgetParameter、getPart
1. 関数型プログラミング
    - アノテーション（Java5）や、ラムダ式(Java8)などにより、非同期ロジックの宣言的構成を可能にする非ブロッキングアプリと継続APIによって恩恵がある

### リアクティブとは
[Reactive programming](https://en.wikipedia.org/wiki/Reactive_programming)を基に整理します。

- データストリームと変更の伝播に関係する宣言型 プログラミング
- リアクティブプログラミングは、インタラクティブなユーザーインターフェイスとほぼリアルタイムのシステムアニメーションの作成を簡素化する方法として提案されている
- リアクティブ プログラミングは、さまざまなモデルとセマンティクスによって制御される。これらは、次のとおり分類できる
    - 同期: 時間の同期モデルと非同期モデル
    - 決定論: 決定論的評価プロセスと非決定論的評価プロセスおよび結果
    - 更新プロセス:コールバックとデータフローとアクター
https://docs.spring.io/spring-framework/reference/web/webflux/new-framework.html

[Spring WebFlux>Overview](https://docs.spring.io/spring-framework/reference/web/webflux/new-framework.html)では、下記の記載もあります。

- ブロックされるのではなく、操作が完了したりデータが利用可能になったりしたときに通知に反応する


### ノンブロッキング
- ノンブロッキングはプログラミング処理のこと
- 処理の進捗を確認しながら同時に並行して複数の処理が可能
- 入力に対して、待ち時間がないのでスループットが向上する
- ブロッキングとノンブロッキングの比較は下記の通り

| |ブロッキング|ノンブロッキング|
|:--|:--|:--|
|処理の順序|逐次的に順番に処理|並列処理|
|待ち時間|処理の間で待ち時間が発生する|待ち時間は発生しない|

### Applicability
- Spring MVC or WebFlux？
- 相互の継続性と一貫性を考慮して設計されており、並行して使用できる

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/a38b9063-3aaa-ecf7-4f28-02cb3509a3d6.png)
※ 出典：[Spring WebFlux>Overview](https://docs.spring.io/spring-framework/reference/web/webflux/new-framework.html)

考慮点は、下記の通り
- すでにMVCアプリケーションが存在し問題ない場合は、そのままでよい
    - ほとんどのライブラリは、ブロッキングが前提であり、ライブラリの選択肢は豊富にある
- ノンブロッキングを探している場合、Spring WebFluxは、候補になり得る
    - サーバ
        - Netty
        - Tomcat
        - Jetty
        - Undertow
        - Servlet
    - プログラミングモデル
        - annotated controllers and functional web endpoints
    - アクティブライブラリ
        - Reactor
        - RxJava
- Java 8 ラムダ、Kotlinで使用する軽量かつ、機能的なWebフレームワークに関心がある場合、Spring WebFlux機能Webエンドポイントを使用できる
    - 透明性、制御性の向上によるメリットが得られる
    - 要件が複雑ではない小規模アプリやマイクロサービスにも適している
- Spring MVC、Spring WebFluxコントローラー、Spring WebFlux機能エンドポイントのいずれかを使用したアプリを混在できる
- blocking persistence APIs、ネットワークAPIを使用する場合は、一般的なアーキテクチャでは、Spring MVCが最適
    - ReactorとRxJavaの両方でブロッキング呼び出しを別スレッドで実行することは可能だが、ノンブロッキングのメリットを最大限活かせない
- リモートサービスへの呼び出しを含むSpring MVCがある場合、reactive Web Clientを試してみる
    - Spring MVCコントローラーのメソッドから、リアクティブ型（Reactor、RxJava等）を直接返せる
    - レイテンシーが大きい、相互依存性が大きいほどメリットは大きい
- 大規模なチームは、ノンブロッキング、関数型、宣言型プログラミングへの移行における学習曲線を意識すること
    - 小規模から始める。大規模に行わない。メリットを測定する

### Server
- Spring WebFluxでは、下記をサポートしている
    - サーブレットコンテナ
        - Tocat
        - Jetty
    - 非サーブレットコンテナ
        - Netty
        - Undertow
- Spring Bootでは、WebFluxスターターがある
    - スターターでは、Nettyを使用するが、Maven等を変更しTomcat等に切り替えることも可能
- TomcatとJettyは、Spring MVCとWebFluxの両方で使用できる
    - Spring MVCはサーブレットブロッキングI/Oに依存する
    - Spring WebFluxはサーブレットノンブロッキングに依存する
        - 低レベルアダプターの背後で、サーブレットAPIを使用する
- Undertowでは、Spring WebFluxはサーブレットAPIを使用せずに、Undetow APIを直接使用する

### パフォーマンス
- リアクティブ&ノンブロッキングでは、アプリケーションの実行速度は向上しない
    - WebClientを使って、リモート呼び出しを並列で実行すると、場合によっては高速化する
    - ただし、ノンブロッキング方式で処理にするには、より多くの作業が必要になり、必要な処理時間はわずかに長くなる
- メリットは、少数の固定スレッドと少ないメモリで拡張できる点

### Concurrency Model
- 並行性モデルと、ブロッキングとスレッドのデフォルトの想定には重要な違いがある
- Spring MVC
    - アプリケーションが、現在のスレッドをブロックできる事が前提
    - サーブレットコンテナは、リクエスト処理中に発生する可能性があるブロッキングを吸収するため、大きなスレッドプールを使用する
- Spring WebFlux
    - アプリケーションが、ブロッキングされないことが前提
    - ノンブロッキングサーバでは、小さな固定サイズのスレッドプールを使用してリクエストを処理する

#### ブロッキングAPIの呼び出し
- ブロッキングライブラリを使用するには、ReactorとRxJavaの両方で、別スレッド処理を続行するためのpublishOn演算子を用意している

#### Mutable State
- Reactor と RxJava では、演算子を使用してロジックを宣言する
- 実行時に、データが個別の段階で順番に処理されるリアクティブ パイプラインが形成される
- メリットは、パイプライン内のアプリケーション コードが、同時に呼び出されることがないため、アプリケーションが可変状態を保護する必要がなくなる

#### スレッドモデル
- Vanilla Spring WebFluxサーバでは、下記を想定している
    - サーバ用に1つのスレッド
    - リクエスト用に複数のスレッド（通常はCPUコアと同数）
    - サーブレットコンテナは、サーブレットI/O（ブロッキング）とサーブレット3.1（非ブロッキング）I/Oの両方をサポートするので、より多くのスレッドで開始される
- リアクティブ WebClientは、イベントループスタイルで動作する
    - それに関連する少数の固定された処理スレッドが表示される
    - Reactor Nettyがクライアントとサーバの両方に使用される場合、2つはデフォルトでイベントループリソースを共有する
- ReactorとRxJavaは、処理を別のスレッド プールに、切り替えるために使用されるpublishOn演算子で使用するスケジューラーと呼ばれるスレッドプールの抽象化を提供する
    - 同時実行戦略の名前がつけられる
        - 例えば、parallel、elastic
- データアクセスライブラリやその他のサードパーティの依存関係も、独自のスレッドを作成して使用できる


#### 設定
- Spring Framework は、 サーバーの起動と停止をサポートしていない
- サーバーのスレッド モデルを構成するには、サーバー固有の構成 API を使用するか、Spring Boot を使用する場合は、各サーバーの Spring Boot 構成オプションを確認する必要がある


# 実践
## 前提
1. VSCodeを起動します
1. コマンドパレッドを開きます
1. Spring Spring Initializrを選択します
1. 3.3.1を選択します
1. Javaを選択します
1. GroupIdとArtifactIdを設定します
1. packagetypeをJarとします
1. Javaのバージョンを17とします
1. Spring Reactive Webを選択します
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/faa98406-658e-4326-c05b-1626e4e1bf9f.png)
1. 追加されました
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/0b15d1ff-9d1e-12bf-9419-bc9de0a6a729.png)

## RestControllerの作成
とりあえず、最小構成で試してみます

### リクエストハンドラ
1. SampleRestController.javaを、SpringBootアプリケーションと同じパッケージに追加します
1. 下記のコードを追加します
    ```java
    package com.example.webflux.sample;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class SampleRestController {
      @RequestMapping("/")
      public String index() {
        return "Hello, World!";
      }
    
    }
    ```
### 動作確認
1. ビルドと起動します
    ```bash
    $ mvn package
    $ java -jar target/sample-0.0.1-SNAPSHOT.jar
    ```
1. ブラウザでlocalhost:8080を開きます。表示されました
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/1bcd6938-519e-0218-5e15-c0faaa31de9c.png)

## ノンブロッキング処理
WebFluxでは、処理をラップし、ノンブロッキングにする機能が用意されています。
「Flux」、「Mono」というノンブロッキングラッパーの機能があります。
それぞれは、下記の違いあります。
- Flux
    - 複数オブジェクトに対応
- Mono
    - 単一オブジェクに対応

### Mono
当該クラスは、単一オブジェクトを扱います。

#### リクエストハンドラ
1. 下記のコードを追加します
    - fluxメソッドを追加しています
    ```java
    package com.example.webflux.sample;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import reactor.core.publisher.Mono; // Add this import statement
    
    @RestController
    public class SampleRestController {
      @RequestMapping("/")
      public String index() {
        return "Hello, World!";
      }
    
      @RequestMapping("/flux")
      public Mono<String> flux() {
        return Mono.just("Hello, Flux(Mono).");
      }
    
    }
    ```
    - Mono.just
        - Monoはジェネリックスをサポート
        - 引数に指定したオブジェクトをラップしたMonoインスタンスが生成される
#### 確認
1. ビルドと起動します
    ```bash
    $ mvn package
    $ java -jar target/sample-0.0.1-SNAPSHOT.jar
    ```
1. ブラウザでlocalhost:8080を開きます。表示されました
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/69986fd2-e228-fc01-2d60-c65ceeb26c7b.png)


### Fluxクラス
当該クラスは、複数オブジェクトを扱います。

#### リクエストハンドラ
1. 下記のコードを追加します
    - flux2メソッドを追加しています
    ```java
    package com.example.webflux.sample;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import reactor.core.publisher.Mono; // Add this import statement
    import reactor.core.publisher.Flux; // Add this import statement
    
    @RestController
    public class SampleRestController {
      @RequestMapping("/")
      public String index() {
        return "Hello, World!";
      }
    
      @RequestMapping("/flux")
      public Mono<String> flux() {
        return Mono.just("Hello, Flux(Mono).");
      }
    
      @RequestMapping("/flux2")
      public Flux<String> flux2() {
        return Flux.just("Hello, Flux(Flux).","こんにちは、Fluxクラスです");
      }
    
    }
    ```

#### 確認
1. ビルドと起動します
    ```bash
    $ mvn package
    $ java -jar target/sample-0.0.1-SNAPSHOT.jar
    ```
1. ブラウザでlocalhost:8080を開きます。2つまとめて表示されました
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/863f1279-4895-46df-a34f-bc54f85c3a80.png)


## DBの利用
Spring Data JPAと、H2を使用してデータベースアクセスし、Mono/Fluxで利用する。
### ダミーデーターを利用する

#### pomの修正
1. JPAとH2をインストールします
    ```xml
		<dependency>
				<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>

		<dependency>
				<groupId>com.h2database</groupId>
				<artifactId>h2</artifactId>
				<scope>runtime</scope>
		</dependency>
    ```

#### エンティティの作成
1. ハンドラと同じ場所に、「Post.java」というファイルを作成します
1. 下記のコードを追加します
    ```java
    package com.example.webflux.sample;
    
    import jakarta.persistence.Column;
    import jakarta.persistence.Entity;
    import jakarta.persistence.GeneratedValue;
    import jakarta.persistence.GenerationType;
    import jakarta.persistence.Id;
    import jakarta.persistence.Table;
    
    @Entity
    @Table(name = "post")
    public class Post {
      @Id
      @GeneratedValue(strategy = GenerationType.AUTO)
      @Column
      public int id;
    
      @Column
      public int userId;
    
      @Column(nullable = false)
      public String title;
    
      @Column(nullable = false)
      public String body;
    
      public Post() {
        super();
      }
    
      public Post(int id, int userId, String title, String body){
        super();
        this.id = id;
        this.userId = userId;
        this.title = title;
        this.body = body;
      }
    
      public String toString(){
        return "{id:"+id+",userId:"+userId+",title:"+title+",body:"+body+"}";
      }
    
    
    }
    ```

#### リポジトリの作成
1. 上記のエンティティと同じ場所に「PostRepository.java」インタフェイスを配置します
1. 下記のコードを追加します
    ```java
    package com.example.webflux.sample;
    
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.stereotype.Repository;
    
    @Repository
    public interface PostRepository extends JpaRepository<Post, Integer> {
      public Post findById(int id);
    }
    ```
    - IDでレコードを取得するfindByIdメソッドを用意

#### リクエストハンドラを修正
1. 作成したリクエストハンドラに、下記のコードを追加します
    - PostRepositoryのインスタンス変数
    ```java
      @Autowired
      PostRepository repository;
    ```
    - postメソッド
    ```java
      @RequestMapping("/post")
      public Mono<Post> post(){
        Post post = new Post(0,0,"title-a","body-a");
        return Mono.just(post);
      }
    ```

#### 確認
1. ビルドと起動します
    ```bash
    $ mvn package
    $ java -jar target/sample-0.0.1-SNAPSHOT.jar
    ```
1. ブラウザでlocalhost:8080/postを開きます。ダミーで登録した内容が見えました
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/b0ff0d62-91a3-0a1a-10f3-ab5922c24afb.png)

### DBにアクセスする
#### ハンドラの修正
1. ハンドラに下記を追加します
    - initメソッドで初期データを登録します
    ```java
      @PostConstruct
      public void init() {
        Post post1 = new Post(1, 1, "Hello", "Hello Flux!");
        Post post2 = new Post(2, 2, "Sample", "This is sample post.");
        Post post3 = new Post(3, 3, "ハロー", "これはサンプルです");
        repository.saveAndFlush(post1);
        repository.saveAndFlush(post2);
        repository.saveAndFlush(post3);
      }
    ```
    - postメソッド（パラメータつき）を追加します
    ```java
      @RequestMapping("/post/{id}")
      public Mono<Post> post(@PathVariable int id){
        Post post = repository.findById(id);
        return Mono.just(post);
      }
    ```
#### 確認
1. ビルドと起動します
    ```bash
    $ mvn package
    $ java -jar target/sample-0.0.1-SNAPSHOT.jar
    ```
1. ブラウザでlocalhost:8080/post/1を開きます
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/f97dfefd-2258-f1f2-f8fc-0a13071b49e1.png)

1. ブラウザでlocalhost:8080/post/2を開きます
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/0ca53595-48de-70c3-0619-15e9a761ea3e.png)

1. ブラウザでlocalhost:8080/post/3を開きます
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/1f61fea8-b943-5fb0-782e-5538b54888b4.png)

### 全レコードを表示する
#### ハンドラを修正する
1. ハンドラに、下記のメソッドを追加します
    ```java
      @RequestMapping("/posts")
      public Flux<Post> posts(){
        List<Post> posts = repository.findAll();
        return Flux.fromArray(posts.toArray(new Post[0]));
      }
    ```
#### 確認
1. ビルドと起動します
    ```bash
    $ mvn package
    $ java -jar target/sample-0.0.1-SNAPSHOT.jar
    ```
1. ブラウザでlocalhost:8080/posts
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/b2251909-03d9-36db-96be-ed241752682f.png)

## ファイルアクセスとネットワークアクセス
データベース以外にも、ファイルアクセスがある。
Spring Bootでは、アプリに必要なファイル類は、`resources`フォルダに用意し、読み込む。

### sampleファイルを用意
1. resoucesフォルダにsample.txtを配置します
1. 下記を追記します
    ```
    This is sample text file.
    サンプルテキストファイルです。
    ```

### リクエストハンドラ
1. リクエストハンドラに下記を追加します
    ```java
      @RequestMapping("/file")
      public Mono<String> file(){
        String result ="";
        try {
          ClassPathResource classPath = new ClassPathResource("sample.txt");
          InputStream stream = classPath.getInputStream();
          InputStreamReader streamReader = new InputStreamReader(stream);
          BufferedReader reader = new BufferedReader(streamReader);
          
          String line;
          while((line = reader.readLine()) != null){
            result += line + "\n";
          }
    
        } catch (IOException e) {
          result = e.getMessage();
        }
        return Mono.just(result);
      }
    ```
### 確認
1. ビルドと起動します
    ```java
    $ mvn package
    $ java -jar target/sample-0.0.1-SNAPSHOT.jar
    ```
1. ブラウザでlocalhost:8080/file
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/5e58147d-8682-c571-e676-3287fffeca87.png)

## Web ClientでJSONデータを取得する
アプリから、NWアクセスを行う場合、WebClientというクラスを利用します。

### ハンドラ
1. RestControllerにWebClient利用のためのコードを追加します
    - WebClientBuilderは、コンストラクタに引数として渡される
    - ドメインを指定する
    ```java
      private final WebClient webClient;
    
      public SampleRestController(WebClient.Builder webClientBuilder) {
        super();
        webClient = webClientBuilder.baseUrl("jsonplaceholder.typicode.com").build();
      }
    ```
    - メソッドを追加する
    ```java
      @RequestMapping("/web/{id}")
      public Mono<Post> web(@PathVariable int id){
        return this.webClient.get()
        .uri("/posts/"+id)
        .accept(MediaType.APPLICATION_JSON)
        .retrieve()
        .bodyToMono(Post.class);
      }
      
      @RequestMapping("/web")
      public Flux<Post> web2(){
        return this.webClient.get()
        .uri("/posts")
        .accept(MediaType.APPLICATION_JSON)
        .retrieve()
        .bodyToFlux(Post.class);
      }
    ```
    - url:パス
    - accept(MediaType):JSON形式
    - retrieve:情報の取得
    - bodyToFlux、bodyToMono:Flux、Mono形式で取得する
### 確認
1. ビルドと起動します
    ```bash
    $ mvn package
    $ java -jar target/sample-0.0.1-SNAPSHOT.jar
    ```
1. ブラウザでlocalhost:8080/webにアクセスします。表示されました
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/0d6b7dd0-cbc3-e25e-c088-a3eba403ea4e.png)

1. ブラウザでlocalhost:8080/web/3にアクセスします。表示されました
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/ea807d47-3c64-7f4e-70e4-ec37b229dda9.png)

## コントローラーと関数型ルーティング
ここでは、Controllerを使って、関数によるルーティングを試してみます。


### コントローラー
関数でルーティングする場合は、リクエストメソッドを使いません。
Router Functionというものを作成します。

- Router Functionは、ルーティング関数を管理するためのクラス
- Router Functionを作成し、Beanとしてアプリに登録することで、指定したルーティングが機能し、アクセスにより処理が実行される
- コントローラーなどのクラス内に、メソッドを用意する


1. SampleController.javaを追加します
1. 下記のコードを追加します
    ```java
    package com.example.webflux.sample;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.reactive.function.server.RouterFunction;
    import org.springframework.web.reactive.function.server.ServerRequest;
    import org.springframework.web.reactive.function.server.ServerResponse;
    import static org.springframework.web.reactive.function.server.RouterFunctions.route;
    import static org.springframework.web.reactive.function.server.RequestPredicates.GET;
    import reactor.core.publisher.Mono; // Add this import
    import static org.springframework.web.reactive.function.server.ServerResponse.ok; // Add this import
    
    @Controller
    public class SampleController {
    
      @Bean
      public RouterFunction<ServerResponse> routes() {
        return route(GET("/f/hello"), this::hello);
      }
    
      Mono<ServerResponse> hello(ServerRequest request) {
        return ok().body(Mono.just("Hello Functional routing world"),String.class);
      }
    
    }
    ```
    - 
### 確認
1. ビルドとSpring Bootを起動します
    ```bash
    $ mvn package
    $ java -jar target/sample-0.0.1-SNAPSHOT.jar
    ```
1. ブラウザでlocalhost:8080/f/hello にアクセスします。表示されました
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/db6db105-4a09-81bb-0182-88093e88b364.png)



## 複数のrouteを連結する
複数のルーティングを行うために、RouterFunctionではどのように実装するのか試してみます。
RouterFunctionに必要なルーティングをすべて登録します。

### コントローラー
1. 下記のようにコードを修正します
    - routes関数
        - andRouteで関数を登録する
    ```java
      @Bean
      public RouterFunction<ServerResponse> routes() {
        return route(GET("/f/hello"), this::hello)
          .andRoute(GET("/f/hello2"), this::hello2);
      }
    ```
    - 新しい関数
    ```java
      Mono<ServerResponse> hello2(ServerRequest request) {
        return ok().body(Mono.just("関数型ルーティングの世界へようこそ！"),String.class);
      }
    ```

### 確認
1. ビルドとSpring Bootを起動します
    ```bash
    $ mvn package
    $ java -jar target/sample-0.0.1-SNAPSHOT.jar
    ```
1. ブラウザでlocalhost:8080/f/hello2 にアクセスします。表示されました
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/f954bf93-74db-a024-5e30-c7f19e06945f.png)


## テンプレートでWebページをレンダリング
Controllerクラスを利用する場合には、テンプレートエンジンを使うことも可能ですが、Spring Webとは異なります。

### pom.xml
テンプレートを使うために、thymeleafをインストールします
1. pom.xmlに下記のコードを追加します
    ```xml
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-thymeleaf</artifactId>
		</dependency>
    ```

### テンプレート
1. resourcesフォルダにtemplatesを用意します
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/9b298700-a0ed-a890-fcd8-d2272b96689a.png)

1. templatesにflux.htmlを作成します
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/86a99417-e2be-36b7-7506-416d03bd3afb.png)

1. 下記のコードを追加します。この時点では動的な値は埋め込んでいません
    ```html
    <!DOCTYPE html>
    <html>
    <head>
        <title>Flux top page</title>
        <meta http-equiv="Content-type" content="text/html"; charset="UTF-8" />
        <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap/dist/css/bootstrap.min.css" >
    </head>
    <body class="container">
      <h1 class="display-4">Flux page</h1>
      <p class="msg">This is Sample WebFlux page!!</p>
    </body>
    </body>
    </html>
    ```

### リクエストハンドラ
まずはじめに、リクエストハンドラのパターンを試します。

1. コントローラークラスに下記を追加します
    ```java
      @RequestMapping("/f/flux")
      Mono<Rendering> flux() {
        return Mono.just(Rendering.view("flux").build());
      } 
    ```
### 確認
1. ビルドとSpring Bootを起動します
    ```bash
    $ mvn package
    $ java -jar target/sample-0.0.1-SNAPSHOT.jar
    ```
1. ブラウザでlocalhost:8080/f/flux にアクセスします。表示されました
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/25032e2a-72fa-c824-4b7d-4ef2b5cadd3c.png)

### 関数ルーティング
次に、関数ルーティングを試します。

1. コントローラーを修正します
    - ルーティングに追加します
    ```java
      @Bean
      public RouterFunction<ServerResponse> routes() {
        return route(GET("/f/hello"), this::hello)
          .andRoute(GET("/f/hello2"), this::hello2)
          .andRoute(GET("/f/flux2"), this::flux2);
      }
    ```
    - メソッドを追加します
    ```java
      Mono<ServerResponse> flux2(ServerRequest request) {
        return ok().contentType(MediaType.TEXT_HTML).render("flux");
      }
    ```
### 確認
1. ビルドとSpring Bootを起動します
    ```bash
    $ mvn package
    $ java -jar target/sample-0.0.1-SNAPSHOT.jar
    ```
1. ブラウザでlocalhost:8080/f/flux2 にアクセスします。表示されました
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/dca9cdcd-e5f0-fb72-699e-ee46176b278c.png)


### 値をテンプレートに渡す
コントローラーから値をテンプレートに渡します

1. flux.htmlを下記のようにタイトル、メッセージを埋め込むように修正します
    ```html
    <!DOCTYPE html>
    <html>
    <head>
        <title>Flux top page</title>
        <meta http-equiv="Content-type" content="text/html"; charset="UTF-8" />
        <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap/dist/css/bootstrap.min.css" >
    </head>
    <body class="container">
      <h1 class="display-4" th:text="${title}"></h1>
      <p class="msg" th:text="${message}"></p>
    </body>
    </body>
    </html>
    ```
### リクエストハンドラを修正
Rendering.BuilderのmodelAttributeメソッドで値を設定します

1. fluxメソッドを下記のように書き換えます
    ```java
      @RequestMapping("/f/flux")
      Mono<Rendering> flux() {
        // return Mono.just(Rendering.view("flux").build());
        return Mono.just(Rendering.view("flux")
                .modelAttribute("title","Flux/Request Handler")
                .modelAttribute("message","これはリクエストハンドラのサンプルです")
                .build());
      } 
    ```
### 確認
1. ビルドとSpring Bootを起動します
    ```bash
    $ mvn package
    $ java -jar target/sample-0.0.1-SNAPSHOT.jar
    ```
1. ブラウザでlocalhost:8080/f/flux にアクセスします。表示されました
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/409f4278-11d0-d14e-ca5e-b3e7cb8d2349.png)

### Model引数を利用する
リクエストハンドラの場合、引数にModelを用意して値を追加もできる

1. fluxメソッドを下記のように書き換えます
    ```java
      @RequestMapping("/f/flux")
      Mono<Rendering> flux(Model model) {
        model.addAttribute("title","Flux/Request Handler(Using Model Parameter)");
        model.addAttribute("message","これはリクエストハンドラのサンプルです");
        return Mono.just(Rendering.view("flux").build());
      } 
    ```
### 確認
1. ビルドとSpring Bootを起動します
    ```bash
    $ mvn package
    $ java -jar target/sample-0.0.1-SNAPSHOT.jar
    ```
1. ブラウザでlocalhost:8080/f/flux にアクセスします。表示されました
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/4c2662b7-abb9-e513-89ae-2d00ec6168e0.png)

### 関数ルーティングで実装する
renderメソッドの第二引数にパラメータを渡します。

1. flux2メソッドを下記のように修正します
    ```java
      Mono<ServerResponse> flux2(ServerRequest request) {
        // return ok().contentType(MediaType.TEXT_HTML).render("flux");
        Map map = new HashMap();
        map.put("title","Flux/Functional Routing");
        map.put("message","これは関数型ルーティングのサンプルです");
        return ok().contentType(MediaType.TEXT_HTML).render("flux",map);
      }
    ```
### 確認
1. ビルドとSpring Bootを起動します
    ```bash
    $ mvn package
    $ java -jar target/sample-0.0.1-SNAPSHOT.jar
    ```
1. ブラウザでlocalhost:8080/f/flux にアクセスします。表示されました
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/b805b500-54e7-1868-9270-ec588bbe5cfa.png)


# 考察
今回、リアクティブやノンブロッキングの特徴をまとめるとともに、その具体的な実装である
Spring WebFluxを使用してみました。
今回は、主に、APIを想定した内容でした。次回以降は、クライアント側の実装を試してみます。

# 参考
https://docs.spring.io/spring-framework/reference/web/webflux.html

https://en.wikipedia.org/wiki/Reactive_programming

[Spring Boot 3 プログラミング入門](https://www.amazon.co.jp/Spring-Boot-3-%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0%E5%85%A5%E9%96%80-%E6%8E%8C%E7%94%B0%E6%B4%A5%E8%80%B6%E4%B9%83/dp/4798069167)