函数式端点

Spring WebFlux 包含 WebFlux.fn，这是一个轻量级的函数式编程模型，其中函数用于路由和处理请求，并且契约被设计为不可变。它是基于注解的编程模型的替代方案，但运行在相同的 响应式核心 基础上。

概述

在 WebFlux.fn 中，HTTP 请求由 HandlerFunction 处理：一个接受 ServerRequest 并返回延迟 ServerResponse（即 Mono<ServerResponse>）的函数。请求和响应对象都具有不可变契约，提供对 HTTP 请求和响应的 JDK 8 友好访问。HandlerFunction 等同于基于注解的编程模型中 @RequestMapping 方法的主体。

传入请求通过 RouterFunction 路由到处理函数：一个接受 ServerRequest 并返回延迟 HandlerFunction（即 Mono<HandlerFunction>）的函数。当路由函数匹配时，返回一个处理函数；否则返回一个空的 Mono。RouterFunction 等同于 @RequestMapping 注解，但主要区别在于路由函数不仅提供数据，还提供行为。

RouterFunctions.route() 提供了一个路由构建器，便于创建路由，如以下示例所示：

Java
import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.web.reactive.function.server.RequestPredicates.*;
import static org.springframework.web.reactive.function.server.RouterFunctions.route;

PersonRepository repository = ...
PersonHandler handler = new PersonHandler(repository);

RouterFunction<ServerResponse> route = route() [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 Mono<ServerResponse> listPeople(ServerRequest request) {
		// ...
	}

	public Mono<ServerResponse> createPerson(ServerRequest request) {
		// ...
	}

	public Mono<ServerResponse> getPerson(ServerRequest request) {
		// ...
	}
}
<1>  使用 `route()` 创建路由。
Kotlin
val repository: PersonRepository = ...
val handler = PersonHandler(repository)

val route = coRouter { [id="CO2-1"][id="CO1-1"][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) {

	// ...

	suspend fun listPeople(request: ServerRequest): ServerResponse {
		// ...
	}

	suspend fun createPerson(request: ServerRequest): ServerResponse {
		// ...
	}

	suspend fun getPerson(request: ServerRequest): ServerResponse {
		// ...
	}
}
<1>  使用协程路由 DSL 创建路由；也可以通过 `router { }` 使用响应式替代方案。

运行 RouterFunction 的一种方法是将其转换为 HttpHandler 并通过其中一个内置的 服务器适配器 安装：

  • RouterFunctions.toHttpHandler(RouterFunction)

  • RouterFunctions.toHttpHandler(RouterFunction, HandlerStrategies)

大多数应用程序可以通过 WebFlux Java 配置运行，请参阅 运行服务器。

HandlerFunction

ServerRequest 和 ServerResponse 是不可变接口，提供对 HTTP 请求和响应的 JDK 8 友好访问。请求和响应都为正文流提供 Reactive Streams 背压。请求正文用 Reactor Flux 或 Mono 表示。响应正文用任何 Reactive Streams Publisher 表示，包括 Flux 和 Mono。有关更多信息，请参阅 响应式库。

ServerRequest

ServerRequest 提供对 HTTP 方法、URI、头和查询参数的访问，而对正文的访问通过 body 方法提供。

以下示例将请求正文提取到 Mono<String>：

  • Java

  • Kotlin

Mono<String> string = request.bodyToMono(String.class);
val string = request.awaitBody<String>()

以下示例将正文提取到 Flux<Person>（或 Kotlin 中的 Flow<Person>），其中 Person 对象从某种序列化形式（例如 JSON 或 XML）解码：

  • Java

  • Kotlin

Flux<Person> people = request.bodyToFlux(Person.class);
val people = request.bodyToFlow<Person>()

前面的示例是使用更通用的 ServerRequest.body(BodyExtractor) 的快捷方式，它接受 BodyExtractor 函数式策略接口。BodyExtractors 实用程序类提供了对多个实例的访问。例如，前面的示例也可以按如下方式编写：

  • Java

  • Kotlin

Mono<String> string = request.body(BodyExtractors.toMono(String.class));
Flux<Person> people = request.body(BodyExtractors.toFlux(Person.class));
	val string = request.body(BodyExtractors.toMono(String::class.java)).awaitSingle()
	val people = request.body(BodyExtractors.toFlux(Person::class.java)).asFlow()

以下示例展示了如何访问表单数据：

  • Java

  • Kotlin

Mono<MultiValueMap<String, String>> map = request.formData();
val map = request.awaitFormData()

以下示例展示了如何将多部分数据作为映射访问：

  • Java

  • Kotlin

Mono<MultiValueMap<String, Part>> map = request.multipartData();
val map = request.awaitMultipartData()

以下示例展示了如何以流式方式一次访问一个多部分数据：

  • Java

  • Kotlin

Flux<PartEvent> allPartEvents = request.bodyToFlux(PartEvent.class);
allPartsEvents.windowUntil(PartEvent::isLast)
      .concatMap(p -> p.switchOnFirst((signal, partEvents) -> {
          if (signal.hasValue()) {
              PartEvent event = signal.get();
              if (event instanceof FormPartEvent formEvent) {
                  String value = formEvent.value();
                  // handle form field
              }
              else if (event instanceof FilePartEvent fileEvent) {
                  String filename = fileEvent.filename();
                  Flux<DataBuffer> contents = partEvents.map(PartEvent::content);
                  // handle file upload
              }
              else {
                  return Mono.error(new RuntimeException("Unexpected event: " + event));
              }
          }
          else {
              return partEvents; // either complete or error signal
          }
      }));
val parts = request.bodyToFlux<PartEvent>()
allPartsEvents.windowUntil(PartEvent::isLast)
    .concatMap {
        it.switchOnFirst { signal, partEvents ->
            if (signal.hasValue()) {
                val event = signal.get()
                if (event is FormPartEvent) {
                    val value: String = event.value();
                    // handle form field
                } else if (event is FilePartEvent) {
                    val filename: String = event.filename();
                    val contents: Flux<DataBuffer> = partEvents.map(PartEvent::content);
                    // handle file upload
                } else {
                    return Mono.error(RuntimeException("Unexpected event: " + event));
                }
            } else {
                return partEvents; // either complete or error signal
            }
        }
    }
}

