楊絳先生說：大部分人的問題是，做得不多而想得太多。

今天要講的函數語言程式設計可能和Spring Boot本身的關係不太大，但是它很重要！不僅是因為從Java 7升級到Java 8多了一種新程式設計語法的支援，更因為這是一種不同的思維模式。同時，今天的內容可能會偏多一點，希望愛學習的你能耐心看完。

Spring 5中的引入了對響應式程式設計的支援——WebFlux，它基於Reactor類庫的基礎實現，之前的三篇文章：

已經詳細講述過Reactor和WebFlux註解模型以及用法，可以點選複習。目前在Spring Boot中不支援兩種正規化混用。

本文我們將實現一個使用Java 8 lambda表示式來定義，使用Spring WebFlux的請求處理方法HandlerFunctions的例子。我們會使用Java 8 lambda程式碼風格來編寫程式碼，如下所示：

HandlerFunction<ServerResponse> echoHandlerFn = (request) -> ServerResponse.ok().body(fromObject(request.queryParam("name")));

RequestPredicate predicate = RequestPredicates.GET("/echo");

RouterFunction <ServerResponse> routerFunction = RouterFunctions.route(GET("/echo"), echoHandler::echo);

Mono<ServerResponse> echo = ServerResponse.ok().body(fromObject(request.queryParam("name"
 
)));

接下來，我們先看幾個關鍵元件。

HandlerFunction

簡單來說，HandlerFunction是一個接受ServletRequest並返回ServletResponse的函式介面。在使用註解模型時，我們會直接使用@RequestMapping("/")註解來對映請求路徑，而HandlerFunction就是起到這個同樣的作用。介面定義如下程式碼：

package org.springframework.web.reactive.function.server;
import reactor.core.publisher.Mono;

@FunctionalInterface
 

public interface HandlerFunction<T extends ServerResponse> {
    Mono<T> handle(ServerRequest var1);
}

這裡，我們又看到了@FunctionalInterface的身影，標明是一個函式式介面，ServerRequest和ServerResponse是在Reactor型別之上構建的介面。我們可以將請求主體body轉換為Reactor的Mono或Flux型別，並且可以還發送任何響應的例項流給釋出者作為響應主體。

ServerRequest

在包org.springframework.web.reactive.function.server中的ServerRequest介面是表示的伺服器端HTTP請求。 我們可以在HTTP請求中通過各種方法來使用它，這裡要注意和註解模型下的ServerHttpRequest區別開，使用的方法如下：

HttpMethod method = request.method();
String path = request.path();
String id = request.pathVariable("id");
Map<String, String> pathVariables = request.pathVariables();
Optional<String> email = request.queryParam("email");
URI uri = request.uri();

由於需要轉換為Reactor的響應型別，我們就需要使用bodyToMono()或bodyToFlux()方法來將請求body轉換為Mono<T>或Flux<T>型別，如下：

Mono<User> manMono = request.bodyToMono(Man.class);
Flux<User> mansFlux = request.bodyToFlux(Man.class)

bodyToMono()和bodyToFlux()方法實際上是BodyExtractor物件的例項，它主要用於提取請求主體內容並將其反序列化為POJO物件。這也就意味著，我們可以使用BodyExtractor類來將請求主體body內容轉化為Mono或Flux型別，如下所示：

Mono<User> manMono = request.body(BodyExtractors.toMono(Man.class));
Flux<User> mansFlux = request.body(BodyExtractors.toFlux(Man.class));

如果要將請求主體轉換為泛型型別時，還可以使用ParameterizedTypeReference。

ParameterizedTypeReference<Map<String, List<User>>> typeReference = new Parameterized
TypeReference<Map<String, List<User>>>() {};
Mono<Map<String, List<User>>> mapMono = request.body(BodyExtractors.toMono(typeReference));

ServerResponse

同樣，在包中org.springframework.web.reactive.function.server的ServerResponse介面表示伺服器端HTTP的響應式響應。 ServerResponse也是一個唯一的介面，並提供了許多靜態構建器方法來構建響應，包括status, contentType, cookies, headers和body等。

以下是如何使用構造器方法，來構建ServerResponse的幾個例子：

ServerResponse.ok().contentType(APPLICATION_JSON).body(userMono, User.class);
ServerResponse.ok().contentType(APPLICATION_JSON).body(BodyInserters.fromObject(user));
ServerResponse.created(uri).build();
ServerResponse.notFound().build();

我們還可以使用render()方法渲染檢視模板，如下所示：

Map<String,?> modelAttributes = new HashMap<>();
modelAttributes.put("man",man);
ServerResponse.ok().render("home", modelAttributes);

因此，使用這些ServerResponse的構造器方法，便可以構造HandlerFunction.handle法的返回值了。

RouterFunction

RouterFunction使用RequestPredicate將傳入請求對映到HandlerFunction。我們可以使用RouterFunctions的類靜態方法來構建RouterFunction，如下所示：

RouterFunctions.route(GET("/echo"), request -> ok().body(fromObject(request.queryParam("name"))));

