Spring5 の新機能 - 機能的な Web フレームワークの詳細なコード例-＆＃＆チュートリアル-php.cn

昨日の Juergen のブログで述べたように、Spring 5.0 の 2 番目のマイルストーンは、新しい機能的な Web フレームワークの導入です。この記事では、このフレームワークについて詳しく説明します。

例

サンプルアプリケーションからのいくつかの抜粋から始めましょう。以下は、personオブジェクトを公開する応答情報ベースです。。従来の非応答型情報ベースとよく似ていますが、従来の情報ベースは Flux を返す点が異なります。 .cn /wiki/1059.html" target="_blank">リストを返し、Mono<person> が返される person を返します。 Mono は、保存がいつ完了したかを示す完了フラグとして使用されます。 Reactor タイプの詳細については、このブログ投稿を参照してください。

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

ログイン後にコピー

Person对象的响应信息库。很类似于传统的，非响应信息库，只不过它返回Flux而传统的返回List，以及返回Mono<Person>的地方返回Person。Mono用作完成标识：指出何时保存被完成。关于Reactor类型的更多信息，请参阅此博客文章。

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));
}));

ログイン後にコピー

下面是我们如何暴露带有新的函数式web框架的资源库：

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

ログイン後にコピー

下面我们要介绍如何运行，比如在Reactor Netty中：

$ curl &#39;http://localhost:8080/person/1&#39;
{"name":"John Doe","age":42}

ログイン後にコピー

最后要做的一件事是试一试：

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

ログイン後にコピー

下面还有更多介绍，让我们挖掘得更深！

核心组件

我会通过彻底说明核心组件来介绍框架：HandlerFunction，RouterFunction，以及FilterFunction。这三个接口以及文中描述的所有其他类型都可以在org.springframework.web.reactive.function包中找到。

HandlerFunction

这一新框架的起点是HandlerFunction<T>，基本上是Function>，其中Request和Response是新定义的，一成不变的界面友好地来提供JDK-8 DSL到底层HTTP消息。对于构建Response实体是一个方便的构建工具，非常类似于在ResponseEntity中看到的。对应到HandlerFunction注解是一个带有@RequestMapping的方法。

下面是一个简单的“Hello World”处理函数的例子，返回有200状态以及body为String的响应消息：

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

ログイン後にコピー

正如我们在上面的例子中看到的，处理函数是通过构建在Reactor的基础上而完全响应：它们接受Flux，Mono，或任何其他相应的流Publisher作为响应类型。

要注意的一点，HandlerFunction本身是没有副作用的，因为它返回响应，而不是把它当作一个参数（参见Servlet.service(ServletRequest,ServletResponse)，这实质上是BiConsumer ）。没有副作用有很多好处：易于测试，编写和优化。

RouterFunction

传入的请求被路由到有RouterFunction<T>的处理函数（即Function）路由到处理函数，如果它匹配的话；否则就返回一个空的结果。路由方法与@RequestMapping注解的作用相似。但是，还有一个显著的区别：用注解时路由会被限制到注解的value所能表达的范围，处理这些方法的覆盖是困难的；当用路由方法的时候，代码就在那里，可以轻松的覆盖或替换。

下面是一个有内嵌处理函数的路由函数的例子。它看起来有点冗长，但不要担心：我们会找到办法让它变短。

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

ログイン後にコピー

一般不用写完整的路由方法，而是静态引入RouterFunctions.route()，这样就可以用请求判断式（RequestPredicate） (即 Predicate)和处理方法（HandlerFunction）创建路由方法了。如果判断式判断成功则返回处理方法，否则返回空结果。如下是用route方法方式重写上面的例子：

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

ログイン後にコピー

你可以（静态地）导入RequestPredicates.*以访问常用的谓词，基于路径、HTTP方法、内容类型等等匹配。有了它，我们可以使helloWorldRoute更简单：

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

ログイン後にコピー

组合函数

两个路由函数可以组成一个新的路由函数，路由到任一个处理函数：如果第一个函数不匹配，那么就执行第二个。你可以通过调用RouterFunction.and()，像这样组合两个路由函数：

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"))));

ログイン後にコピー

