Functional Endpoints
-
ServerResponse
-
RouterFunction
-
RouterFunctions
-
PathVariable
-
Mono
-
Flux
-
Validator :description: Spring WebFlux.fn 是一个轻量级的函数式编程模型,其中函数用于路由和处理,而契约被设计为不可变。它在 Reactive Core 的基础上运行,旨在替代基于注解的编程模型。WebFlux.fn 通过 HandlerFunctions 和 ServerResponse 来处理 HTTP 请求和响应。HandlerFunction 是一个获取 ServerRequest 并返回延迟 ServerResponse 的函数。RouterFunction 是一个获取 ServerRequest 并返回延迟 HandlerFunction 的函数。可以使用 RouterFunctions.route() 来创建路由,其中路由函数接受谓词和处理函数。通过使用嵌套路由,可以将常见的谓词分组到具有共享路径的路由器函数中。WebFlux.fn 还允许将请求重定向到资源,并提供对在根位置提供服务的资源的支持。 See equivalent in the Servlet stack
Spring WebFlux 包含 WebFlux.fn,这是一个轻量级的函数式编程模型,其中函数用于路由和处理请求,并且合约旨在不可变。它是一种基于注释的编程模型的替代方法,但在其他方面运行在相同的 Reactive Core 基础上。
Overview
在 WebFlux.fn 中,通过 HandlerFunction
处理 HTTP 请求:一个取用`ServerRequest` 并返回延迟的 ServerResponse
的函数(即 Mono<ServerResponse>
)。请求和响应对象都具有不可变契约,这些契约为 HTTP 请求和响应提供了符合 JDK 8 的访问。HandlerFunction
等效于基于注解的编程模型中 @RequestMapping
方法的主体。
传入请求将路由到带有 RouterFunction
的处理程序函数:一个将接受 ServerRequest
并返回延迟的 HandlerFunction
(即 Mono<HandlerFunction>
)的函数。当路由器函数匹配时,将返回处理程序函数;否则为空 Mono
。RouterFunction
相当于一个 @RequestMapping
注解,但主要区别在于,路由器函数不仅仅提供数据,而且还提供行为。
RouterFunctions.route()
提供了一个路由构建器,它使用户能够轻松创建路由,如下图例所示:
- Java
-
import static org.springframework.http.MediaType.APPLICATION_JSON; import static org.springframework.web.reactive.function.server.RequestPredicates.*; import static org.springframework.web.reactive.function.server.RouterFunctions.route; PersonRepository repository = ... PersonHandler handler = new PersonHandler(repository); RouterFunction<ServerResponse> route = route() 1 .GET("/person/{id}", accept(APPLICATION_JSON), handler::getPerson) .GET("/person", accept(APPLICATION_JSON), handler::listPeople) .POST("/person", handler::createPerson) .build(); public class PersonHandler { // ... public Mono<ServerResponse> listPeople(ServerRequest request) { // ... } public Mono<ServerResponse> createPerson(ServerRequest request) { // ... } public Mono<ServerResponse> getPerson(ServerRequest request) { // ... } }
1 | Create router using route() .
|
2 | 创建路由,使用协同程序路由 DSL;还可通过 router { } 使用响应式替代方案。 |
运行`RouterFunction`的一种方法是将其转换为`HttpHandler`,并通过一个内置的server adapters安装:
-
RouterFunctions.toHttpHandler(RouterFunction)
-
RouterFunctions.toHttpHandler(RouterFunction, HandlerStrategies)
大多数应用程序可以通过 WebFlux Java 配置运行,请参阅Running a Server。
HandlerFunction
ServerRequest`和`ServerResponse`是不可变接口,可提供对 HTTP 请求和响应的 JDK 8 友好访问。请求和响应均对正文流提供https://www.reactive-streams.org[反应流]背压。请求正文使用 Reactor `Flux`或`Mono`表示。响应正文使用任何反应流`Publisher`表示,包括`Flux`和`Mono
。有关更多详细信息,请参阅Reactive Libraries。
ServerRequest
ServerRequest
提供对 HTTP 方法、URI、标头和查询参数的访问,而对主体的访问是通过 body
方法提供的。
以下示例将请求正文提取到 Mono<String>
:
-
Java
-
Kotlin
Mono<String> string = request.bodyToMono(String.class);
val string = request.awaitBody<String>()
以下示例将正文提取到 Flux<Person>
(或 Kotlin 中的 Flow<Person>
),其中`Person` 对象是从某种已序列化形式(例如 JSON 或 XML)解码而来:
-
Java
-
Kotlin
Flux<Person> people = request.bodyToFlux(Person.class);
val people = request.bodyToFlow<Person>()
前面的示例是快捷方式,它使用了更通用的 ServerRequest.body(BodyExtractor)
,它接受 BodyExtractor
函数式策略接口。实用程序类 BodyExtractors
可访问许多实例。例如,前面的示例也可以写成以下形式:
-
Java
-
Kotlin
Mono<String> string = request.body(BodyExtractors.toMono(String.class));
Flux<Person> people = request.body(BodyExtractors.toFlux(Person.class));
val string = request.body(BodyExtractors.toMono(String::class.java)).awaitSingle()
val people = request.body(BodyExtractors.toFlux(Person::class.java)).asFlow()
以下示例展示如何访问表单数据:
-
Java
-
Kotlin
Mono<MultiValueMap<String, String>> map = request.formData();
val map = request.awaitFormData()
以下示例展示如何以映射形式访问 multipart 数据:
-
Java
-
Kotlin
Mono<MultiValueMap<String, Part>> map = request.multipartData();
val map = request.awaitMultipartData()
以下示例展示如何一次访问 multipart 数据并以流式传输形式访问:
-
Java
-
Kotlin
Flux<PartEvent> allPartEvents = request.bodyToFlux(PartEvent.class);
allPartsEvents.windowUntil(PartEvent::isLast)
.concatMap(p -> p.switchOnFirst((signal, partEvents) -> {
if (signal.hasValue()) {
PartEvent event = signal.get();
if (event instanceof FormPartEvent formEvent) {
String value = formEvent.value();
// handle form field
}
else if (event instanceof FilePartEvent fileEvent) {
String filename = fileEvent.filename();
Flux<DataBuffer> contents = partEvents.map(PartEvent::content);
// handle file upload
}
else {
return Mono.error(new RuntimeException("Unexpected event: " + event));
}
}
else {
return partEvents; // either complete or error signal
}
}));
val parts = request.bodyToFlux<PartEvent>()
allPartsEvents.windowUntil(PartEvent::isLast)
.concatMap {
it.switchOnFirst { signal, partEvents ->
if (signal.hasValue()) {
val event = signal.get()
if (event is FormPartEvent) {
val value: String = event.value();
// handle form field
} else if (event is FilePartEvent) {
val filename: String = event.filename();
val contents: Flux<DataBuffer> = partEvents.map(PartEvent::content);
// handle file upload
} else {
return Mono.error(RuntimeException("Unexpected event: " + event));
}
} else {
return partEvents; // either complete or error signal
}
}
}
}
请注意,PartEvent
对象的正文内容必须完全被消耗、中继或释放,以避免内存泄漏。
ServerResponse
ServerResponse
提供对 HTTP 响应的访问,而且因为它不可变,所以你可以使用 build
方法来创建它。你可以使用该构建器设置响应状态、添加响应标头或提供一个主体。下例创建了一个 200 (OK) 响应(带有 JSON 内容):
-
Java
-
Kotlin
Mono<Person> person = ...
ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(person, Person.class);
val person: Person = ...
ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).bodyValue(person)
下例展示了如何构建一个 201 (CREATED) 响应(带有 Location
标头和空主体):
-
Java
-
Kotlin
URI location = ...
ServerResponse.created(location).build();
val location: URI = ...
ServerResponse.created(location).build()
根据所使用的编解码器,可以传递提示参数来自定义主体的序列化或反序列化方式。例如,要指定一个https://www.baeldung.com/jackson-json-view-annotation[Jackson JSON 视图]:
-
Java
-
Kotlin
ServerResponse.ok().hint(Jackson2CodecSupport.JSON_VIEW_HINT, MyJacksonView.class).body(...);
ServerResponse.ok().hint(Jackson2CodecSupport.JSON_VIEW_HINT, MyJacksonView::class.java).body(...)
Handler Classes
我们可以将一个处理函数编写为一个 lambda,如下图例所示:
-
Java
-
Kotlin
HandlerFunction<ServerResponse> helloWorld =
request -> ServerResponse.ok().bodyValue("Hello World");
val helloWorld = HandlerFunction<ServerResponse> { ServerResponse.ok().bodyValue("Hello World") }
这样做很方便,但在应用程序中,我们需要多个函数,并且多个内联 lambda 可能很混乱。因此,将相关的处理函数分组在一个处理函数类中很有用,这个类在基于注解的应用程序中所扮演的角色与 @Controller
类似。例如,下例公开了一个响应式的 Person
存储库:
- Java
-
import static org.springframework.http.MediaType.APPLICATION_JSON; import static org.springframework.web.reactive.function.server.ServerResponse.ok; public class PersonHandler { private final PersonRepository repository; public PersonHandler(PersonRepository repository) { this.repository = repository; } public Mono<ServerResponse> listPeople(ServerRequest request) { (1) Flux<Person> people = repository.allPeople(); return ok().contentType(APPLICATION_JSON).body(people, Person.class); } public Mono<ServerResponse> createPerson(ServerRequest request) { (2) Mono<Person> person = request.bodyToMono(Person.class); return ok().build(repository.savePerson(person)); } public Mono<ServerResponse> getPerson(ServerRequest request) { (3) int personId = Integer.valueOf(request.pathVariable("id")); return repository.getPerson(personId) .flatMap(person -> ok().contentType(APPLICATION_JSON).bodyValue(person)) .switchIfEmpty(ServerResponse.notFound().build()); } }
1 | listPeople 是一个处理函数,它以 JSON 格式返回存储库中找到的所有 Person 对象。 |
2 | createPerson 是一个处理函数,用于存储请求主体中包含的新的 Person 。请注意,PersonRepository.savePerson(Person) 返回 Mono<Void> :一个空的 Mono ,当 从请求读取人员并存储该人员时,发出完成信号。因此,我们使用 build(Publisher<Void>) 方法在收到该完成信号(即存储了 Person 时)发送响应。 |
3 | getPerson 是一个处理函数,返回一个由 id 路径变量标识的单个人员。如果找到该 Person ,我们从仓库中检索该 Person 并创建一个 JSON 响应。如果未找到,我们使用 switchIfEmpty(Mono<T>) 返回 404 未找到响应。
|
4 | listPeople 是一个处理函数,它以 JSON 格式返回存储库中找到的所有 Person 对象。 |
5 | createPerson 是一个处理函数,用于存储请求主体中包含的新的 Person 。请注意,PersonRepository.savePerson(Person) 是一个挂起函数,没有返回类型。 |
6 | getPerson 是一个处理函数,它返回一个单个人,由 id 路径变量标识。如果找到,我们将从存储库中检索该 Person ,并创建一个 JSON 响应。如果找不到,我们将返回 404 未找到响应。 |
Validation
函数式端点可以使用 Spring 的 validation facilities 对请求正文进行验证。例如,给定 Person
的自定义 Spring Validator 实现:
- Java
-
public class PersonHandler { private final Validator validator = new PersonValidator(); (1) // ... public Mono<ServerResponse> createPerson(ServerRequest request) { Mono<Person> person = request.bodyToMono(Person.class).doOnNext(this::validate); (2) return ok().build(repository.savePerson(person)); } private void validate(Person person) { Errors errors = new BeanPropertyBindingResult(person, "person"); validator.validate(person, errors); if (errors.hasErrors()) { throw new ServerWebInputException(errors.toString()); (3) } } }
1 | Create Validator instance. |
2 | Apply validation. |
3 | 为 400 响应引发异常。
|
4 | Create Validator instance. |
5 | Apply validation. |
6 | 为 400 响应引发异常。 |
处理程序还可以创建一个全局`Validator`实例并将其注入,进而使用标准 Bean 验证 API (JSR-303),该实例基于`LocalValidatorFactoryBean`。请参见Spring Validation。
RouterFunction
路由函数用于将请求路由到对应的 HandlerFunction
。通常,您不会自己编写路由函数,而是使用 RouterFunctions
实用类上的一个方法来创建一个。RouterFunctions.route()
(无参数)为一个流畅的构建器,用于创建一个路由函数,而 RouterFunctions.route(RequestPredicate, HandlerFunction)
提供了一个创建一个路由的直接方式。
通常建议使用 route()
构建器,因为它为典型的映射场景提供方便的快捷方式,而无需使用难以发现的静态导入。例如,路由函数构建器提供 GET(String, HandlerFunction)
方法来为 GET 请求创建一个映射;POST(String, HandlerFunction)
为 POST 请求创建一个映射。
除了基于 HTTP 方法的映射之外,路由生成器还提供了一种方法,以便在映射到请求时引入附加谓词。对于每个 HTTP 方法,都有一个重载变量,它将 RequestPredicate
作为参数,尽管可以表达哪些附加约束条件。
Predicates
您可以编写自己的 RequestPredicate
,但 RequestPredicates
实用类提供基于请求路径、HTTP 方法、内容类型等的常用实现。以下示例使用请求谓词基于 Accept
头创建约束:
-
Java
-
Kotlin
RouterFunction<ServerResponse> route = RouterFunctions.route()
.GET("/hello-world", accept(MediaType.TEXT_PLAIN),
request -> ServerResponse.ok().bodyValue("Hello World")).build();
val route = coRouter {
GET("/hello-world", accept(TEXT_PLAIN)) {
ServerResponse.ok().bodyValueAndAwait("Hello World")
}
}
您可以通过使用以下方法组合多个请求谓词:
-
RequestPredicate.and(RequestPredicate)
— both must match. -
RequestPredicate.or(RequestPredicate)
— either can match.
RequestPredicates
中的许多谓词是组合的。例如,RequestPredicates.GET(String)
由 RequestPredicates.method(HttpMethod)
和 RequestPredicates.path(String)
组合而成。上面所示的示例还使用两个请求谓词,因为构建器在内部使用 RequestPredicates.GET
,并将其与 accept
谓词组合。
Routes
路由函数按顺序评估:如果第一个路由不匹配,则评估第二个路由,依此类推。因此,在通用路由之前声明更具体的路由是有意义的。在将路由函数注册为 Spring bean 时,这一点也很重要,如下所述。请注意,此行为不同于基于注释的编程模型,其中“最具体”的控制器方法是自动选择的。
使用路由函数构建器时,所有已定义的路由都组合成一个 RouterFunction
,该 RouterFunction
从 build()
返回。还有其他方法可以将多个路由函数组合在一起:
-
add(RouterFunction)
在RouterFunctions.route()
构建器上 -
RouterFunction.and(RouterFunction)
-
RouterFunction.andRoute(RequestPredicate, HandlerFunction)
— 用于RouterFunction.and()
的快捷方式,带有嵌套RouterFunctions.route()
。
以下示例显示了四个路由的组合:
- Java
-
import static org.springframework.http.MediaType.APPLICATION_JSON; import static org.springframework.web.reactive.function.server.RequestPredicates.*; PersonRepository repository = ... PersonHandler handler = new PersonHandler(repository); RouterFunction<ServerResponse> otherRoute = ... RouterFunction<ServerResponse> route = route() .GET("/person/{id}", accept(APPLICATION_JSON), handler::getPerson) (1) .GET("/person", accept(APPLICATION_JSON), handler::listPeople) (2) .POST("/person", handler::createPerson) (3) .add(otherRoute) (4) .build();
1 | 带有与 JSON 匹配的 Accept 标头的 GET /person/{id} 路由到 PersonHandler.getPerson |
2 | 带有与 JSON 匹配的 Accept 标头的 GET /person 路由到 PersonHandler.listPeople |
3 | 没有其他谓词的 POST /person 映射到 PersonHandler.createPerson ,并且 |
4 | otherRoute 是一个路由器函数,它在其他地方被创建,并添加到已构建的路由中。
|
5 | 带有与 JSON 匹配的 Accept 标头的 GET /person/{id} 路由到 PersonHandler.getPerson |
6 | 带有与 JSON 匹配的 Accept 标头的 GET /person 路由到 PersonHandler.listPeople |
7 | 没有其他谓词的 POST /person 映射到 PersonHandler.createPerson ,并且 |
8 | otherRoute 是一个路由器函数,它在其他地方被创建,并添加到已构建的路由中。 |
Nested Routes
通常,一组路由器函数具有共享谓词,例如共享路径。在上面的示例中,共享谓词将是路径谓词,它匹配 /person
,三个路由使用该谓词。在使用注解时,可以通过使用映射到 /person
的类型级 @RequestMapping
注解来消除此重复行为。在 WebFlux.fn 中,可以通过路由函数生成器上的 path
方法共享路径谓词。例如,可以通过使用嵌套路由以以下方式改进上面示例的最后几行:
- Java
-
RouterFunction<ServerResponse> route = route() .path("/person", builder -> builder (1) .GET("/{id}", accept(APPLICATION_JSON), handler::getPerson) .GET(accept(APPLICATION_JSON), handler::listPeople) .POST(handler::createPerson)) .build();
1 | 请注意,path 的第二个参数是一个使用路由器构建器的使用者。
|
2 | 创建路由,使用协同程序路由 DSL;还可通过 router { } 使用响应式替代方案。 |
虽然基于路径的嵌套是最常见的,但是您可以通过使用构建器上的 nest
方法嵌套在任何类型的谓词上。上面仍然包含一些重复,形式为共享的 Accept
头谓词。我们可以通过将 nest
方法与 accept
一起使用来进一步改进:
-
Java
-
Kotlin
RouterFunction<ServerResponse> route = route()
.path("/person", b1 -> b1
.nest(accept(APPLICATION_JSON), b2 -> b2
.GET("/{id}", handler::getPerson)
.GET(handler::listPeople))
.POST(handler::createPerson))
.build();
val route = coRouter {
"/person".nest {
accept(APPLICATION_JSON).nest {
GET("/{id}", handler::getPerson)
GET(handler::listPeople)
POST(handler::createPerson)
}
}
}
Serving Resources
WebFlux.fn 为提供服务提供内置支持。
除了以下描述的功能之外,还可以实现更灵活的资源处理,这得益于 |
Redirecting to a resource
可以将与指定谓词匹配的请求重定向到资源。例如,这对于处理单页面应用程序中的重定向非常有用。
-
Java
-
Kotlin
ClassPathResource index = new ClassPathResource("static/index.html");
List<String> extensions = List.of("js", "css", "ico", "png", "jpg", "gif");
RequestPredicate spaPredicate = path("/api/**").or(path("/error")).or(pathExtension(extensions::contains)).negate();
RouterFunction<ServerResponse> redirectToIndex = route()
.resource(spaPredicate, index)
.build();
val redirectToIndex = router {
val index = ClassPathResource("static/index.html")
val extensions = listOf("js", "css", "ico", "png", "jpg", "gif")
val spaPredicate = !(path("/api/**") or path("/error") or
pathExtension(extensions::contains))
resource(spaPredicate, index)
}
Serving resources from a root location
还可以将与给定模式匹配的请求路由到相对于给定根位置的资源。
-
Java
-
Kotlin
Resource location = new FileSystemResource("public-resources/");
RouterFunction<ServerResponse> resources = RouterFunctions.resources("/resources/**", location);
val location = FileSystemResource("public-resources/")
val resources = router { resources("/resources/**", location) }
Running a Server
如何在 HTTP 服务器中运行路由器函数?一种简单的选择是使用以下方法之一将路由器函数转换为一个 HttpHandler
:
-
RouterFunctions.toHttpHandler(RouterFunction)
-
RouterFunctions.toHttpHandler(RouterFunction, HandlerStrategies)
然后,你可以对返回的`HttpHandler`执行一系列服务器适配器,按照HttpHandler的服务器特定说明进行操作。
另一个更典型的选项(也由 Spring Boot 使用)是通过使用 Spring 配置来声明处理请求所需的组件的WebFlux Config,基于DispatcherHandler
运行设置。WebFlux Java 配置声明以下基础设施组件来支持功能性终端:
-
RouterFunctionMapping
:检测 Spring 配置中的一个或多个RouterFunction<?>
bean,orders them,通过RouterFunction.andOther
将它们组合在一起,并将请求路由到生成的组合RouterFunction
。 -
HandlerFunctionAdapter
:一个简单的适配器,它允许DispatcherHandler
调用已映射到请求的HandlerFunction
。 -
ServerResponseResultHandler
:通过调用ServerResponse
的writeTo
方法,处理从调用HandlerFunction
获得的结果。
前面的组件允许功能性端点在 DispatcherHandler
请求处理生命周期中以及(可能)并排随注释控制器一起运行(如果声明了的话)。Spring Boot WebFlux 启动器启用功能性端点的方式也是如此。
下面的示例显示了 WebFlux Java 配置(请参见 DispatcherHandler 以了解如何运行它):
-
Java
-
Kotlin
@Configuration
@EnableWebFlux
public class WebConfig implements WebFluxConfigurer {
@Bean
public RouterFunction<?> routerFunctionA() {
// ...
}
@Bean
public RouterFunction<?> routerFunctionB() {
// ...
}
// ...
@Override
public void configureHttpMessageCodecs(ServerCodecConfigurer configurer) {
// configure message conversion...
}
@Override
public void addCorsMappings(CorsRegistry registry) {
// configure CORS...
}
@Override
public void configureViewResolvers(ViewResolverRegistry registry) {
// configure view resolution for HTML rendering...
}
}
@Configuration
@EnableWebFlux
class WebConfig : WebFluxConfigurer {
@Bean
fun routerFunctionA(): RouterFunction<*> {
// ...
}
@Bean
fun routerFunctionB(): RouterFunction<*> {
// ...
}
// ...
override fun configureHttpMessageCodecs(configurer: ServerCodecConfigurer) {
// configure message conversion...
}
override fun addCorsMappings(registry: CorsRegistry) {
// configure CORS...
}
override fun configureViewResolvers(registry: ViewResolverRegistry) {
// configure view resolution for HTML rendering...
}
}
Filtering Handler Functions
可使用路由函数生成器中的 before
、after
或 filter
方法过滤处理程序函数。借助标注,可通过使用 @ControllerAdvice
、ServletFilter
或同时使用两者,实现类似功能。过滤器将应用到生成器构建的所有路由。这意味着在嵌套路由中定义的过滤器不会应用到“顶级”路由。例如,考虑以下示例:
- Java
-
RouterFunction<ServerResponse> route = route() .path("/person", b1 -> b1 .nest(accept(APPLICATION_JSON), b2 -> b2 .GET("/{id}", handler::getPerson) .GET(handler::listPeople) .before(request -> ServerRequest.from(request) (1) .header("X-RequestHeader", "Value") .build())) .POST(handler::createPerson)) .after((request, response) -> logResponse(response)) (2) .build();
1 | 仅将添加自定义请求头的 before 过滤器应用于两个 GET 路由。 |
2 | 将记录响应的 after 过滤器应用于所有路由,包括嵌套路由。
|
3 | 仅将添加自定义请求头的 before 过滤器应用于两个 GET 路由。 |
4 | 将记录响应的 after 过滤器应用于所有路由,包括嵌套路由。 |
路由生成器中的 filter
方法接收一个 HandlerFilterFunction
:一个接收 ServerRequest
和 HandlerFunction
并返回 ServerResponse
的函数。处理程序函数参数代表链中的下一个元素。这通常是指被路由到的处理程序,但如果应用了多个过滤器,它也可以是另一个过滤器。
现在,假设我们有一个可以确定特定路径是否被允许的 SecurityManager
,我们可以向路由中添加一个简单的安全性过滤器。以下示例展示了如何执行此操作:
-
Java
-
Kotlin
SecurityManager securityManager = ...
RouterFunction<ServerResponse> route = route()
.path("/person", b1 -> b1
.nest(accept(APPLICATION_JSON), b2 -> b2
.GET("/{id}", handler::getPerson)
.GET(handler::listPeople))
.POST(handler::createPerson))
.filter((request, next) -> {
if (securityManager.allowAccessTo(request.path())) {
return next.handle(request);
}
else {
return ServerResponse.status(UNAUTHORIZED).build();
}
})
.build();
val securityManager: SecurityManager = ...
val route = router {
("/person" and accept(APPLICATION_JSON)).nest {
GET("/{id}", handler::getPerson)
GET("", handler::listPeople)
POST(handler::createPerson)
filter { request, next ->
if (securityManager.allowAccessTo(request.path())) {
next(request)
}
else {
status(UNAUTHORIZED).build();
}
}
}
}
上述示例表明调用 next.handle(ServerRequest)
是可选的。我们只有在允许访问时才运行处理程序函数。
除了在路由函数生成器中使用 filter
方法之外,还可通过 RouterFunction.filter(HandlerFilterFunction)
将过滤器应用到现有路由函数。
通过专用 xref:web/webflux-cors.adoc#webflux-cors-webfilter[ |