還可以將多個路由定義合併到一個新的路由定義中，以便路由到與謂詞相匹配的第一個處理函式。

import static org.springframework.web.reactive.function.server.RequestPredicates.*;

RouterFunctions.route(GET("/echo"), request -> ok().body(fromObject(request.queryParam("name"))))
.and(route(GET("/home"), request -> ok().render("home")))
.andRoute(POST("/mans"), request -> ServerResponse.ok().build());

上面，我們將三個路由合成為一個傳入給請求，並分別對映處理Handler。假設我們需要編寫多個具有相同父級字首的路由，這時，並不用在每個路由中重複URL路徑，使用RouterFunctions.nest()方法即可實現父級目錄和子級目錄的對映，如下所示：

RouterFunctions.nest(path("/api/mans"),
nest(accept(APPLICATION_JSON),
route(GET("/{id}"), request -> ServerResponse.ok().build())
.andRoute(method(HttpMethod.GET), request -> ServerResponse.ok().build())));

說明一下，程式碼中將兩個URL對映到其處理函式。一種是GET /api/mans，它返回所有使用者，另一種是GET /api/mans/{id}返回給定id的使用者詳細資訊。

我們還可以使用RequestPredicates靜態方法建立RequestPredicate，以及使用RequestPredicate.and組合請求達到同樣的效果，如下所示：

RouterFunctions.route(path("/api/mans").and(method(HttpMethod.GET)),
request -> ServerResponse.ok().build());
RouterFunctions.route(GET("/api/mans").or(GET("/api/mans/list")),
request -> ServerResponse.ok().build());

HandlerFilterFunction

我們如果將基於註解的方法與函式方法進行比較，則RouterFunction與@RequestMapping註解類似，而HandlerFunction與使用@RequestMapping("/")註解的方法類似。 WebFlux框架還提供了HandlerFilterFunction介面，它更類似於Servlet Filter或@ControllerAdvice方法，介面定義如下：

package org.springframework.web.reactive.function.server;

import java.util.function.Function;
import org.springframework.util.Assert;
import reactor.core.publisher.Mono;

@FunctionalInterface
public interface HandlerFilterFunction<T extends ServerResponse, R extends ServerResponse> {
    Mono<R> filter(ServerRequest var1, HandlerFunction<T> var2);
//其它預設方法
}

比如，我們可以使用HandlerFilterFunction根據使用者角色過濾路由，如下示例：

RouterFunction<ServerResponse> route = route(DELETE("/api/mans/{id}"), request -> ok().build());
RouterFunction<ServerResponse> filteredRoute = route.filter((request, next) -> {
    if (hasAdminRole()) {
        return next.handle(request);
    }
    else {
        return ServerResponse.status(UNAUTHORIZED).build();
    }
});
private boolean hasAdminRole()
{
    //判斷是否有管理全許可權的邏輯程式碼
}

當我們向/api/mans/{id}的URL發出請求時，篩選器將檢查使用者是否具有管理員角色，並決定執行處理函式，還是返回UNAUTHORIZED響應。

將HandlerFunctions註冊為方法引用

我們也可以不使用內聯lambda來定義HandlerFunctions，而是將它們定義為方法引用並在路由配置中使用方法引用，如下所示：

@Component
public class EchoHandler {

    public Mono<ServerResponse> echo(ServerRequest request) {
        return ServerResponse.ok().body(fromObject(request.queryParam("name")));
    }
}

@Configuration
public class ManControllerFunc {

    @Autowired
    private com.hjf.boot.demo.flux.func.EchoHandler echoHandler;

    @Bean
    public RouterFunction<ServerResponse> echoRouterFunction() {
        return RouterFunctions.route(GET("/echo"), echoHandler::echo);
    }

}

實戰：使用RouterFunction的查詢API

現在，有了前面的基礎知識受，我們就可以使用功函數語言程式設計模型來構建應用程式了。 我們將建立一個UserHandler來作為HandlerFunctions的操作定義，然後配置一個RouterFunctions的路由Bean來對映路徑以處理請求。

第一步，建立示例Bean：ManEntity.class，如下所示：

@Entity
@Table(name="Man")
public class ManEntity {

    @Id @GeneratedValue(strategy= GenerationType.AUTO)
    private int id;

//    @Column(nullable=false)
    private String name;

//    @Column(nullable=false, unique=true)
    private int age;
// 省略get、set

第二步，建立服務元件類：ManHandler.class

@Component
public class ManHandler {

//    private ManReactiveRepository manReactiveRepository;//目前Spring-data-jpa並不支援，會報錯,要麼使用mongodb
//
//    @Autowired
//    public void UserHandlerFunctions(ManReactiveRepository manReactiveRepository) {
//        this.manReactiveRepository = manReactiveRepository;
//    }

    //
    public Mono<ServerResponse> getAllUsers(ServerRequest request)
    {
//        Flux<ManEntity> allMans = manReactiveRepository.findAll();
        Flux<ManEntity> allMans = Flux.fromArray(mockMan(10).toArray(new ManEntity[10]));
        return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON_UTF8)
                .body(allMans, ManEntity.class);
    }

