Spring5新特性-函數式Web框架的程式碼實例詳解

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

範例

我們先從範例應用程式的一些摘錄開始。下面是暴露Person物件的回應資訊庫。很類似傳統的，非回應資訊庫，只不過它回傳Flux8abf60ac54173a2785e603c7a1f95b4e而傳統的回傳List8abf60ac54173a2785e603c7a1f95b4e，以及回傳Mono5182f7e335fc8ff939fa92a582f4d112用作完成識別：指出何時保存被完成。關於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

這個新框架的起點是HandlerFunction8742468051c85b06f0a0af9e3e506b5c，基本上是Function ，其中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)，這實質上是BiConsumer6e72f5b255c484787157de45967f7d3d ）。沒有副作用有很多好處：易於測試，編寫和優化。

RouterFunction

傳入的請求被路由到有RouterFunction8742468051c85b06f0a0af9e3e506b5c的處理函數（即Function< Request, Optional）路由到處理函數，如果它匹配的話；否則就傳回一個空的結果。路由方法與@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） (即Predicatef7d8f1c8612adb3bda833145b9a351cc)和處理方法（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(FilterFunction469df1b70b2914a3841e0404ec3e3d5d)进行过滤，其中FilterFunction43ca9160a1fbc6e1e17f36fac17e2094本质上是BiFunction。函数的处理器（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是一个无限路由函数，因此我们知道接下来的处理程序会返回什么类型的响应信息。这就是为什么我们最终在我们的过滤器中用Response6b3d0130bba23ae47fe2b8e8cddf0195结束以及用Object响应body的原因。在处理程序类中，两种方法都返回Responsef7e83be87db5cd2d9a8a0b8117b38cd4，所以应该有可能有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运行时中运行。

以上是Spring5新特性-函數式Web框架的程式碼實例詳解的詳細內容。更多資訊請關注PHP中文網其他相關文章！