函数式端点

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

val string = request.awaitBody<String>()

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

val people = request.bodyToFlow<Person>()

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

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

val map = request.awaitFormData()

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

val map = request.awaitMultipartData()

request.bodyToFlux(PartEvent.class).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
			}
			return Mono.empty();
		}));

request.bodyToFlux<PartEvent>().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@switchOnFirst Mono.error(RuntimeException("Unexpected event: $event"))
				}
			} else {
				return@switchOnFirst partEvents // either complete or error signal
			}
			Mono.empty()
		}
	}

Mono<Pet> pet = request.bind(Pet.class, dataBinder -> dataBinder.setAllowedFields("name"));

val pet: Pet? = request.bindAndAwait<Pet>{ dataBinder -> dataBinder.setAllowedFields("name") }

Mono<Person> person = getPerson();
return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(person, Person.class);

val person: Person = getPerson()
return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).bodyValueWithTypeAndAwait<Person>(person)

URI location = ...
return ServerResponse.created(location).build();

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

return ServerResponse.ok().hint(JacksonCodecSupport.JSON_VIEW_HINT, MyJacksonView.class).body(...);

return ServerResponse.ok().hint(JacksonCodecSupport.JSON_VIEW_HINT, MyJacksonView::class.java).body(...)

public class PersonHandler {

	private final PersonRepository repository;

	public PersonHandler(PersonRepository repository) {
		this.repository = repository;
	}

	// listPeople is a handler function that returns all Person objects found
	// in the repository as JSON
	public Mono<ServerResponse> listPeople(ServerRequest request) {
		Flux<Person> people = repository.allPeople();
		return ok().contentType(APPLICATION_JSON).body(people, Person.class);
	}

	// createPerson is a handler function that stores a new Person contained
	// in the request body.
	// Note that PersonRepository.savePerson(Person) returns Mono<Void>: an empty
	// Mono that emits a completion signal when the person has been read from the
	// request and stored. So we use the build(Publisher<Void>) method to send a
	// response when that completion signal is received (that is, when the Person
	// has been saved)
	public Mono<ServerResponse> createPerson(ServerRequest request) {
		Mono<Person> person = request.bodyToMono(Person.class);
		return ok().build(repository.savePerson(person));
	}

	// getPerson is a handler function that returns a single person, identified by
	// the id path variable. We retrieve that Person from the repository and create
	// a JSON response, if it is found. If it is not found, we use switchIfEmpty(Mono<T>)
	// to return a 404 Not Found response.
	public Mono<ServerResponse> getPerson(ServerRequest request) {
		int personId = Integer.valueOf(request.pathVariable("id"));
		return repository.getPerson(personId)
			.flatMap(person -> ok().contentType(APPLICATION_JSON).bodyValue(person))
			.switchIfEmpty(ServerResponse.notFound().build());
	}
}

class PersonHandler(private val repository: PersonRepository) {

	// listPeople is a handler function that returns all Person objects found
	// in the repository as JSON
	suspend fun listPeople(request: ServerRequest): ServerResponse {
		val people: Flow<Person> = repository.allPeople()
		return ServerResponse.ok().contentType(APPLICATION_JSON).bodyAndAwait(people)
	}

	// createPerson is a handler function that stores a new Person contained
	// in the request body.
	// Note that PersonRepository.savePerson(Person) returns Mono<Void>: an empty
	// Mono that emits a completion signal when the person has been read from the
	// request and stored. So we use the build(Publisher<Void>) method to send a
	// response when that completion signal is received (that is, when the Person
	// has been saved)
	suspend fun createPerson(request: ServerRequest): ServerResponse {
		val person = request.awaitBody<Person>()
		repository.savePerson(person)
		return ServerResponse.ok().buildAndAwait()
	}

