功能性端点
Spring WebFlux包括WebFlux.fn,这是一个轻量级的函数式编程模型,其中使用函数来路由和处理请求,并为不可变性设计了契约。它是注解驱动编程模型的替代方案,但在相同的响应式核心基础上运行。
概述
在WebFlux.fn中,使用HandlerFunction
处理HTTP请求:一个接受ServerRequest
并返回延迟的ServerResponse
(即Mono<ServerResponse>
)的函数。请求和响应对象都具有不可变的契约,为JDK 8友好地访问HTTP请求和响应。 HandlerFunction
相当于注解驱动编程模型中@RequestMapping
方法的主体。
传入请求通过RouterFunction
路由到处理函数:一个接受ServerRequest
并返回延迟的HandlerFunction
(即Mono<HandlerFunction>
)的函数。当路由函数匹配时,返回处理函数;否则返回一个空的Mono。 RouterFunction
相当于@RequestMapping
注解,但主要区别在于路由函数不仅提供数据,还提供行为。
RouterFunctions.route()
提供了一个路由构建器,方便创建路由器,如下例所示:
-
Java
-
Kotlin
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() (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() 创建路由器。 |
val repository: PersonRepository = ...
val handler = PersonHandler(repository)
val route = coRouter { (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配置运行,请参阅运行服务器。
处理函数
ServerRequest
和ServerResponse
是不可变接口,提供了对HTTP请求和响应的JDK 8友好访问。请求和响应都提供了对请求体流的Reactive Streams反压支持。请求体用Reactor的Flux
或Mono
表示。响应体用任何Reactive Streams的Publisher
表示,包括Flux
和Mono
。更多信息,请参见Reactive Libraries。
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();
// 处理表单字段
}
else if (event instanceof FilePartEvent fileEvent) {
String filename = fileEvent.filename();
Flux<DataBuffer> contents = partEvents.map(PartEvent::content);
// 处理文件上传
}
else {
return Mono.error(new RuntimeException("意外事件:" + event));
}
}
else {
return partEvents; // 完成或错误信号
}
}));
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();
// 处理表单字段
} else if (event is FilePartEvent) {
val filename: String = event.filename();
val contents: Flux<DataBuffer> = partEvents.map(PartEvent::content);
// 处理文件上传
} else {
return Mono.error(RuntimeException("意外事件:" + event));
}
} else {
return partEvents; // 完成或错误信号
}
}
}
}
请注意,PartEvent
对象的请求体内容必须完全消耗、传递或释放,以避免内存泄漏。
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) { (1)
Flux<Person> people = repository.allPeople();
return ok().contentType(APPLICATION_JSON).body(people, Person.class);
}
public Mono<ServerResponse> createPerson(ServerRequest request) { (2)
Mono<Person> person = request.bodyToMono(Person.class);
return ok().build(repository.savePerson(person));
}
public Mono<ServerResponse> getPerson(ServerRequest request) { (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 是一个处理程序函数,以JSON格式返回存储库中找到的所有Person 对象。 |
2 | createPerson 是一个处理程序函数,用于存储请求主体中包含的新Person 。请注意,PersonRepository.savePerson(Person) 返回Mono<Void> :一个空的Mono ,当从请求中读取并存储人员时发出完成信号。因此,我们使用build(Publisher<Void>) 方法在接收到该完成信号时发送响应(即,当Person 已保存时)。 |
3 | getPerson 是一个处理程序函数,返回由id 路径变量标识的单个人员。我们从存储库中检索该Person 并创建JSON响应(如果找到)。如果未找到,则使用switchIfEmpty(Mono<T>) 返回404未找到响应。 |
class PersonHandler(private val repository: PersonRepository) {
suspend fun listPeople(request: ServerRequest): ServerResponse { (1)
val people: Flow<Person> = repository.allPeople()
return ok().contentType(APPLICATION_JSON).bodyAndAwait(people);
}
suspend fun createPerson(request: ServerRequest): ServerResponse { (2)
val person = request.awaitBody<Person>()
repository.savePerson(person)
return ok().buildAndAwait()
}
suspend fun getPerson(request: ServerRequest): ServerResponse { (3)
val personId = request.pathVariable("id").toInt()
return repository.getPerson(personId)?.let { ok().contentType(APPLICATION_JSON).bodyValueAndAwait(it) }
?: ServerResponse.notFound().buildAndAwait()
}
}
1 | listPeople 是一个处理程序函数,以JSON格式返回存储库中找到的所有Person 对象。 |
2 | createPerson 是一个处理程序函数,用于存储请求主体中包含的新Person 。请注意,PersonRepository.savePerson(Person) 是一个没有返回类型的挂起函数。 |
3 | getPerson 是一个处理程序函数,返回由id 路径变量标识的单个人员。我们从存储库中检索该Person 并创建JSON响应(如果找到)。如果未找到,则返回404未找到响应。 |
验证
-
Java
-
Kotlin
public class PersonHandler {
private final Validator validator = new PersonValidator(); (1)
// ...
public Mono<ServerResponse> createPerson(ServerRequest request) {
Mono<Person> person = request.bodyToMono(Person.class).doOnNext(this::validate); (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()); (3)
}
}
}
1 | 创建Validator 实例。 |
2 | 应用验证。 |
3 | 为400响应引发异常。 |
class PersonHandler(private val repository: PersonRepository) {
private val validator = PersonValidator() (1)
// ...
suspend fun createPerson(request: ServerRequest): ServerResponse {
val person = request.awaitBody<Person>()
validate(person) (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()) (3)
}
}
}
1 | 创建Validator 实例。 |
2 | 应用验证。 |
3 | 为400响应引发异常。 |
处理程序还可以使用标准的bean验证API(JSR-303),通过创建和注入基于LocalValidatorFactoryBean
的全局Validator
实例。请参阅Spring验证。
路由函数
路由函数用于将请求路由到相应的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()
返回。还有其他将多个路由函数组合在一起的方法:
-
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.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) (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
val repository: PersonRepository = ...
val handler = PersonHandler(repository);
val otherRoute: RouterFunction<ServerResponse> = coRouter { }
val route = coRouter {
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
。在WebFlux.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 的第二个参数是一个接受路由构建器的消费者。 |
val route = coRouter { (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 = Arrays.asList("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 FileSystemResource("public-resources/");
RouterFunction<ServerResponse> resources = RouterFunctions.resources("/resources/**", location);
val location = FileSystemResource("public-resources/")
val resources = router { resources("/resources/**", location) }
运行服务器
如何在HTTP服务器中运行路由函数?一个简单的选项是通过以下方式之一将路由函数转换为HttpHandler
:
-
RouterFunctions.toHttpHandler(RouterFunction)
-
RouterFunctions.toHttpHandler(RouterFunction, HandlerStrategies)
然后,您可以使用返回的HttpHandler
与许多服务器适配器一起使用,按照HttpHandler中的服务器特定说明。
一个更典型的选项,也被Spring Boot使用,是通过DispatcherHandler
为基础的设置运行,通过WebFlux配置,使用Spring配置声明处理请求所需的组件。WebFlux Java配置声明以下基础设施组件来支持功能端点:
-
RouterFunctionMapping
:在Spring配置中检测一个或多个RouterFunction<?>
bean,对其进行排序,通过RouterFunction.andOther
组合它们,并将请求路由到生成的组合RouterFunction
。 -
HandlerFunctionAdapter
:简单的适配器,让DispatcherHandler
调用映射到请求的HandlerFunction
。 -
ServerResponseResultHandler
:通过调用ServerResponse
的writeTo
方法处理对HandlerFunction
的调用结果。
上述组件使功能端点适应DispatcherHandler
请求处理生命周期,并且(可能)与已声明的注释控制器并行运行。这也是Spring Boot WebFlux starter启用功能端点的方式。
以下示例显示了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
-
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 过滤器记录响应,适用于所有路由,包括嵌套路由。 |
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();
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 提供。 |