函数式端点

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
Kotlin

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 创建路由。

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

HandlerFunction

参见 Reactive 栈中的对应内容

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) { (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` 是一个处理函数，它将存储库中找到的所有 `Person` 对象作为 JSON 返回。
2	`createPerson` 是一个处理函数，它存储请求主体中包含的新 `Person`。
3	`getPerson` 是一个处理函数，它返回由 `id` 路径变量标识的单个人员。如果找到该 `Person`，我们从存储库中检索并创建 JSON 响应。如果未找到，我们返回 404 Not Found 响应。

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

验证

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

Java
Kotlin

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 响应抛出异常。

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

`RouterFunction`

参见 Reactive 栈中的对应内容

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

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

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

谓词

您可以编写自己的 RequestPredicate，但 RequestPredicates 工具类提供了基于 HTTP 方法、请求路径、头、API 版本等常见匹配需求的内置选项。

以下示例使用 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 时也很重要，稍后将对此进行描述。请注意，此行为与基于注解的编程模型不同，后者会自动选择“最具体”的控制器方法。

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

RouterFunctions.route() 构建器上的 add(RouterFunction)
RouterFunction.and(RouterFunction)
RouterFunction.andRoute(RequestPredicate, HandlerFunction) — 带有嵌套 RouterFunctions.route() 的 RouterFunction.and() 的快捷方式。

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

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) (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` 是在其他地方创建并添加到构建路由的路由函数。

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	带有匹配 JSON 的 `Accept` 头的 `GET /person/{id}` 路由到 `PersonHandler.getPerson`
2	带有匹配 JSON 的 `Accept` 头的 `GET /person` 路由到 `PersonHandler.listPeople`
3	没有附加谓词的 `POST /person` 映射到 `PersonHandler.createPerson`，以及
4	`otherRoute` 是在其他地方创建并添加到构建路由的路由函数。

嵌套路由

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

Java
Kotlin

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	使用 `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)
		}
	}
}

API 版本

路由函数支持按 API 版本匹配。

首先，在 MVC 配置中启用 API 版本控制，然后您可以按如下方式使用 version 谓词：

Java
Kotlin

RouterFunction<ServerResponse> route = RouterFunctions.route()
	.GET("/hello-world", version("1.2"),
		request -> ServerResponse.ok().body("Hello World")).build();

val route = router {
	GET("/hello-world", version("1.2")) {
		ServerResponse.ok().body("Hello World")
	}
}

version 谓词可以是：

固定版本（"1.2"）——仅匹配给定版本
基线版本（"1.2+"）——匹配给定版本及以上，直至最高支持的版本。

有关底层基础设施和 API 版本控制支持的更多详细信息，请参阅 API 版本控制。

提供资源

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")).negate();
RouterFunction<ServerResponse> redirectToIndex = route()
	.resource(spaPredicate, index)
	.build();

val redirectToIndex = router {
	val index = ClassPathResource("static/index.html")
	val spaPredicate = !(path("/api/**") or path("/error"))
	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) }

运行服务器

参见 Reactive 栈中的对应内容

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

RouterFunctionMapping：在 Spring 配置中检测一个或多个 RouterFunction<?> bean，对它们进行排序，通过 RouterFunction.andOther 将它们组合，并将请求路由到生成的组合 RouterFunction。
HandlerFunctionAdapter：简单的适配器，允许 DispatcherHandler 调用映射到请求的 HandlerFunction。

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

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

过滤处理函数

参见 Reactive 栈中的对应内容

您可以使用路由函数构建器上的 before、after 或 filter 方法过滤处理函数。使用注解，您可以通过使用 @ControllerAdvice、ServletFilter 或两者来实现类似的功能。过滤器将应用于构建器构建的所有路由。这意味着嵌套路由中定义的过滤器不适用于“顶级”路由。例如，请看以下示例：

Java
Kotlin

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` 过滤器应用于所有路由，包括嵌套路由。

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	添加自定义请求头的 `before` 过滤器仅应用于两个 GET 路由。
2	记录响应的 `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 支持。