Functional Endpoints

Spring Web MVC 包含 WebMvc.fn，其中函数用于路由和处理请求，且协定设计为不可变，是一种轻量级函数式编程模型。它是基于注解的编程模型的替代方案，但在其他方面它在相同的 DispatcherServlet 上运行。

Overview

在 WebMvc.fn 中，使用 HandlerFunction 处理一个 HTTP 请求，这是个接受 ServerRequest 并返回 ServerResponse 的函数。请求和响应对象都具有不可变契约，使开发者能够以 JDK 8 友好的方式访问 HTTP 请求和响应。HandlerFunction 等于基于注解的编程模型中 @RequestMapping 方法的主体。

传入请求会通过一个 RouterFunction 路由到一个处理函数，该函数接受 ServerRequest 并返回一个可选的 HandlerFunction（即 Optional<HandlerFunction>）。当路由函数匹配成功时，会返回一个处理函数；否则返回一个空 Optional。RouterFunction 等于 @RequestMapping 注解，但存在一个主要差异，即路由函数不仅提供数据，还提供行为。

RouterFunctions.route() 提供了一个路由构建器，它使用户能够轻松创建路由，如下图例所示：

Java
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.web.servlet.function.RequestPredicates.*;
import static org.springframework.web.servlet.function.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 ServerResponse listPeople(ServerRequest request) {
		// ...
	}

	public ServerResponse createPerson(ServerRequest request) {
		// ...
	}

	public ServerResponse getPerson(ServerRequest request) {
		// ...
	}
}
1 Create router using route().
Kotlin
import org.springframework.web.servlet.function.router

val repository: PersonRepository = ...
val handler = PersonHandler(repository)

val route = router { (1)
	accept(APPLICATION_JSON).nest {
		GET("/person/{id}", handler::getPerson)
		GET("/person", handler::listPeople)
	}
	POST("/person", handler::createPerson)
}


class PersonHandler(private val repository: PersonRepository) {

	// ...

	fun listPeople(request: ServerRequest): ServerResponse {
		// ...
	}

	fun createPerson(request: ServerRequest): ServerResponse {
		// ...
	}

	fun getPerson(request: ServerRequest): ServerResponse {
		// ...
	}
}
2 使用路由器 DSL 创建路由器。

例如，如果您将 RouterFunction 注册为一个 bean，通过在 @Configuration 类中展示它，它将被 servlet 自动检测到，如 Running a Server 中所述。

HandlerFunction

ServerRequest 和 ServerResponse 是不可变接口，使开发者能够以 JDK 8 友好的方式访问 HTTP 请求和响应，包括标头、主体、方法和状态代码。

ServerRequest

ServerRequest 提供对 HTTP 方法、URI、标头和查询参数的访问，而对主体的访问是通过 body 方法提供的。

下例提取请求主体为一个 String：

  • Java

  • Kotlin

String string = request.body(String.class);
val string = request.body<String>()

下例将主体提取为 List<Person>，其中 Person 对象从序列化形式（例如 JSON 或 XML）解码而来：

  • Java

  • Kotlin

List<Person> people = request.body(new ParameterizedTypeReference<List<Person>>() {});
val people = request.body<Person>()

下例展示了如何访问参数：

  • Java

  • Kotlin

MultiValueMap<String, String> params = request.params();
val map = request.params()

ServerResponse

ServerResponse 提供对 HTTP 响应的访问，而且因为它不可变，所以你可以使用 build 方法来创建它。你可以使用该构建器设置响应状态、添加响应标头或提供一个主体。下例创建了一个 200 (OK) 响应（带有 JSON 内容）：

  • Java

  • Kotlin

Person person = ...
ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(person);
val person: Person = ...
ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(person)

下例展示了如何构建一个 201 (CREATED) 响应（带有 Location 标头和空主体）：

  • Java

  • Kotlin

URI location = ...
ServerResponse.created(location).build();
val location: URI = ...
ServerResponse.created(location).build()

你也可以使用一个异步结果作为一个主体，它可以是 CompletableFuture、Publisher 或任何其他受 ReactiveAdapterRegistry 支持的类型。例如：

  • Java

  • Kotlin

Mono<Person> person = webClient.get().retrieve().bodyToMono(Person.class);
ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(person);
val person = webClient.get().retrieve().awaitBody<Person>()
ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(person)

如果不仅主体，而且状态或标头也基于一个异步类型，则可以在 ServerResponse 上使用静态 async 方法，该方法接受 CompletableFuture<ServerResponse>、Publisher<ServerResponse> 或任何其他受 ReactiveAdapterRegistry 支持的异步类型。例如：

  • Java

