Spring 5 新特性：函式式Web框架

本文由碼農網 – 小峰原創翻譯，轉載請看清文末的轉載要求，歡迎參與我們的付費投稿計劃！

正如昨天Juergen部落格中所提到的，Spring 5.0的第二個里程碑是引入了一個新的函式式web框架。在這篇文章中，我們將給出關於這個框架的更多資訊。

舉例

我們先從示例應用程式的一些摘錄開始。下面是暴露Person物件的響應資訊庫。很類似於傳統的，非響應資訊庫，只不過它返回Flux<Person>而傳統的返回List<Person>，以及返回Mono<Person>的地方返回Person。Mono<Void>用作完成標識：指出何時儲存被完成。關於Reactor型別的更多資訊，請參閱此部落格文章。

public interface PersonRepository {
    Mono<Person> getPerson(int id);
    Flux<Person> allPeople();
    Mono<Void> savePerson(Mono<Person> person);
}

下面是我們如何暴露帶有新的函式式web框架的資源庫：

RouterFunction<?> route = route(GET("/person/{id}"),
    request -> {
        Mono<Person> person = Mono.justOrEmpty(request.pathVariable("id"))
            .map(Integer::valueOf)
            .then(repository::getPerson);
        return Response.ok().body(fromPublisher(person, Person.class));
    })
    .and(route(GET("/person"),
        request -> {
            Flux<Person> people = repository.allPeople();
        return Response.ok().body(fromPublisher(people, Person.class));
    }))
    .and(route(POST("/person"),
    request -> {
        Mono<Person> person = request.body(toMono(Person.class));
    return Response.ok().build(repository.savePerson(person));
}));

下面我們要介紹如何執行，比如在Reactor Netty中：

HttpHandler httpHandler = RouterFunctions.toHttpHandler(route);
ReactorHttpHandlerAdapter adapter =
    new ReactorHttpHandlerAdapter(httpHandler);
HttpServer server = HttpServer.create("localhost", 8080);
server.startAndAwait(adapter);

最後要做的一件事是試一試：

$ curl 'http://localhost:8080/person/1'
{"name":"John Doe","age":42}

下面還有更多介紹，讓我們挖掘得更深！

核心元件

我會通過徹底說明核心元件來介紹框架：HandlerFunction，RouterFunction，以及FilterFunction。這三個介面以及文中描述的所有其他型別都可以在org.springframework.web.reactive.function包中找到。

HandlerFunction

這一新框架的起點是HandlerFunction<T>，基本上是Function<Request, Response<T>>，其中Request和Response是新定義的，一成不變的介面友好地來提供JDK-8 DSL到底層HTTP訊息。對於構建Response實體是一個方便的構建工具，非常類似於在ResponseEntity中看到的。對應到HandlerFunction註解是一個帶有@RequestMapping的方法。

下面是一個簡單的“Hello World”處理函式的例子，返回有200狀態以及body為String的響應訊息：

HandlerFunction<String> helloWorld =
    request -> Response.ok().body(fromObject("Hello World"));

正如我們在上面的例子中看到的，處理函式是通過構建在Reactor的基礎上而完全響應：它們接受Flux，Mono，或任何其他相應的流Publisher作為響應型別。

要注意的一點，HandlerFunction本身是沒有副作用的，因為它返回響應，而不是把它當作一個引數（參見Servlet.service(ServletRequest,ServletResponse)，這實質上是BiConsumer<ServletRequest,ServletResponse> ）。沒有副作用有很多好處：易於測試，編寫和優化。

RouterFunction

傳入的請求被路由到有RouterFunction<T>的處理函式（即Function<Request, Optional<HandlerFunction<T>>）路由到處理函式，如果它匹配的話；否則就返回一個空的結果。路由方法與@RequestMapping註解的作用相似。但是，還有一個顯著的區別：用註解時路由會被限制到註解的value所能表達的範圍，處理這些方法的覆蓋是困難的；當用路由方法的時候，程式碼就在那裡，可以輕鬆的覆蓋或替換。

