函数式端点

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

概述

在 WebMvc.fn 中，HTTP 请求由 HandlerFunction 处理：一个接受 ServerRequest 并返回 ServerResponse 的函数。 请求和响应对象都具有不可变契约，提供对 HTTP 请求和响应的 JDK 8 友好访问。 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() [id="CO1-1"][id="CO1-1"][id="CO1-1"](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()` 创建路由器。
Kotlin
import org.springframework.web.servlet.function.router

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

val route = router { [id="CO2-1"][id="CO1-2"][id="CO2-1"](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 创建路由器。

如果您将 RouterFunction 注册为 bean，例如通过在 @Configuration 类中公开它，它将由 servlet 自动检测到，如 运行服务器 中所述。

HandlerFunction

ServerRequest 和 ServerResponse 是不可变接口，提供对 HTTP 请求和响应的 JDK 8 友好访问，包括头、主体、方法和状态码。

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

以下展示了如何绑定请求参数，包括可选的 DataBinder 自定义：

  • Java

  • Kotlin

Pet pet = request.bind(Pet.class, dataBinder -> dataBinder.setAllowedFields("name"));
val pet = request.bind(Pet::class.java, {dataBinder -> dataBinder.setAllowedFields("name")})

ServerResponse

ServerResponse 提供对 HTTP 响应的访问，由于它是不可变的，您可以使用 build 方法来创建它。您可以使用构建器设置响应状态、添加响应头或提供主体。以下示例创建了一个带有 JSON 内容的 200 (OK) 响应：

  • Java

  • Kotlin

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

以下示例展示了如何构建一个带有 Location 头且没有主体的 201 (CREATED) 响应：

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

服务器发送事件 可以通过 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()

处理程序类

我们可以将处理函数写成 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

  • Kotlin

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) { [id="CO3-1"][id="CO1-3"][id="CO3-1"](1)
		List<Person> people = repository.allPeople();
		return ok().contentType(APPLICATION_JSON).body(people);
	}

	public ServerResponse createPerson(ServerRequest request) throws Exception { [id="CO3-2"][id="CO1-4"][id="CO3-2"](2)
		Person person = request.body(Person.class);
		repository.savePerson(person);
		return ok().build();
	}

	public ServerResponse getPerson(ServerRequest request) { [id="CO3-3"][id="CO1-5"][id="CO3-3"](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 是一个处理函数，它将存储库中找到的所有 Person 对象作为 JSON 返回。
2 createPerson 是一个处理函数，它存储请求主体中包含的新 Person。
3 getPerson 是一个处理函数，它返回由 id 路径变量标识的单个 person。如果找到，我们从存储库中检索该 Person 并创建 JSON 响应。如果未找到，我们返回 404 Not Found 响应。 
class PersonHandler(private val repository: PersonRepository) {

	fun listPeople(request: ServerRequest): ServerResponse { [id="CO4-1"][id="CO1-6"][id="CO3-4"](1)
		val people: List<Person> = repository.allPeople()
		return ok().contentType(APPLICATION_JSON).body(people);
	}

	fun createPerson(request: ServerRequest): ServerResponse { [id="CO4-2"][id="CO1-7"][id="CO3-5"](2)
		val person = request.body<Person>()
		repository.savePerson(person)
		return ok().build()
	}

	fun getPerson(request: ServerRequest): ServerResponse { [id="CO4-3"][id="CO1-8"][id="CO3-6"](3)
		val personId = request.pathVariable("id").toInt()
		return repository.getPerson(personId)?.let { ok().contentType(APPLICATION_JSON).body(it) }
				?: ServerResponse.notFound().build()

	}
}
1 listPeople 是一个处理函数，它将存储库中找到的所有 Person 对象作为 JSON 返回。
2 createPerson 是一个处理函数，它存储请求主体中包含的新 Person。
3 getPerson 是一个处理函数，它返回由 id 路径变量标识的单个 person。如果找到，我们从存储库中检索该 Person 并创建 JSON 响应。如果未找到，我们返回 404 Not Found 响应。

验证

函数式端点可以使用 Spring 的 验证功能 对请求主体应用验证。例如，给定一个自定义的 Spring Validator 实现用于 Person：

Java
public class PersonHandler {

	private final Validator validator = new PersonValidator(); [id="CO5-1"][id="CO1-9"][id="CO3-7"](1)

	// ...

	public ServerResponse createPerson(ServerRequest request) {
		Person person = request.body(Person.class);
		validate(person); [id="CO5-2"][id="CO1-10"][id="CO3-8"](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()); [id="CO5-3"][id="CO1-11"][id="CO3-9"](3)
		}
	}
}
<1>  创建 `Validator` 实例。
<1>  应用验证。
<1>  针对 400 响应抛出异常。
Kotlin
class PersonHandler(private val repository: PersonRepository) {

	private val validator = PersonValidator() [id="CO6-1"][id="CO1-12"][id="CO4-1"](1)

	// ...

	fun createPerson(request: ServerRequest): ServerResponse {
		val person = request.body<Person>()
		validate(person) [id="CO6-2"][id="CO1-13"][id="CO4-2"](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()) [id="CO6-3"][id="CO1-14"][id="CO4-3"](3)
		}
	}
}
<1>  创建 `Validator` 实例。
<1>  应用验证。
<1>  针对 400 响应抛出异常。

处理程序还可以通过创建和注入基于 LocalValidatorFactoryBean 的全局 Validator 实例来使用标准 bean 验证 API (JSR-303)。 请参阅 Spring 验证。

RouterFunction

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

通常，建议使用 route() 构建器，因为它为典型的映射场景提供了方便的快捷方式，而无需难以发现的静态导入。 例如，路由器函数构建器提供了 GET(String, HandlerFunction) 方法来创建 GET 请求的映射；以及 POST(String, HandlerFunction) 用于 POST 请求。

除了基于 HTTP 方法的映射之外，路由构建器还提供了一种在映射请求时引入额外谓词的方法。 对于每个 HTTP 方法，都有一个重载变体，它将 RequestPredicate 作为参数，通过该参数可以表达额外的约束。

谓词

您可以编写自己的 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) — 两者都必须匹配。

  • RequestPredicate.or(RequestPredicate) — 任意一个都可以匹配。

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

路由

路由器函数按顺序评估：如果第一个路由不匹配，则评估第二个，依此类推。 因此，在通用路由之前声明更具体的路由是有意义的。 这在将路由器函数注册为 Spring bean 时也很重要，稍后将进行描述。 请注意，此行为与基于注解的编程模型不同，后者会自动选择“最具体”的控制器方法。

当使用路由器函数构建器时，所有定义的路由都被组合成一个 RouterFunction，并从 build() 返回。 还有其他方法可以将多个路由器函数组合在一起：

  • RouterFunctions.route() 构建器上的 add(RouterFunction)

  • RouterFunction.and(RouterFunction)

  • RouterFunction.andRoute(RequestPredicate, HandlerFunction) — RouterFunction.and() 与嵌套 RouterFunctions.route() 的快捷方式。

以下示例展示了四个路由的组合：

  • Java

  • Kotlin

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) [id="CO7-1"][id="CO1-15"][id="CO5-1"](1)
	.GET("/person", accept(APPLICATION_JSON), handler::listPeople) [id="CO7-2"][id="CO1-16"][id="CO5-2"](2)
	.POST("/person", handler::createPerson) [id="CO7-3"][id="CO1-17"][id="CO5-3"](3)
	.add(otherRoute) [id="CO7-4"][id="CO1-18"][id="CO5-4"](4)
	.build();
1 GET /person/{id} 且 Accept 头匹配 JSON 的请求被路由到 PersonHandler.getPerson
2 GET /person 且 Accept 头匹配 JSON 的请求被路由到 PersonHandler.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) [id="CO8-1"][id="CO1-19"][id="CO5-5"](1)
	GET("/person", accept(APPLICATION_JSON), handler::listPeople) [id="CO8-2"][id="CO1-20"][id="CO5-6"](2)
	POST("/person", handler::createPerson) [id="CO8-3"][id="CO1-21"][id="CO5-7"](3)
}.and(otherRoute) [id="CO8-4"][id="CO1-22"][id="CO5-8"](4)
1 GET /person/{id} 且 Accept 头匹配 JSON 的请求被路由到 PersonHandler.getPerson
2 GET /person 且 Accept 头匹配 JSON 的请求被路由到 PersonHandler.listPeople
3 POST /person 没有额外谓词的请求被映射到 PersonHandler.createPerson，并且
4 otherRoute 是在其他地方创建的路由器函数，并添加到构建的路由中。

嵌套路由

一组路由器函数通常具有共享谓词，例如共享路径。 在上面的示例中，共享谓词将是一个匹配 /person 的路径谓词，由三个路由使用。 当使用注解时，您将通过使用映射到 /person 的类型级别 @RequestMapping 注解来消除这种重复。 在 WebMvc.fn 中，路径谓词可以通过路由器函数构建器上的 path 方法共享。 例如，通过使用嵌套路由，上面示例的最后几行可以按以下方式改进：

Java
RouterFunction<ServerResponse> route = route()
	.path("/person", builder -> builder [id="CO9-1"][id="CO1-23"][id="CO5-9"](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 { [id="CO10-1"][id="CO1-24"][id="CO6-1"](1)
		GET("/{id}", accept(APPLICATION_JSON), handler::getPerson)
		GET(accept(APPLICATION_JSON), handler::listPeople)
		POST(handler::createPerson)
	}
}
<1>  使用 `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)
		}
	}
}