Mono<ServerResponse> asyncResponse = webClient.get().retrieve().bodyToMono(Person.class)
  .map(p -> ServerResponse.ok().header("Name", p.name()).body(p));
ServerResponse.async(asyncResponse);

Server-Sent Events 可通过 ServerResponse 上的 sse 静态方法提供。该方法提供的构建器允许您发送字符串或其他对象作为 JSON。例如：

  • Java

  • Kotlin

public RouterFunction<ServerResponse> sse() {
	return route(GET("/sse"), request -> ServerResponse.sse(sseBuilder -> {
				// Save the sseBuilder object somewhere..
			}));
}

// In some other thread, sending a String
sseBuilder.send("Hello world");

// Or an object, which will be transformed into JSON
Person person = ...
sseBuilder.send(person);

// Customize the event by using the other methods
sseBuilder.id("42")
		.event("sse event")
		.data(person);

// and done at some point
sseBuilder.complete();
fun sse(): RouterFunction<ServerResponse> = router {
	GET("/sse") { request -> ServerResponse.sse { sseBuilder ->
		// Save the sseBuilder object somewhere..
	}
}

// In some other thread, sending a String
sseBuilder.send("Hello world")

// Or an object, which will be transformed into JSON
val person = ...
sseBuilder.send(person)

// Customize the event by using the other methods
sseBuilder.id("42")
		.event("sse event")
		.data(person)

// and done at some point
sseBuilder.complete()

Handler Classes

我们可以将一个处理函数编写为一个 lambda，如下图例所示：

  • Java

  • Kotlin

HandlerFunction<ServerResponse> helloWorld =
  request -> ServerResponse.ok().body("Hello World");
val helloWorld: (ServerRequest) -> ServerResponse =
  { ServerResponse.ok().body("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 ServerResponse listPeople(ServerRequest request) { (1)
		List<Person> people = repository.allPeople();
		return ok().contentType(APPLICATION_JSON).body(people);
	}

	public ServerResponse createPerson(ServerRequest request) throws Exception { (2)
		Person person = request.body(Person.class);
		repository.savePerson(person);
		return ok().build();
	}

	public ServerResponse getPerson(ServerRequest request) { (3)
		int personId = Integer.parseInt(request.pathVariable("id"));
		Person person = repository.getPerson(personId);
		if (person != null) {
			return ok().contentType(APPLICATION_JSON).body(person);
		}
		else {
			return ServerResponse.notFound().build();
		}
	}

}
1 listPeople 是一个处理函数，它以 JSON 格式返回存储库中找到的所有 Person 对象。
2 createPerson 是一个处理函数，它存储在请求正文中包含的新 Person。
3 getPerson 是一个处理函数，它返回一个单个人，由 id 路径变量标识。如果找到，我们将从存储库中检索该 Person，并创建一个 JSON 响应。如果找不到，我们将返回 404 未找到响应。
Kotlin
class PersonHandler(private val repository: PersonRepository) {

	fun listPeople(request: ServerRequest): ServerResponse { (1)
		val people: List<Person> = repository.allPeople()
		return ok().contentType(APPLICATION_JSON).body(people);
	}

	fun createPerson(request: ServerRequest): ServerResponse { (2)
		val person = request.body<Person>()
		repository.savePerson(person)
		return ok().build()
	}

	fun getPerson(request: ServerRequest): ServerResponse { (3)
		val personId = request.pathVariable("id").toInt()
		return repository.getPerson(personId)?.let { ok().contentType(APPLICATION_JSON).body(it) }
				?: ServerResponse.notFound().build()

	}
}
4 listPeople 是一个处理函数，它以 JSON 格式返回存储库中找到的所有 Person 对象。
5 createPerson 是一个处理函数，它存储在请求正文中包含的新 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 ServerResponse createPerson(ServerRequest request) {
		Person person = request.body(Person.class);
		validate(person); (2)
		repository.savePerson(person);
		return ok().build();
	}

	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 响应引发异常。
Kotlin
class PersonHandler(private val repository: PersonRepository) {

	private val validator = PersonValidator() (1)

	// ...

	fun createPerson(request: ServerRequest): ServerResponse {
		val person = request.body<Person>()
		validate(person) (2)
		repository.savePerson(person)
		return ok().build()
	}

	private fun validate(person: Person) {
		val errors: Errors = BeanPropertyBindingResult(person, "person")
		validator.validate(person, errors)
		if (errors.hasErrors()) {
			throw ServerWebInputException(errors.toString()) (3)
		}
	}
}
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().body("Hello World")).build();
import org.springframework.web.servlet.function.router

