ToB企服应用市场:ToB评测及商务社交产业平台

标题: Spring Web MVC：功能端点（Functional Endpoints） [打印本页]
作者: 莱莱    时间: 2024-12-25 17:00
标题: Spring Web MVC：功能端点（Functional Endpoints）
https://docs.spring.io/spring-framework/reference/web/webmvc-functional.html
Spring Web MVC 包罗了 WebMvc.fn，这是一个轻量级的函数式编程模子。在这个模子中，函数被用来路由和处置惩罚请求，并且计划了不可变性的规范。它是基于注解的编程模子的一个替换方案，但它仍然运行在同一个 DispatcherServlet 上。
概述

在 WebMvc.fn 中，HTTP 请求通过 HandlerFunction 进行处置惩罚：这是一个函数，它吸收 ServerRequest 并返回 ServerResponse。请求和响应对象都具有不可变的规范，这些规范提供了对 HTTP 请求和响应的 JDK 8 友好访问方式。HandlerFunction 相当于基于注解的编程模子中 @RequestMapping 方法的主体部门。
传入的请求通过 RouterFunction 路由到相应的处置惩罚器函数：RouterFunction 是一个函数，它吸收 ServerRequest 并返回一个可选的 HandlerFunction（即 Optional<HandlerFunction>）。当路由器函数匹配时，返回一个处置惩罚器函数；否则返回一个空的 Optional。RouterFunction 相当于 @RequestMapping 注解，但主要的区别在于路由器函数不但提供数据，还提供行为。
RouterFunctions.route() 提供了一个路由器构建器，用于方便地创建路由器，以下示例展示了这一用法：
  1. import static org.springframework.http.MediaType.APPLICATION_JSON;
  2. import static org.springframework.web.servlet.function.RequestPredicates.*;
  3. import static org.springframework.web.servlet.function.RouterFunctions.route;
  5. PersonRepository repository = ...
  6. PersonHandler handler = new PersonHandler(repository);
  8. RouterFunction<ServerResponse> route = route() (1)
  9.         .GET("/person/{id}", accept(APPLICATION_JSON), handler::getPerson)
  10.         .GET("/person", accept(APPLICATION_JSON), handler::listPeople)
  11.         .POST("/person", handler::createPerson)
  12.         .build();
  15. public class PersonHandler {
  17.         // ...
  19.         public ServerResponse listPeople(ServerRequest request) {
  20.                 // ...
  21.         }
  23.         public ServerResponse createPerson(ServerRequest request) {
  24.                 // ...
  25.         }
  27.         public ServerResponse getPerson(ServerRequest request) {
  28.                 // ...
  29.         }
  30. }
复制代码
如果你将 RouterFunction 注册为一个 bean，比方通过在一个 @Configuration 类中将其暴露出来，它将会被 servlet 自动检测。
HandlerFunction

ServerRequest 和 ServerResponse 是不可变的接口，它们提供了对 HTTP 请求和响应的 JDK 8 友好访问方式，包括头部信息、正文、请求方法和状态码。
ServerRequest

ServerRequest 提供了对 HTTP 方法、URI、头部信息和查询参数的访问，而访问正文内容则通过 body 方法提供。
下示例将请求正文提取为字符串：
  1. String string = request.body(String.class);
复制代码
以下示例将正文提取为 List<erson>，其中 Person 对象是从序列化情势（如 JSON 或 XML）解码而来的：
  1. List<Person> people = request.body(new ParameterizedTypeReference<List<Person>>() {});
复制代码
以下示例展示了如何访问参数：
  1. MultiValueMap<String, String> params = request.params();
复制代码
ServerResponse

ServerResponse 提供了对 HTTP 响应的访问，并且因为它是不可变的，你可以使用构建方法来创建它。你可以使用构建器来设置响应状态码、添加响应头部信息或提供响应正文。以下示例创建了一个包罗 JSON 内容的 200（OK）响应：
  1. Person person = ...
  2. ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(person);
复制代码
以下示例展示了如何构建一个带有 Location 头部且没有正文的 201（CREATED）响应：
  1. URI location = ...
  2. ServerResponse.created(location).build();
复制代码
你还可以使用异步效果作为正文，详细情势可以是 CompletableFuture、Publisher，或者 ReactiveAdapterRegistry 支持的其他任何范例。比方：
  1. Mono<Person> person = webClient.get().retrieve().bodyToMono(Person.class);
  2. ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(person);