下面是一個有內嵌處理函式的路由函式的例子。它看起來有點冗長，但不要擔心：我們會找到辦法讓它變短。

RouterFunction<String> helloWorldRoute = 
    request -> {
        if (request.path().equals("/hello-world")) {
            return Optional.of(r -> Response.ok().body(fromObject("Hello World")));
        } else {
            return Optional.empty();
        }
    };

一般不用寫完整的路由方法，而是靜態引入RouterFunctions.route()，這樣就可以用請求判斷式（RequestPredicate） (即 Predicate<Request>)和處理方法（HandlerFunction）建立路由方法了。如果判斷式判斷成功則返回處理方法，否則返回空結果。如下是用route方法方式重寫上面的例子：

RouterFunction<String> helloWorldRoute =
    RouterFunctions.route(request -> request.path().equals("/hello-world"),
        request -> Response.ok().body(fromObject("Hello World")));

你可以（靜態地）匯入RequestPredicates.*以訪問常用的謂詞，基於路徑、HTTP方法、內容型別等等匹配。有了它，我們可以使helloWorldRoute更簡單：

RouterFunction<String> helloWorldRoute =
    RouterFunctions.route(RequestPredicates.path("/hello-world"),
        request -> Response.ok().body(fromObject("Hello World")));

組合函式

兩個路由函式可以組成一個新的路由函式，路由到任一個處理函式：如果第一個函式不匹配，那麼就執行第二個。你可以通過呼叫RouterFunction.and()，像這樣組合兩個路由函式：

RouterFunction<?> route =
    route(path("/hello-world"),
        request -> Response.ok().body(fromObject("Hello World")))
    .and(route(path("/the-answer"),
        request -> Response.ok().body(fromObject("42"))));

如果路徑匹配/hello-world，以上將回應“Hello World”，如果匹配/the-answer，則同時返回“42”。如果兩者都不匹配，則返回一個空的Optional。請注意，組合的路由函式會依次執行，因此在具體函式之前放入泛型函式是有意義的。

你也可以組合要求謂詞，通過呼叫and或or。工作方式是這樣：對於and，如果兩個給定謂詞匹配的話，結果謂詞匹配，而如果兩者中的一個謂語匹配的話，那麼就or匹配。例如：

RouterFunction<?> route =
    route(method(HttpMethod.GET).and(path("/hello-world")), 
        request -> Response.ok().body(fromObject("Hello World")))
    .and(route(method(HttpMethod.GET).and(path("/the-answer")), 
        request -> Response.ok().body(fromObject("42"))));

事實上，在RequestPredicates發現的大多數謂詞是組合的！例如，RequestPredicates.GET(String)是RequestPredicates.method(HttpMethod)和RequestPredicates.path(String)的組合物。因此，我們可以將上面的程式碼重寫為：

RouterFunction<?> route =
    route(GET("/hello-world"),
        request -> Response.ok().body(fromObject("Hello World")))
    .and(route(GET("/the-answer"),
        request -> Response.ok().body(fromObject(42))));

方法引用

順便說一句：到目前為止，我們已經編寫了所有的處理函式作為內聯的lambda表示式。雖然這在演示和短的例子中表現良好，但是不得不說這有一種會導致“混亂”的傾向，因為你要混合兩種擔憂：請求路由和請求處理。因此，我們要看看是否能夠讓事情變得更簡潔。首先，我們建立一個包含處理程式碼的類：

class DemoHandler {
    public Response<String> helloWorld(Request request) {
        return Response.ok().body(fromObject("Hello World"));
    }
    public Response<String> theAnswer(Request request) {
        return Response.ok().body(fromObject("42"));
    }
}

注意，兩個方法都有一個相容了處理函式的標誌。這允許我們使用方法引用：

DemoHandler handler = new DemoHandler(); // or obtain via DI
RouterFunction<?> route =
    route(GET("/hello-world"), handler::helloWorld)
    .and(route(GET("/the-answer"), handler::theAnswer));

