功能性端點

Spring Web MVC 包含 WebMvc.fn，這是一種輕量級功能性程式設計模型，其中函數用於路由和處理請求，而協定則為不可變性而設計。它是基於註解的程式設計模型的替代方案，但在相同的 DispatcherServlet 上執行。

概觀

請參閱 Reactive 堆疊中的等效項

在 WebMvc.fn 中，HTTP 請求由 HandlerFunction 處理：這是一個接受 ServerRequest 並回傳 ServerResponse 的函數。請求和回應物件都具有不可變的協定，可提供 JDK 8 友善的方式來存取 HTTP 請求和回應。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 是不可變的介面，可提供 JDK 8 友善的方式來存取 HTTP 請求和回應，包括標頭、Body、方法和狀態碼。

ServerRequest

ServerRequest 提供對 HTTP 方法、URI、標頭和查詢參數的存取，而對 Body 的存取則透過 body 方法提供。

以下範例將請求 Body 提取為 String

  • Java

  • Kotlin

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

以下範例將 Body 提取為 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 方法來建立它。您可以使用建構器設定回應狀態、新增回應標頭或提供 Body。以下範例建立一個包含 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 標頭且沒有 Body 的 201 (CREATED) 回應

  • Java

  • Kotlin

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

您也可以使用非同步結果作為 Body，以 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)

如果不僅 Body，而且狀態或標頭也基於非同步類型，則您可以使用 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 是一個處理器函數，它以 JSON 形式回傳在儲存庫中找到的所有 Person 物件。
2 createPerson 是一個處理器函數，它儲存請求 Body 中包含的新 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 是一個處理器函數，它以 JSON 形式回傳在儲存庫中找到的所有 Person 物件。
2 createPerson 是一個處理器函數，它儲存請求 Body 中包含的新 Person。
3 getPerson 是一個處理器函數，它回傳單個人員，由 id 路徑變數識別。如果找到該 Person，我們會從儲存庫中檢索它並建立 JSON 回應。如果未找到，我們會回傳 404 Not Found 回應。

驗證

功能性端點可以使用 Spring 的 驗證工具 將驗證應用於請求 Body。例如，給定一個用於 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 方法、內容類型等等。以下範例使用請求述詞來建立基於 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 中，該 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) (1)
	.GET("/person", accept(APPLICATION_JSON), handler::listPeople) (2)
	.POST("/person", handler::createPerson) (3)
	.add(otherRoute) (4)
	.build();
1 GET /person/{id} 與匹配 JSON 的 Accept 標頭路由到 PersonHandler.getPerson
2 GET /person 與匹配 JSON 的 Accept 標頭路由到 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 GET /person/{id} 與匹配 JSON 的 Accept 標頭路由到 PersonHandler.getPerson
2 GET /person 與匹配 JSON 的 Accept 標頭路由到 PersonHandler.listPeople
3 POST /person 沒有其他述詞映射到 PersonHandler.createPerson，以及
4 otherRoute 是一個在其他地方建立的路由器函數，並新增到已建立的路由中。

巢狀路由

一組路由器函數通常具有共用述詞，例如共用路徑。在上面的範例中，共用述詞將是與 /person 匹配的路徑述詞，由三個路由使用。當使用註解時，您可以使用類型級別的 @RequestMapping 註解來映射到 /person，從而消除此重複。在 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)
		}
	}
}

提供資源

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

執行伺服器

請參閱 Reactive 堆疊中的等效項

您通常透過 MVC 配置 在基於 DispatcherHandler 的設定中執行路由器函數，該配置使用 Spring 配置來宣告處理請求所需的組件。MVC Java 配置宣告了以下基礎架構組件以支援功能性端點

  • RouterFunctionMapping：偵測 Spring 配置中的一個或多個 RouterFunction<?> Bean，對它們進行排序，透過 RouterFunction.andOther 將它們組合起來，並將請求路由到產生的組合 RouterFunction。

  • HandlerFunctionAdapter：簡單的適配器，讓 DispatcherHandler 調用映射到請求的 HandlerFunction。

先前的組件讓功能性端點適合 DispatcherServlet 請求處理生命週期，並且（可能）與宣告的任何註解控制器並排執行。這也是 Spring Boot Web Starter 如何啟用功能性端點的方式。

以下範例顯示了 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...
	}
}

篩選處理器函數

請參閱 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) 將篩選器應用於現有的路由器函數。

功能性端點的 CORS 支援透過專用的 CorsFilter 提供。