复制代码
果不但正文，而且状态码或头部信息也基于异步范例，你可以使用 ServerResponse 上的静态 async 方法，它担当 CompletableFuture<ServerResponse>、Publisher<ServerResponse> 或 ReactiveAdapterRegistry 支持的任何其他异步范例。比方：
  1. Mono<ServerResponse> asyncResponse = webClient.get().retrieve().bodyToMono(Person.class)
  2.   .map(p -> ServerResponse.ok().header("Name", p.name()).body(p));
  3. ServerResponse.async(asyncResponse);
复制代码
可以通过 ServerResponse 上的静态 sse 方法提供服务器发送事件（Server-Sent Events）。该方法提供的构建器允许你发送字符串或其他对象作为 JSON。比方：
  1. public RouterFunction<ServerResponse> sse() {
  2.         return route(GET("/sse"), request -> ServerResponse.sse(sseBuilder -> {
  3.                                 // Save the sseBuilder object somewhere..
  4.                         }));
  5. }
  7. // In some other thread, sending a String
  8. sseBuilder.send("Hello world");
  10. // Or an object, which will be transformed into JSON
  11. Person person = ...
  12. sseBuilder.send(person);
  14. // Customize the event by using the other methods
  15. sseBuilder.id("42")
  16.                 .event("sse event")
  17.                 .data(person);
  19. // and done at some point
  20. sseBuilder.complete();
复制代码
处置惩罚器类（Handler Classes）

我们可以将处置惩罚器函数编写为 lambda 表达式，如下例所示：
  1. HandlerFunction<ServerResponse> helloWorld =
  2.   request -> ServerResponse.ok().body("Hello World");
复制代码
在实际应用中，我们可能需要多个函数，并且多个内联 lambda 表达式可能会让代码变得混乱。因此，将相关的处置惩罚器函数组合成一个处置惩罚器类是有用的，这类似于在基于注解的应用步伐中使用 @Controller 注解的脚色。比方，以下类公开了一个响应式的 Person 存储库：
  1. import static org.springframework.http.MediaType.APPLICATION_JSON;
  2. import static org.springframework.web.reactive.function.server.ServerResponse.ok;
  4. public class PersonHandler {
  6.         private final PersonRepository repository;
  8.         public PersonHandler(PersonRepository repository) {
  9.                 this.repository = repository;
  10.         }
  12.         public ServerResponse listPeople(ServerRequest request) { (1)
  13.                 List<Person> people = repository.allPeople();
  14.                 return ok().contentType(APPLICATION_JSON).body(people);
  15.         }
  17.         public ServerResponse createPerson(ServerRequest request) throws Exception { (2)
  18.                 Person person = request.body(Person.class);
  19.                 repository.savePerson(person);
  20.                 return ok().build();
  21.         }
  23.         public ServerResponse getPerson(ServerRequest request) { (3)
  24.                 int personId = Integer.parseInt(request.pathVariable("id"));
  25.                 Person person = repository.getPerson(personId);
  26.                 if (person != null) {
  27.                         return ok().contentType(APPLICATION_JSON).body(person);
  28.                 }
  29.                 else {
  30.                         return ServerResponse.notFound().build();
  31.                 }
  32.         }
  34. }
复制代码
验证（Validation）

一个功能端点可以使用 Spring 的验证实用步伐来对请求体进行验证。比方，假设我们有一个针对 Person 的自界说 Spring Validator 实现：
  1. public class PersonHandler {
  3.         private final Validator validator = new PersonValidator();
  5.         // ...
  7.         public ServerResponse createPerson(ServerRequest request) {
  8.                 Person person = request.body(Person.class);
  9.                 validate(person);
  10.                 repository.savePerson(person);
  11.                 return ok().build();
  12.         }
  14.         private void validate(Person person) {
  15.                 Errors errors = new BeanPropertyBindingResult(person, "person");
  16.                 validator.validate(person, errors);
  17.                 if (errors.hasErrors()) {
  18.                         throw new ServerWebInputException(errors.toString());
  19.                 }
  20.         }
  21. }
复制代码
处置惩罚器还可以通过创建并注入一个基于 LocalValidatorFactoryBean 的全局 Validator 实例来使用尺度的 Bean 验证 API（JSR-303）
RouterFunction