val route = router {
	GET("/hello-world", accept(TEXT_PLAIN)) {
		ServerResponse.ok().body("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.servlet.function.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 是一个路由器函数，它在其他地方被创建，并添加到已构建的路由中。
Kotlin
import org.springframework.http.MediaType.APPLICATION_JSON
import org.springframework.web.servlet.function.router

val repository: PersonRepository = ...
val handler = PersonHandler(repository);

val otherRoute = router {  }

val route = router {
	GET("/person/{id}", accept(APPLICATION_JSON), handler::getPerson) (1)
	GET("/person", accept(APPLICATION_JSON), handler::listPeople) (2)
	POST("/person", handler::createPerson) (3)
}.and(otherRoute) (4)
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 注释来消除这种重复。在 WebMvc.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 的第二个参数是一个使用路由器构建器的使用者。
Kotlin
import org.springframework.web.servlet.function.router

val route = router {
	"/person".nest { (1)
		GET("/{id}", accept(APPLICATION_JSON), handler::getPerson)
		GET(accept(APPLICATION_JSON), handler::listPeople)
		POST(handler::createPerson)
	}
}
2 Using nest DSL.

虽然基于路径的嵌套是最常见的，但是您可以通过使用构建器上的 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();
import org.springframework.web.servlet.function.router

val route = router {
	"/person".nest {
		accept(APPLICATION_JSON).nest {
			GET("/{id}", handler::getPerson)
			GET("", handler::listPeople)
			POST(handler::createPerson)
		}
	}
}

Serving Resources

WebMvc.fn 提供了用于提供资源的内置支持。

除了下面描述的功能外，还可以通过 [|RouterFunctions.resources()|](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/function/RouterFunctions.html#resources(java.util.function.Function)) 实现更为灵活的资源处理。

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

您通常会通过MVC Config在基于DispatcherHandler的设置中运行路由器函数，该设置使用 Spring 配置来声明处理请求所需的组件。MVC Java 配置声明以下基础设施组件以支持函数 end-point：

  • RouterFunctionMapping：检测 Spring 配置中的一个或多个 RouterFunction&lt;?&gt; bean，orders them，通过 RouterFunction.andOther 将它们组合在一起，并将请求路由到生成的组合 RouterFunction。

  • HandlerFunctionAdapter：一个简单的适配器，它允许 DispatcherHandler 调用已映射到请求的 HandlerFunction。

上述元件允许功能端点适用于 DispatcherServlet 请求处理生命周期，而且还可以（可能是）与已声明的标注控制器并排运行。这也是 Spring Boot Webstarter 启用功能端点的实现方法。

下面的示例展示了 WebFlux Java 配置：

  • Java

  • Kotlin

@Configuration
@EnableMvc
public class WebConfig implements WebMvcConfigurer {

	@Bean
	public RouterFunction<?> routerFunctionA() {
		// ...
	}

	@Bean
	public RouterFunction<?> routerFunctionB() {
		// ...
	}

	// ...

	@Override
	public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
		// configure message conversion...
	}

	@Override
	public void addCorsMappings(CorsRegistry registry) {
		// configure CORS...
	}

	@Override
	public void configureViewResolvers(ViewResolverRegistry registry) {
		// configure view resolution for HTML rendering...
	}
}
@Configuration
@EnableMvc
class WebConfig : WebMvcConfigurer {

	@Bean
	fun routerFunctionA(): RouterFunction<*> {
		// ...
	}

	@Bean
	fun routerFunctionB(): RouterFunction<*> {
		// ...
	}

	// ...

	override fun configureMessageConverters(converters: List<HttpMessageConverter<*>>) {
		// 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 过滤器应用于所有路由，包括嵌套路由。
Kotlin
import org.springframework.web.servlet.function.router

val route = router {
	"/person".nest {
		GET("/{id}", handler::getPerson)
		GET(handler::listPeople)
		before { (1)
			ServerRequest.from(it)
					.header("X-RequestHeader", "Value").build()
		}
	}
	POST(handler::createPerson)
	after { _, response -> (2)
		logResponse(response)
	}
}
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();
import org.springframework.web.servlet.function.router

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) 将过滤器应用到现有路由函数。

通过专用 CorsFilter 提供对功能终端的 CORS 支持。