FilterFunction

由路由函式對映的路徑可以通過呼叫RouterFunction.filter(FilterFunction<T, R>)進行過濾，其中FilterFunction<T,R>本質上是BiFunction<Request, HandlerFunction<T>, Response<R>>。函式的處理器（handler）引數代表的就是整個鏈條中的下一項: 這是一個典型的 HandlerFunction, 但如果附加了多個過濾器的話，它也能夠是另外的一個 FilterFunction。讓我們向路由新增一個日誌過濾器：

RouterFunction<?> route =
    route(GET("/hello-world"), handler::helloWorld)
    .and(route(GET("/the-answer"), handler::theAnswer))
    .filter((request, next) -> {
        System.out.println("Before handler invocation: " + request.path());
        Response<?> response = next.handle(request);
        Object body = response.body();
        System.out.println("After handler invocation: " + body);
    return response;
});

需要注意的是，要不要呼叫下一個處理程式是可選的。這在安全和快取方案中非常有用（如只在使用者有足夠許可權的時候呼叫next）。

由於route是一個無限路由函式，因此我們知道接下來的處理程式會返回什麼型別的響應資訊。這就是為什麼我們最終在我們的過濾器中用Response<?>結束以及用Object響應body的原因。在處理程式類中，兩種方法都返回Response<String>，所以應該有可能有String響應主體。我們可以通過使用RouterFunction.andSame()來代替and()做到這一點。這種組合方法需要引數路由函式是相同的型別。例如，我們可以讓所有的響應變成大寫：

RouterFunction<String> route =
  route(GET("/hello-world"), handler::helloWorld)
  .andSame(route(GET("/the-answer"), handler::theAnswer))
  .filter((request, next) -> {
    Response<String> response = next.handle(request);
    String newBody = response.body().toUpperCase();
    return Response.from(response).body(fromObject(newBody));
  });

使用註解，相似的功能可以用@ControllerAdvice和/或ServletFilter來實現。

執行服務端

所有這一切都很好，但有一件事忘了：我們如何才能在實際的HTTP伺服器中執行這些函式呢？答案勿庸置疑是通過呼叫另一個函式。你可以通過使用RouterFunctions.toHttpHandler()將路由函式轉換成HttpHandler。HttpHandler是引進到Spring 5.0 M1的一個響應抽象：它允許你執行在各種響應執行時上：Reactor Netty、RxNetty、Servlet 3.1+，和Undertow。在這個例子中，我們已經表明了在Reactor Netty中執行route是怎麼樣的。對於Tomcat，它看起來像這樣：

HttpHandler httpHandler = RouterFunctions.toHttpHandler(route);
HttpServlet servlet = new ServletHttpHandlerAdapter(httpHandler);
Tomcat server = new Tomcat();
Context rootContext = server.addContext("",
    System.getProperty("java.io.tmpdir"));
Tomcat.addServlet(rootContext, "servlet", servlet);
rootContext.addServletMapping("/", "servlet");
tomcatServer.start();

有一點要注意的是，上面的程式碼不依賴於Spring應用程式上下文。就像JdbcTemplate和其他Spring實用工具類，使用應用程式上下文是可選的：你可以在上下文中接通處理程式和路由函式，但它不是必需的。

還要注意的是，你也可以轉換路由函式為HandlerMapping，以便它可以在DispatcherHandler中執行（可能需要有響應的@Controllers）。

結論

讓我通過簡短的總結來得出結論：

• 處理函式通過返回響應處理請求。
• 路由函式路由到處理函式，並且可以與其他路由函式組合。
• 路由函式可以通過過濾器進行過濾。
• 路由函式可以在響應的web執行時中執行。

為了讓大家能更全面的瞭解，我已經建立了一個使用泛函web框架的簡單示例專案。你可以在GitHub上找到這個專案。歡迎留下你的看法！