函式式端點

參見 Reactive 棧中的對應內容

Spring Web MVC 包含 WebMvc.fn，一個輕量級的功能性程式設計模型，其中函式用於路由和處理請求，並且契約設計為不可變。它是基於註解的程式設計模型的替代方案，但除此之外，它執行在相同的 DispatcherServlet 上。

概述

參見 Reactive 棧中的對應內容

在 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 支援。