功能终结点 (Functional Endpoints) _ Spring Framework 6.1.10 中文文档(官方文档中文翻译) —

Spring Web MVC 包括 WebMvc.fn，这是一个轻量级的函数式编程模型，其中函数用于路由和处理请求，而合约则设计为不可变性。它是基于注释的编程模型的替代方案，但在其他方面运行相同的 DispatcherServlet。Spring中文文档

概述

请参阅 Reactive 堆栈中的等效项Spring中文文档

在 WebMvc.fn 中，HTTP 请求使用：一个接受并返回 . request 和 response 对象都具有不可变的协定，这些协定提供对 JDK 8 友好的访问 HTTP 请求和响应。等价于方法的主体基于注释的编程模型。HandlerFunctionServerRequestServerResponseHandlerFunction@RequestMappingSpring中文文档

传入请求被路由到具有：的处理程序函数：获取并返回一个可选的（即）。当路由器函数匹配时，返回处理程序函数;否则为空的 Optional。相当于一个注释，但带有 major 路由器功能不仅提供数据，还提供行为。RouterFunctionServerRequestHandlerFunctionOptional<HandlerFunction>RouterFunction@RequestMappingSpring中文文档

RouterFunctions.route()提供路由器构建器，方便创建路由器，如以下示例所示：Spring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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	使用创建路由器。`route()`

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 {
		// ...
	}
}

1	使用路由器DSL创建路由器。

如果将 Bean 注册为 Bean，例如通过在类中公开它，Servlet 将自动检测到它，如运行服务器中所述。RouterFunction@ConfigurationSpring中文文档

1	使用创建路由器。`route()`

1	使用路由器DSL创建路由器。

HandlerFunction 函数

请参阅 Reactive 堆栈中的等效项Spring中文文档

ServerRequest并且是提供 JDK 8 友好的不可变接口访问 HTTP 请求和响应，包括标头、正文、方法和状态代码。ServerResponseSpring中文文档

服务器请求

ServerRequest提供对 HTTP 方法、URI、标头和查询参数的访问，而通过这些方法提供对身体的访问。bodySpring中文文档

以下示例将请求正文提取为：StringSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

String string = request.body(String.class);

val string = request.body<String>()

以下示例将正文提取为，其中对象是从序列化表单（如 JSON 或 XML）解码的：List<Person>PersonSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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

val people = request.body<Person>()

以下示例演示如何访问参数：Spring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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

val map = request.params()

服务器响应

ServerResponse提供对 HTTP 响应的访问，并且由于它是不可变的，因此您可以使用创建它的方法。您可以使用构建器设置响应状态，添加响应标头，或提供正文。以下示例使用 JSON 创建 200 （OK）响应内容：buildSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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

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

以下示例演示如何生成具有标头且没有正文的 201 （CREATED）响应：LocationSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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

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

还可以使用异步结果作为正文，其形式为、或支持的任何其他类型。例如：CompletableFuturePublisherReactiveAdapterRegistrySpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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)

如果不仅正文，而且状态或标头都基于异步类型，您可以在上使用 static 方法，其中接受、或支持的任何其他异步类型。例如：asyncServerResponseCompletableFuture<ServerResponse>Publisher<ServerResponse>ReactiveAdapterRegistrySpring中文文档

JavaSpring中文文档

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

服务器发送的事件可以通过上的静态方法。该方法提供的生成器允许您以 JSON 格式发送字符串或其他对象。例如：sseServerResponseSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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

处理程序类

我们可以将处理程序函数编写为 lambda，如以下示例所示：Spring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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

val helloWorld: (ServerRequest) -> ServerResponse =
  { ServerResponse.ok().body("Hello World") }