PartEvent 对象的正文内容必须完全消耗、中继或释放，以避免内存泄漏。

以下示例展示了如何绑定请求参数，包括可选的 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

Mono<Person> person = ...
ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(person, Person.class);
val person: Person = ...
ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).bodyValue(person)

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

  • Java

  • Kotlin

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

根据使用的编解码器，可以传递提示参数以自定义正文的序列化或反序列化方式。例如，要指定 Jackson JSON 视图：

  • Java

  • Kotlin

ServerResponse.ok().hint(Jackson2CodecSupport.JSON_VIEW_HINT, MyJacksonView.class).body(...);
ServerResponse.ok().hint(Jackson2CodecSupport.JSON_VIEW_HINT, MyJacksonView::class.java).body(...)

处理类

我们可以将处理函数编写为 lambda 表达式，如以下示例所示：

  • Java

  • Kotlin

HandlerFunction<ServerResponse> helloWorld =
  request -> ServerResponse.ok().bodyValue("Hello World");
val helloWorld = HandlerFunction<ServerResponse> { ServerResponse.ok().bodyValue("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 Mono<ServerResponse> listPeople(ServerRequest request) { [id="CO3-1"][id="CO1-2"][id="CO3-1"](1)
		Flux<Person> people = repository.allPeople();
		return ok().contentType(APPLICATION_JSON).body(people, Person.class);
	}

	public Mono<ServerResponse> createPerson(ServerRequest request) { [id="CO3-2"][id="CO1-3"][id="CO3-2"](2)
		Mono<Person> person = request.bodyToMono(Person.class);
		return ok().build(repository.savePerson(person));
	}

	public Mono<ServerResponse> getPerson(ServerRequest request) { [id="CO3-3"][id="CO1-4"][id="CO3-3"](3)
		int personId = Integer.valueOf(request.pathVariable("id"));
		return repository.getPerson(personId)
			.flatMap(person -> ok().contentType(APPLICATION_JSON).bodyValue(person))
			.switchIfEmpty(ServerResponse.notFound().build());
	}
}
1 listPeople 是一个处理函数，它将存储库中找到的所有 Person 对象作为 JSON 返回。
2 createPerson 是一个处理函数，它存储请求正文中包含的新 Person。请注意，PersonRepository.savePerson(Person) 返回 Mono<Void>：一个空的 Mono，当从请求中读取并存储人员时，它会发出完成信号。因此，我们使用 build(Publisher<Void>) 方法在收到完成信号时（即当 Person 已保存时）发送响应。
3 getPerson 是一个处理函数，它返回一个由 id 路径变量标识的单个人员。我们从存储库中检索该 Person，如果找到，则创建 JSON 响应。如果未找到，我们使用 switchIfEmpty(Mono<T>) 返回 404 Not Found 响应。 
class PersonHandler(private val repository: PersonRepository) {

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

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

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

	}
}
1 listPeople 是一个处理函数，它将存储库中找到的所有 Person 对象作为 JSON 返回。
2 createPerson 是一个处理函数，它存储请求正文中包含的新 Person。请注意，PersonRepository.savePerson(Person) 是一个没有返回类型的挂起函数。
3 getPerson 是一个处理函数，它返回一个由 id 路径变量标识的单个人员。我们从存储库中检索该 Person，如果找到，则创建 JSON 响应。如果未找到，我们返回 404 Not Found 响应。