如果路径匹配/hello-world，以上将回应“Hello World”，如果匹配/the-answer，则同时返回“42”。如果两者都不匹配，则返回一个空的Optional新しい機能 Web フレームワークでリポジトリを公開する方法は次のとおりです:

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

ログイン後にコピー

🎜Reactor Netty などで実行する方法は次のとおりです: 🎜

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));

ログイン後にコピー

🎜以下にさらに紹介します。さらに詳しく見てみましょう。 🎜🎜コアコンポーネント🎜🎜 コアコンポーネントである HandlerFunction、RouterFunction、および FilterFunction を徹底的に説明することで、フレームワークを紹介します。これら 3 つのインターフェイスと、この記事で説明されている他のすべてのタイプは、 org.springframework.web.reactive.function パッケージにあります。 🎜🎜HandlerFunction🎜🎜 この新しいフレームワークの開始点は HandlerFunction<T> です。これは基本的に Function> です。 Request と Response は、基盤となる HTTP メッセージに JDK-8 DSL を提供する、新しく定義された使いやすいインターフェイスです。は、Response エンティティを構築するための便利な構築ツールで、ResponseEntity で表示されるものとよく似ています。 HandlerFunction アノテーションに対応するのは、@RequestMapping を持つメソッドです。 🎜🎜 以下は、単純な「Hello World」処理関数の例です。この関数はステータス 200 と本文文字列の応答メッセージ: 🎜

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;
});

ログイン後にコピー

🎜 上の例でわかるように、ハンドラー関数は Reactor の上に構築することで完全に応答します。 Flux、Mono、またはその他の対応するストリーム Publisher を応答タイプとして受け入れます。 🎜🎜 注意すべき点の 1 つは、HandlerFunction 自体には副作用がないということです。これは、応答をパラメータとして扱う代わりに応答を返すためです (Servlet.service(ServletRequest,ServletResponse) を参照してください。これは本質的に BiConsumer< ; です。サーブレットリクエスト、サーブレットレスポンス>)。副作用がないことには、テスト、作成、最適化が容易であるなど、多くの利点があります。 🎜🎜RouterFunction🎜🎜 受信リクエストは A にルーティングされます。 RouterFunction<T> を持つハンドラー関数 (つまり、Function) が一致する場合はハンドラー関数にルーティングされ、一致しない場合は空の結果が返されます。ルーティングメソッドには、@RequestMapping アノテーションと同様の機能があります。ただし、もう 1 つの大きな違いがあります。アノテーションを使用する場合、ルーティングはアノテーションの値が表現できる範囲に制限され、ルーティングメソッドを使用する場合は、コードがそこに存在するため、これらのメソッドのカバレッジを処理することが困難になります。簡単に上書きまたは置き換えることができます。 🎜🎜以下は、組み込みハンドラー関数を使用したルーティング関数の例です。少し長く感じるかもしれませんが、心配しないでください。短くする方法を見つけます。 🎜

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));
  });

ログイン後にコピー

🎜 通常、完全なルーティングメソッドを記述する必要はありませんが、静的に RouterFunctions.route() を導入すると、リクエスト述語 (つまり、Predicate) と処理メソッド (HandlerFunction) を使用してルーティングメソッドを作成できるようになります。判定が成功した場合は処理メソッドを返し、そうでない場合は空の結果を返します。 Route メソッドを使用して書き直された上記の例は次のとおりです: 🎜

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();

ログイン後にコピー

🎜 RequestPredicates.* を (静的に) インポートして、パス、HTTP メソッド、コンテンツタイプなどに基づいたマッチング、一般的に使用される述語にアクセスできます。これを使用すると、helloWorldRoute をより単純にすることができます: 🎜rrreee🎜結合関数🎜🎜 2 つのルーティング関数は、任意の処理関数にルーティングして新しいルーティング関数を形成できます: 最初の関数が一致しない場合は、二つ目。 RouterFunction.and() を呼び出すことで、次のように 2 つのルーティング関数を組み合わせることができます: 🎜rrreee🎜 パスが /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)进行过滤，其中FilterFunction本质上是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是一个无限路由函数，因此我们知道接下来的处理程序会返回什么类型的响应信息。这就是为什么我们最终在我们的过滤器中用Response结束以及用Object响应body的原因。在处理程序类中，两种方法都返回Response，所以应该有可能有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）。