路由函数用于将请求路由到相应的HandlerFunction。通常，你不会自己编写路由函数，而是使用 RouterFunctions 工具类上的方法来创建一个。RouterFunctions.route()（无参数）提供了一个流通的构建器来创建路由函数，而 RouterFunctions.route(RequestPredicate, HandlerFunction) 则提供了一种直接创建路由的方式。
通常，推荐使用 route() 构建器，因为它为典型的映射场景提供了方便的快捷方式，而无需使用难以发现的静态导入。比方，路由器函数构建器提供了 GET(String, HandlerFunction) 方法来创建针对 GET 请求的映射，以及 POST(String, HandlerFunction) 方法来创建针对 POST 请求的映射。
除了基于 HTTP 方法的映射外，路由构建器还提供了一种在映射请求时引入额外谓词（predicates ）的方式。对于每种 HTTP 方法，都有一个重载的变体，它担当一个 RequestPredicate 作为参数，通过它可以表达额外的束缚条件。
Predicates

可以编写自己的RequestPredicate，但RequestPredicates实用类提供了基于请求路径、HTTP方法、内容范例等的常用实现。以下示例使用请求谓词（request predicate ）创建了一个基于Accept头的束缚：
  1. RouterFunction<ServerResponse> route = RouterFunctions.route()
  2.         .GET("/hello-world", accept(MediaType.TEXT_PLAIN),
  3.                 request -> ServerResponse.ok().body("Hello World")).build();
复制代码
可以使用以下方式将多个请求谓词组合在一起：

RequestPredicates中的很多谓词是组合的。比方，RequestPredicates.GET(String)是由RequestPredicates.method(HttpMethod)和RequestPredicates.path(String)组合而成的。上面显示的示例也使用了两个请求谓词，因为构建器内部使用了RequestPredicates.GET，并将其与accept 谓词组合。
路由（Routes）

路由器函数按顺序进行评估：如果第一个路由不匹配，则评估第二个，依此类推。因此，在声明一样寻常路由之前声明更详细的路由是有意义的。在将路由器函数注册为Spring bean时，这一点也很告急。这种行为与基于注解的编程模子不同，在基于注解的编程模子中，会自动选择“最详细”的控制器方法。
当使用路由器函数构建器时，所有界说的路由都被组合成一个从build()返回的RouterFunction。另有其他方法可以将多个路由器函数组合在一起：

以下示例展示了四条路由的组合：
  1. import static org.springframework.http.MediaType.APPLICATION_JSON;
  2. import static org.springframework.web.servlet.function.RequestPredicates.*;
  4. PersonRepository repository = ...
  5. PersonHandler handler = new PersonHandler(repository);
  7. RouterFunction<ServerResponse> otherRoute = ...
  9. RouterFunction<ServerResponse> route = route()
  10.         .GET("/person/{id}", accept(APPLICATION_JSON), handler::getPerson) (1)
  11.         .GET("/person", accept(APPLICATION_JSON), handler::listPeople) (2)
  12.         .POST("/person", handler::createPerson) (3)
  13.         .add(otherRoute) (4)
  14.         .build();
复制代码
嵌套路由（Nested Routes）

对于一组路由器函数来说，共享一个谓词是常见的，比方共享一个路径。在上面的示例中，共享的谓词将是一个匹配/person的路径谓词，被三个路由使用。当使用注解时，可以通过使用映射到/person的范例级别的@RequestMapping注解来消除这种重复。在WebMvc.fn中，可以通过路由器函数构建器上的path方法共享路径谓词。比方，上面示例的最后几行可以通过使用嵌套路由来改进：
  1. RouterFunction<ServerResponse> route = route()
  2.         .path("/person", builder -> builder
  3.                 .GET("/{id}", accept(APPLICATION_JSON), handler::getPerson)
  4.                 .GET(accept(APPLICATION_JSON), handler::listPeople)
  5.                 .POST(handler::createPerson))
  6.         .build();
复制代码
只管基于路径的嵌套是最常见的，但可以通过在构建器上使用nest方法来根据任何范例的谓词进行嵌套。上述示例中仍然包罗了一些重复，情势为共享的Accept-header谓词。我们可以通过将nest方法和accept一起使用来进一步改进：
  1. RouterFunction<ServerResponse> route = route()
  2.         .path("/person", b1 -> b1
  3.                 .nest(accept(APPLICATION_JSON), b2 -> b2
  4.                         .GET("/{id}", handler::getPerson)
  5.                         .GET(handler::listPeople))
  6.                 .POST(handler::createPerson))
  7.         .build();
复制代码
提供资源

WebMvc.fn提供了内置的支持，用于提供服务资源。
除了下面描述的功能之外，还可以通过使用RouterFunctions#resource(java.util.function.Function)实现更灵活的资源处置惩罚。
重定向到资源