    //
    public Mono<ServerResponse> getUserById(ServerRequest request) {
//        Mono<ManEntity> manMono = manReactiveRepository.findById(Integer.valueOf(request.pathVariable("id")));
        Mono<ManEntity> manMono = Mono.just(mockMan(1).get(0));
        Mono<ServerResponse> notFount = ServerResponse.notFound().build();
        return manMono.flatMap(user -> ServerResponse.ok()
                .contentType(MediaType.APPLICATION_JSON_UTF8)
                .body(fromObject(user)))
                .switchIfEmpty(notFount);
    }

    //
    public Mono<ServerResponse> saveUser(ServerRequest request) {
        Mono<ManEntity> manMono = request.bodyToMono(ManEntity.class);
//        Mono<ManEntity> mono = manMono.flatMap(man -> manReactiveRepository.save(man));
        return ServerResponse.ok().body(manMono, ManEntity.class);
    }

    public Mono<ServerResponse> deleteUser(ServerRequest request) {
        Integer id = Integer.valueOf(request.pathVariable("id"));
//        Mono<Void> mono = manReactiveRepository.deleteById(id); 刪除返回void的空
        return ServerResponse.ok().build(Mono.empty());
    }

    static public List<ManEntity> mockMan(int num){
        List<ManEntity> manEntityList = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            ManEntity man = new ManEntity();
            man.setId(i);
            man.setName("testname_"+i);
            man.setAge(18+i);
            manEntityList.add(man);
        }
        return manEntityList;
    }
}

細心的同學已經發現，這裡我們應該是要使用JPA的，但是通過實踐並查閱官方文件發現，Spring-data-jpa目前暫時還未支援響應式，所以會在啟動時報錯——

No property saveAll found for type

不過相信在未來，應該是會逐漸受到支援的。這裡我們手動寫一個mockMan方法來模擬讀取資料庫資料。這裡還可以使用已經受支援的Redis或MongoDB替代也行。

第三步，建立啟動類：RunAppFunc .class，並註冊RouterFunction,如下

@SpringBootApplication
public class RunAppFunc {

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

    @Autowired
    ManHandler manHandler;

    @Bean
    public RouterFunction<ServerResponse> routerFunctions() {
        return nest(path("/api/mans"),
                        nest(accept(APPLICATION_JSON),
                                route(GET("/{id}"), manHandler::getUserById)
                                        .andRoute(method(HttpMethod.GET), manHandler::getAllUsers)
                                        .andRoute(DELETE("/{id}"), manHandler::deleteUser)
                                        .andRoute(POST("/"), manHandler::saveUser)));
    }
}

程式碼中，我們對應對映服務類ManHandler的CRUD操作方法，並使用字首的方式來統一建立路由。再次提醒，SpringBoot目前是不支援兩種程式設計模型的混用的。

第四步，啟動應用，再次報錯！發現路由沒有生效，查詢了StackOverflow後發現，是內嵌的tomcat影響，我們只需要排除掉即可，更新pom如下：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

再次啟動，成功！這時，控制檯列印會多出以下內容：

Mapped /api/mans => {
Accept: [application/json] => {
(GET && /{id}) -> com.hjf.boot.demo.flux.func.RunAppFunc$$Lambda$236/[email protected]
GET -> com.hjf.boot.demo.flux.func.RunAppFunc$$Lambda$238/[email protected]
(DELETE && /{id}) -> com.hjf.boot.demo.flux.func.RunAppFunc$$Lambda$239/[email protected]
(POST && /) -> com.hjf.boot.demo.flux.func.RunAppFunc$$\Lambda\$240/[email protected]
}
}

[{“id”:0,”name”:”testname_0”,”age”:18},{“id”:1,”name”:”testname_1”,”age”:19},{“id”:2,”name”:”testname_2”,”age”:20},{“id”:3,”name”:”testname_3”,”age”:21},{“id”:4,”name”:”testname_4”,”age”:22},{“id”:5,”name”:”testname_5”,”age”:23},{“id”:6,”name”:”testname_6”,”age”:24},{“id”:7,”name”:”testname_7”,”age”:25},{“id”:8,”name”:”testname_8”,”age”:26},{“id”:9,”name”:”testname_9”,”age”:27}]

其實，預設情況下，spring-boot-starter-webflux使用reactor-netty作為執行時引擎。 我們可以排除reactor-netty，並使用其他支援反應式非阻塞I/O的伺服器，比如，Undertow，Jetty或Tomcat。

小結

本文詳細介紹了Spring WebFlux中的函數語言程式設計模型中的各個關鍵元件，並通過一個實際的例子來講函數語言程式設計與SpringBoot進行了集合。雖然我們可能已經習慣了註解模型的程式設計方式，但瞭解一個新的思維模式同樣對我們的學習進步有幫助。

參考資源

1、Spring Boot官方文件
2、Spring 5 WebFlux
3、注意有關WebFlux自動配置的更多詳細，請檢視org.springframework.boot.autoconfigure.web.reactive包中的配置類