	// getPerson is a handler function that returns a single person, identified by
	// the id path variable. We retrieve that Person from the repository and create
	// a JSON response, if it is found. If it is not found, we use switchIfEmpty(Mono<T>)
	// to return a 404 Not Found response.
	suspend fun getPerson(request: ServerRequest): ServerResponse {
		val personId = request.pathVariable("id").toInt()
		return repository.getPerson(personId)?.let { ServerResponse.ok().contentType(APPLICATION_JSON).bodyValueAndAwait(it) }
				?: ServerResponse.notFound().buildAndAwait()

	}
}

public class PersonHandler {

	// Create Validator instance
	private final Validator validator = new PersonValidator();

	private final PersonRepository repository;

	public PersonHandler(PersonRepository repository) {
		this.repository = repository;
	}

	public Mono<ServerResponse> createPerson(ServerRequest request) {
		// Apply validation
		Mono<Person> person = request.bodyToMono(Person.class).doOnNext(this::validate);
		return ok().build(repository.savePerson(person));
	}

	private void validate(Person person) {
		Errors errors = new BeanPropertyBindingResult(person, "person");
		validator.validate(person, errors);
		if (errors.hasErrors()) {
			// Raise exception for a 400 response
			throw new ServerWebInputException(errors.toString());
		}
	}
}

class PersonHandler(private val repository: PersonRepository) {

	// Create Validator instance
	private val validator = PersonValidator()

	suspend fun createPerson(request: ServerRequest): ServerResponse {
		val person = request.awaitBody<Person>()
		// Apply validation
		validate(person)
		repository.savePerson(person)
		return ServerResponse.ok().buildAndAwait()
	}

	private fun validate(person: Person) {
		val errors: Errors = BeanPropertyBindingResult(person, "person")
		validator.validate(person, errors)
		if (errors.hasErrors()) {
			// Raise exception for a 400 response
			throw ServerWebInputException(errors.toString())
		}
	}
}

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(MediaType.TEXT_PLAIN)) {
		ServerResponse.ok().bodyValueAndAwait("Hello World")
	}
}

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

RouterFunction<ServerResponse> otherRoute = getOtherRoute();

RouterFunction<ServerResponse> route = route()
	// GET /person/{id} with an Accept header that matches JSON is routed to PersonHandler.getPerson
	.GET("/person/{id}", accept(APPLICATION_JSON), handler::getPerson)
	// GET /person with an Accept header that matches JSON is routed to PersonHandler.listPeople
	.GET("/person", accept(APPLICATION_JSON), handler::listPeople)
	// POST /person with no additional predicates is mapped to PersonHandler.createPerson
	.POST("/person", handler::createPerson)
	// otherRoute is a router function that is created elsewhere and added to the route built
	.add(otherRoute)
	.build();

val repository: PersonRepository = getPersonRepository()
val handler = PersonHandler(repository)

val otherRoute: RouterFunction<ServerResponse> = getOtherRoute()

val route = coRouter {
	// GET /person/{id} with an Accept header that matches JSON is routed to PersonHandler.getPerson
	GET("/person/{id}", accept(APPLICATION_JSON), handler::getPerson)
	// GET /person with an Accept header that matches JSON is routed to PersonHandler.listPeople
	GET("/person", accept(APPLICATION_JSON), handler::listPeople)
	// POST /person with no additional predicates is mapped to PersonHandler.createPerson
	POST("/person", handler::createPerson)
// otherRoute is a router function that is created elsewhere and added to the route built
}.and(otherRoute)

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();

val route = coRouter { (1)
	"/person".nest {
		GET("/{id}", accept(APPLICATION_JSON), handler::getPerson)
		GET(accept(APPLICATION_JSON), handler::listPeople)
		POST(handler::createPerson)
	}
}

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

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

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

ClassPathResource index = new ClassPathResource("static/index.html");
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)
}

Resource location = new FileUrlResource("public-resources/");
RouterFunction<ServerResponse> resources = RouterFunctions.resources("/resources/**", location);

val location = FileUrlResource("public-resources/")
val resources = router { resources("/resources/**", location) }