可以将会匹配指定谓词的请求重定向到资源。比方，在单页应用步伐中处置惩罚重定向时，这可能是有用的。
  1.    ClassPathResource index = new ClassPathResource("static/index.html");
  2. List<String> extensions = Arrays.asList("js", "css", "ico", "png", "jpg", "gif");
  3. RequestPredicate spaPredicate = path("/api/**").or(path("/error")).or(pathExtension(extensions::contains)).negate();
  4. RouterFunction<ServerResponse> redirectToIndex = route()
  5.         .resource(spaPredicate, index)
  6.         .build();
复制代码
从根位置提供服务资源

还可以将会匹配给定模式的请求路由到相对于给定根位置的资源。
  1. Resource location = new FileSystemResource("public-resources/");
  2. RouterFunction<ServerResponse> resources = RouterFunctions.resources("/resources/**", location);
复制代码
运行服务器

通常通过MVC配置在基于DispatcherHandler的设置中运行路由器函数，该配置使用Spring配置声明处置惩罚请求所需的组件。MVC Java配置声明以下基础结构组件以支持功能性端点：

上述组件让功能性端点可以或许融入DispatcherServlet的请求处置惩罚生命周期中，并且（潜伏地）与注解控制器并行运行（如果有声明的话）。这也是Spring Boot Web启动器启用功能性端点的方式。
以下示例展示了一个WebFlux Java配置：
  1. @Configuration
  2. @EnableMvc
  3. public class WebConfig implements WebMvcConfigurer {
  5.         @Bean
  6.         public RouterFunction<?> routerFunctionA() {
  7.                 // ...
  8.         }
  10.         @Bean
  11.         public RouterFunction<?> routerFunctionB() {
  12.                 // ...
  13.         }
  15.         // ...
  17.         @Override
  18.         public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
  19.                 // configure message conversion...
  20.         }
  22.         @Override
  23.         public void addCorsMappings(CorsRegistry registry) {
  24.                 // configure CORS...
  25.         }
  27.         @Override
  28.         public void configureViewResolvers(ViewResolverRegistry registry) {
  29.                 // configure view resolution for HTML rendering...
  30.         }
  31. }
复制代码
过滤处置惩罚函数

你可以通过在路由函数构建器上使用before、after或filter方法来过滤处置惩罚函数。通过注解，你可以使用@ControllerAdvice、ServletFilter或两者来实现类似的功能。过滤器将应用于构建器构建的所有路由。这意味着在嵌套路由中界说的过滤器不实用于“顶层”路由。比方，思量以下示例：
  1. RouterFunction<ServerResponse> route = route()
  2.         .path("/person", b1 -> b1
  3.                 .nest(accept(APPLICATION_JSON), b2 -> b2
  4.                         .GET("/{id}", handler::getPerson)
  5.                         .GET(handler::listPeople)
  6.                         .before(request -> ServerRequest.from(request)
  7.                                 .header("X-RequestHeader", "Value")
  8.                                 .build()))
  9.                 .POST(handler::createPerson))
  10.         .after((request, response) -> logResponse(response))
  11.         .build();
复制代码
路由器构建器上的filter方法担当一个HandlerFilterFunction：这是一个担当ServerRequest和HandlerFunction并返回ServerResponse的函数。处置惩罚函数参数表现链中的下一个元素。这通常是被路由到的处置惩罚步伐，但如果应用了多个过滤器，它也可以是另一个过滤器。
如今我们可以向路由中添加一个简单的安全过滤器，假设我们有一个SecurityManager可以或许确定特定路径是否被允许。以下示例展示了如何做到这一点：
  1. SecurityManager securityManager = ...
  3. RouterFunction<ServerResponse> route = route()
  4.         .path("/person", b1 -> b1
  5.                 .nest(accept(APPLICATION_JSON), b2 -> b2
  6.                         .GET("/{id}", handler::getPerson)
  7.                         .GET(handler::listPeople))
  8.                 .POST(handler::createPerson))
  9.         .filter((request, next) -> {
  10.                 if (securityManager.allowAccessTo(request.path())) {
  11.                         return next.handle(request);
  12.                 }
  13.                 else {
  14.                         return ServerResponse.status(UNAUTHORIZED).build();
  15.                 }
  16.         })
  17.         .build();
复制代码
前面的例子表明，调用next.handle(ServerRequest)是可选的。我们只在访问被允许时才运行处置惩罚函数。
除了在路由器函数构建器上使用filter方法外，还可以通过RouterFunction.filter(HandlerFilterFunction)将过滤器应用于现有的路由器函数。
对于功能性端点，通过专用的CorsFilter提供了CORS支持。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4