这很方便，但是在应用程序中，我们需要多个函数和多个内联 lambda 可能会变得混乱。因此，将相关的处理程序函数组合到一个处理程序类中是很有用的，该类具有与基于批注的应用程序类似的角色。例如，以下类公开一个反应式存储库：@ControllerPersonSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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`是一个处理程序函数，返回单个人，由路径标识变量。我们从存储库中检索它并创建一个 JSON 响应（如果是）发现。如果未找到，我们将返回 404 Not Found 响应。`idPerson`

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

	}
}

1	`listPeople`是一个处理程序函数，它将存储库中找到的所有对象返回为 JSON中。`Person`
2	`createPerson`是一个处理程序函数，用于存储请求正文中包含的新内容。`Person`
3	`getPerson`是一个处理程序函数，返回单个人，由路径标识变量。我们从存储库中检索它并创建一个 JSON 响应（如果是）发现。如果未找到，我们将返回 404 Not Found 响应。`idPerson`

验证

功能端点可以使用 Spring 的验证工具来执行以下操作将验证应用于请求正文。例如，给定一个自定义的 Spring Validator 实现：PersonSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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	创建实例。`Validator`
2	应用验证。
3	引发 400 响应的异常。

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

1	创建实例。`Validator`
2	应用验证。
3	引发 400 响应的异常。

处理程序还可以通过创建和注入来使用标准 Bean 验证 API （JSR-303）基于的全局实例。请参阅 Spring 验证。ValidatorLocalValidatorFactoryBeanSpring中文文档

1	`listPeople`是一个处理程序函数，它将存储库中找到的所有对象返回为 JSON中。`Person`
2	`createPerson`是一个处理程序函数，用于存储请求正文中包含的新内容。`Person`
3	`getPerson`是一个处理程序函数，返回单个人，由路径标识变量。我们从存储库中检索它并创建一个 JSON 响应（如果是）发现。如果未找到，我们将返回 404 Not Found 响应。`idPerson`

1	`listPeople`是一个处理程序函数，它将存储库中找到的所有对象返回为 JSON中。`Person`
2	`createPerson`是一个处理程序函数，用于存储请求正文中包含的新内容。`Person`
3	`getPerson`是一个处理程序函数，返回单个人，由路径标识变量。我们从存储库中检索它并创建一个 JSON 响应（如果是）发现。如果未找到，我们将返回 404 Not Found 响应。`idPerson`

1	创建实例。`Validator`
2	应用验证。
3	引发 400 响应的异常。

1	创建实例。`Validator`
2	应用验证。
3	引发 400 响应的异常。

`RouterFunction`

请参阅 Reactive 堆栈中的等效项Spring中文文档

路由器函数用于将请求路由到相应的 . 通常，您不会自己编写路由器函数，而是使用实用程序类上的方法来创建一个路由器函数。（无参数）为您提供用于创建路由器的流畅构建器功能，而提供了一种直接的方式创建路由器。HandlerFunctionRouterFunctionsRouterFunctions.route()RouterFunctions.route(RequestPredicate, HandlerFunction)Spring中文文档

通常，建议使用构建器，因为它提供了为典型测绘场景提供方便的快捷方式，无需难以发现静态导入。例如，路由器功能构建器提供了为 GET 请求创建映射的方法;和 POST。route()GET(String, HandlerFunction)POST(String, HandlerFunction)Spring中文文档

除了基于 HTTP 方法的映射之外，路由构建器还提供了一种引入其他映射到请求时的谓词。对于每个 HTTP 方法，都有一个重载变体，该变体将 a 作为参数，通过该参数可以表示其他约束。RequestPredicateSpring中文文档

谓词

您可以编写自己的，但实用程序类提供常用的实现，基于请求路径、HTTP 方法、 content-type、等等。以下示例使用请求谓词创建基于标头的约束：RequestPredicateRequestPredicatesAcceptSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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

您可以使用以下方法将多个请求谓词组合在一起：Spring中文文档

RequestPredicate.and(RequestPredicate)— 两者必须匹配。Spring中文文档
RequestPredicate.or(RequestPredicate)— 两者都可以匹配。Spring中文文档

许多谓词都是由组成。例如，由和组成。上面显示的示例还使用了两个请求谓词，就像构建器在内部使用的那样，并用谓词组成。RequestPredicatesRequestPredicates.GET(String)RequestPredicates.method(HttpMethod)RequestPredicates.path(String)RequestPredicates.GETacceptSpring中文文档

路线

路由器功能按顺序计算：如果第一条路由不匹配，则第二是评估，依此类推。因此，在一般路线之前声明更具体的路线是有意义的。在将路由器功能注册为 Spring bean 时，这一点也很重要，就像稍后再描述。请注意，此行为与基于注释的编程模型不同，其中自动选择“最具体”的控制器方法。Spring中文文档

使用路由器功能构建器时，所有定义的路由都组合成一个从返回的路由。还有其他方法可以将多个路由器功能组合在一起：RouterFunctionbuild()Spring中文文档

add(RouterFunction)在构建器上RouterFunctions.route()Spring中文文档
RouterFunction.and(RouterFunction)Spring中文文档
RouterFunction.andRoute(RequestPredicate, HandlerFunction)— 嵌套的快捷方式。RouterFunction.and()RouterFunctions.route()Spring中文文档

以下示例显示了四条路由的组成：Spring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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	`GET /person/{id}`与路由到 JSON 匹配的标头`AcceptPersonHandler.getPerson`
2	`GET /person`与路由到 JSON 匹配的标头`AcceptPersonHandler.listPeople`
3	`POST /person`没有附加谓词映射到，并且`PersonHandler.createPerson`
4	`otherRoute`是在其他地方创建的路由器功能，并添加到构建的路由中。

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)

1	`GET /person/{id}`与路由到 JSON 匹配的标头`AcceptPersonHandler.getPerson`
2	`GET /person`与路由到 JSON 匹配的标头`AcceptPersonHandler.listPeople`
3	`POST /person`没有附加谓词映射到，并且`PersonHandler.createPerson`
4	`otherRoute`是在其他地方创建的路由器功能，并添加到构建的路由中。

嵌套路由

一组路由器函数通常具有共享谓词，例如共享谓词路径。在上面的示例中，共享谓词将是匹配的路径谓词由其中三条路线使用。使用批注时，应使用映射到的类型级批注来删除此重复项。在 WebMvc.fn 中，可以通过路由器函数构建器上的方法共享路径谓词。例如，使用嵌套路由可以通过以下方式改进上述示例的最后几行：/person@RequestMapping/personpathSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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`

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