提供资源

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

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

重定向到资源

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

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

从根位置提供资源

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

  • Java

  • Kotlin

Resource location = new FileUrlResource("public-resources/");
RouterFunction<ServerResponse> resources = RouterFunctions.resources("/resources/**", location);
val location = FileUrlResource("public-resources/")
val resources = router { resources("/resources/**", location) }

运行服务器

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

  • RouterFunctionMapping: 检测 Spring 配置中的一个或多个 RouterFunction<?> bean， 对它们进行排序，通过 RouterFunction.andOther 组合它们，并将请求路由到生成的组合 RouterFunction。

  • HandlerFunctionAdapter: 简单的适配器，允许 DispatcherHandler 调用映射到请求的 HandlerFunction。

上述组件允许函数式端点适应 DispatcherServlet 请求处理生命周期，并且（如果声明了任何带注解的控制器）也可以与带注解的控制器并行运行。这也是 Spring Boot Web 启动器启用函数式端点的方式。

以下示例显示了一个 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...
	}
}

过滤处理函数

您可以使用路由函数构建器上的 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) [id="CO11-1"][id="CO1-25"][id="CO7-1"](1)
				.header("X-RequestHeader", "Value")
				.build()))
		.POST(handler::createPerson))
	.after((request, response) -> logResponse(response)) [id="CO11-2"][id="CO1-26"][id="CO7-2"](2)
	.build();
<1>  添加自定义请求头的 `before` 过滤器仅应用于两个 GET 路由。
<1>  记录响应的 `after` 过滤器应用于所有路由，包括嵌套路由。
Kotlin
import org.springframework.web.servlet.function.router

val route = router {
	"/person".nest {
		GET("/{id}", handler::getPerson)
		GET(handler::listPeople)
		before { [id="CO12-1"][id="CO1-27"][id="CO8-1"](1)
			ServerRequest.from(it)
					.header("X-RequestHeader", "Value").build()
		}
	}
	POST(handler::createPerson)
	after { _, response -> [id="CO12-2"][id="CO1-28"][id="CO8-2"](2)
		logResponse(response)
	}
}
<1>  添加自定义请求头的 `before` 过滤器仅应用于两个 GET 路由。
<1>  记录响应的 `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) 将过滤器应用于现有路由器函数。

对函数式端点的 CORS 支持通过专门的 CorsFilter 提供。