验证

函数式端点可以使用 Spring 的 验证设施 对请求正文应用验证。例如，给定 Person 的自定义 Spring Validator 实现：

Java
public class PersonHandler {

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

	// ...

	public Mono<ServerResponse> createPerson(ServerRequest request) {
		Mono<Person> person = request.bodyToMono(Person.class).doOnNext(this::validate); [id="CO5-2"][id="CO1-9"][id="CO3-8"](2)
		return ok().build(repository.savePerson(person));
	}

	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-10"][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-11"][id="CO4-1"](1)

	// ...

	suspend fun createPerson(request: ServerRequest): ServerResponse {
		val person = request.awaitBody<Person>()
		validate(person) [id="CO6-2"][id="CO1-12"][id="CO4-2"](2)
		repository.savePerson(person)
		return ok().buildAndAwait()
	}

	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-13"][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().bodyValue("Hello World")).build();
val route = coRouter {
	GET("/hello-world", accept(TEXT_PLAIN)) {
		ServerResponse.ok().bodyValueAndAwait("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() 返回。还有其他方法可以将多个路由函数组合在一起：

  • 路由函数构建器上的 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.reactive.function.server.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-14"][id="CO5-1"](1)
	.GET("/person", accept(APPLICATION_JSON), handler::listPeople) [id="CO7-2"][id="CO1-15"][id="CO5-2"](2)
	.POST("/person", handler::createPerson) [id="CO7-3"][id="CO1-16"][id="CO5-3"](3)
	.add(otherRoute) [id="CO7-4"][id="CO1-17"][id="CO5-4"](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

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

val otherRoute: RouterFunction<ServerResponse> = coRouter {  }

val route = coRouter {
	GET("/person/{id}", accept(APPLICATION_JSON), handler::getPerson) [id="CO8-1"][id="CO1-18"][id="CO5-5"](1)
	GET("/person", accept(APPLICATION_JSON), handler::listPeople) [id="CO8-2"][id="CO1-19"][id="CO5-6"](2)
	POST("/person", handler::createPerson) [id="CO8-3"][id="CO1-20"][id="CO5-7"](3)
}.and(otherRoute) [id="CO8-4"][id="CO1-21"][id="CO5-8"](4)
1 GET /person/{id} 带有匹配 JSON 的 Accept 头被路由到 PersonHandler.getPerson
2 GET /person 带有匹配 JSON 的 Accept 头被路由到 PersonHandler.listPeople
3 POST /person 没有额外的谓词被映射到 PersonHandler.createPerson，并且
4 otherRoute 是一个在其他地方创建的路由函数，并添加到构建的路由中。

嵌套路由

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

Java
RouterFunction<ServerResponse> route = route()
	.path("/person", builder -> builder [id="CO9-1"][id="CO1-22"][id="CO5-9"](1)
		.GET("/{id}", accept(APPLICATION_JSON), handler::getPerson)
		.GET(accept(APPLICATION_JSON), handler::listPeople)
		.POST(handler::createPerson))
	.build();
<1>  请注意，`path` 的第二个参数是接受路由构建器的消费者。
Kotlin
val route = coRouter { [id="CO10-1"][id="CO1-23"][id="CO6-1"](1)
	"/person".nest {
		GET("/{id}", accept(APPLICATION_JSON), handler::getPerson)
		GET(accept(APPLICATION_JSON), handler::listPeople)
		POST(handler::createPerson)
	}
}
<1>  使用协程路由 DSL 创建路由；也可以通过 `router { }` 使用响应式替代方案。

尽管基于路径的嵌套是最常见的，但您可以使用构建器上的 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();
val route = coRouter {
	"/person".nest {
		accept(APPLICATION_JSON).nest {
			GET("/{id}", handler::getPerson)
			GET(handler::listPeople)
			POST(handler::createPerson)
		}
	}
}

提供资源

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

运行服务器

如何在 HTTP 服务器中运行路由函数？一个简单的选项是使用以下方法之一将路由函数转换为 HttpHandler：

  • RouterFunctions.toHttpHandler(RouterFunction)

  • RouterFunctions.toHttpHandler(RouterFunction, HandlerStrategies)

然后，您可以按照 HttpHandler 中的服务器特定说明，将返回的 HttpHandler 与多个服务器适配器一起使用。

一个更典型的选项（Spring Boot 也使用）是通过 WebFlux 配置 运行基于 DispatcherHandler 的设置，该配置使用 Spring 配置来声明处理请求所需的组件。WebFlux Java 配置声明了以下基础设施组件以支持函数式端点：

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

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

  • ServerResponseResultHandler: 通过调用 ServerResponse 的 writeTo 方法处理 HandlerFunction 调用结果。

前面的组件允许函数式端点适应 DispatcherHandler 请求处理生命周期，并且（可能）与任何声明的注解控制器并行运行。这也是 Spring Boot WebFlux 启动器启用函数式端点的方式。

以下示例显示了 WebFlux Java 配置（有关如何运行它，请参阅 DispatcherHandler）：

  • Java

  • Kotlin

@Configuration
@EnableWebFlux
public class WebConfig implements WebFluxConfigurer {

	@Bean
	public RouterFunction<?> routerFunctionA() {
		// ...
	}

	@Bean
	public RouterFunction<?> routerFunctionB() {
		// ...
	}

	// ...

	@Override
	public void configureHttpMessageCodecs(ServerCodecConfigurer configurer) {
		// configure message conversion...
	}

	@Override
	public void addCorsMappings(CorsRegistry registry) {
		// configure CORS...
	}

	@Override
	public void configureViewResolvers(ViewResolverRegistry registry) {
		// configure view resolution for HTML rendering...
	}
}
@Configuration
@EnableWebFlux
class WebConfig : WebFluxConfigurer {

	@Bean
	fun routerFunctionA(): RouterFunction<*> {
		// ...
	}

	@Bean
	fun routerFunctionB(): RouterFunction<*> {
		// ...
	}

	// ...

	override fun configureHttpMessageCodecs(configurer: ServerCodecConfigurer) {
		// 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-24"][id="CO7-1"](1)
				.header("X-RequestHeader", "Value")
				.build()))
		.POST(handler::createPerson))
	.after((request, response) -> logResponse(response)) [id="CO11-2"][id="CO1-25"][id="CO7-2"](2)
	.build();
<1>  添加自定义请求头的 `before` 过滤器仅应用于两个 GET 路由。
<1>  记录响应的 `after` 过滤器应用于所有路由，包括嵌套路由。
Kotlin
val route = router {
	"/person".nest {
		GET("/{id}", handler::getPerson)
		GET("", handler::listPeople)
		before { [id="CO12-1"][id="CO1-26"][id="CO8-1"](1)
			ServerRequest.from(it)
					.header("X-RequestHeader", "Value").build()
		}
		POST(handler::createPerson)
		after { _, response -> [id="CO12-2"][id="CO1-27"][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();
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 支持通过专门的 CorsWebFilter 提供。