1	使用 DSL。`nest`

尽管基于路径的嵌套是最常见的，但您可以使用生成器上的方法。上面仍然包含一些共享标头谓词形式的重复。我们可以通过将该方法与以下方法结合使用来进一步改进：nestAcceptnestacceptSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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

1	`GET /person/{id}`与路由到 JSON 匹配的标头`AcceptPersonHandler.getPerson`
2	`GET /person`与路由到 JSON 匹配的标头`AcceptPersonHandler.listPeople`
3	`POST /person`没有附加谓词映射到，并且`PersonHandler.createPerson`
4	`otherRoute`是在其他地方创建的路由器功能，并添加到构建的路由中。

1	`GET /person/{id}`与路由到 JSON 匹配的标头`AcceptPersonHandler.getPerson`
2	`GET /person`与路由到 JSON 匹配的标头`AcceptPersonHandler.listPeople`
3	`POST /person`没有附加谓词映射到，并且`PersonHandler.createPerson`
4	`otherRoute`是在其他地方创建的路由器功能，并添加到构建的路由中。

1	请注意，第二个参数是采用路由器构建器的使用者。`path`

1	使用 DSL。`nest`

服务资源

WebMvc.fn 提供对提供资源的内置支持。Spring中文文档

除了下面描述的功能之外，借助 RouterFunctions#resource（java.util.function.Function），还可以实现更灵活的资源处理。

重定向到资源

可以将与指定谓词匹配的请求重定向到资源。这可能很有用，例如，用于处理单页应用程序中的重定向。Spring中文文档

JavaSpring中文文档
KotlinSpring中文文档

   ClassPathResource index = new ClassPathResource("static/index.html");
List<String> extensions = Arrays.asList("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)
}

从根位置提供资源

还可以将与给定模式匹配的请求路由到相对于给定根位置的资源。Spring中文文档

JavaSpring中文文档
KotlinSpring中文文档

Resource location = new FileSystemResource("public-resources/");
RouterFunction<ServerResponse> resources = RouterFunctions.resources("/resources/**", location);

val location = FileSystemResource("public-resources/")
val resources = router { resources("/resources/**", location) }

除了下面描述的功能之外，借助 RouterFunctions#resource（java.util.function.Function），还可以实现更灵活的资源处理。

运行服务器

请参阅 Reactive 堆栈中的等效项Spring中文文档

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

RouterFunctionMapping：在春季检测一个或多个豆子配置，对它们进行排序，将它们组合在一起，然后将请求路由到生成的组合。RouterFunction<?>RouterFunction.andOtherRouterFunctionSpring中文文档
HandlerFunctionAdapter：允许调用的简单适配器映射到请求的 a。DispatcherHandlerHandlerFunctionSpring中文文档

前面的组件允许功能终结点适合请求处理生命周期，并且（可能）与带注释的控制器并行运行，如果任何声明。这也是 Spring Boot Web 启用功能端点的方式起动机。DispatcherServletSpring中文文档

以下示例显示了 WebFlux Java 配置：Spring中文文档

JavaSpring中文文档
KotlinSpring中文文档

@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...
	}
}

筛选处理程序函数

请参阅 Reactive 堆栈中的等效项Spring中文文档

可以使用路由上的、或方法筛选处理程序函数函数生成器。使用批注，可以通过使用、和/或来实现类似的功能。过滤器将应用于构建器构建的所有路径。这意味着在嵌套路由中定义的筛选器不适用于“顶级”路由。例如，请考虑以下示例：beforeafterfilter@ControllerAdviceServletFilterSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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	添加自定义请求标头的筛选器仅应用于两个 GET 路由。`before`
2	记录响应的筛选器将应用于所有路由，包括嵌套路由。`after`

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

1	添加自定义请求标头的筛选器仅应用于两个 GET 路由。`before`
2	记录响应的筛选器将应用于所有路由，包括嵌套路由。`after`

路由器构建器上的方法需要： a 函数接受 a 和并返回 . 处理程序函数参数表示链中的下一个元素。这通常是路由到的处理程序，但它也可以是另一个筛选是否应用了多个。filterHandlerFilterFunctionServerRequestHandlerFunctionServerResponseSpring中文文档

现在我们可以在路由中添加一个简单的安全过滤器，假设我们有一个可以确定是否允许特定路径。以下示例演示如何执行此操作：SecurityManagerSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

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)Spring中文文档

除了在路由器功能构建器上使用该方法外，还可以应用通过过滤到现有路由器功能。filterRouterFunction.filter(HandlerFilterFunction)Spring中文文档

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

1	添加自定义请求标头的筛选器仅应用于两个 GET 路由。`before`
2	记录响应的筛选器将应用于所有路由，包括嵌套路由。`after`

1	添加自定义请求标头的筛选器仅应用于两个 GET 路由。`before`
2	记录响应的筛选器将应用于所有路由，包括嵌套路由。`after`

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