Controladores anotados

Primavera WebFlux proporciona un modelo de programación basado en anotaciones, donde los componentes @Controller y @RestController usan anotaciones para expresar asignaciones de consultas, entrada de consultas, manejo de excepciones y más. Los controladores anotados tienen firmas de métodos flexibles y no necesariamente necesitan extender clases base o implementar interfaces específicas.

La siguiente lista muestra un ejemplo básico:

@RestController
public classHelloController {
@GetMapping("/hello") 
public String handle (){
return "Hello WebFlux";
}
}

@RestController
class HelloController {
@GetMapping("/hello")
fun handle() = "Hello WebFlux"
}

En el ejemplo anterior, el método devuelve una String a escriba en la respuesta.

@Controller

Puede definir beans controladores utilizando la definición estándar de Spring Bean. El estereotipo @Controller permite el descubrimiento automático y es consistente con el soporte general de Spring para descubrir clases con la anotación @Component en el classpath y registrar automáticamente definiciones de beans para ellas. También actúa como un estereotipo para la clase anotada, indicando su función como componente web.

Para habilitar la detección automática de dichos beans con la anotación @Controller, puede agregar el componente escaneo a la configuración Java, como se muestra en el siguiente ejemplo:

@Configuration
@ComponentScan("org.example.web") 
public class WebConfig {
// ...
}

@Configuration
 @ComponentScan("org.example.web") 
class WebConfig {
// ...
}

@RestController es una anotación compuesta que a su vez está metaanotada con las anotaciones @Controller y @ResponseBody, lo que indica un controlador cuyo cada método hereda @ResponseBody anotación a nivel de tipo y, por lo tanto, escribe directamente en el cuerpo de la respuesta en lugar de reconocer la representación y renderizar usando una plantilla HTML.

Solicitar mapeo

El La anotación @RequestMapping se utiliza para asignar solicitudes a métodos de controlador. Tiene varios atributos para hacer coincidir por URL, método HTTP, parámetros de solicitud, encabezados y tipos de medios. Puede usarlo a nivel de clase para expresar asignaciones generales o a nivel de método para limitarlo a una asignación de punto final específica.

También hay opciones específicas del método HTTP para acortar el anotación @RequestMapping:

• @GetMapping

• @PostMapping

• @PutMapping

• @DeleteMapping

• @PatchMapping

Las anotaciones anteriores son anotaciones personalizadas que se especifican porque la mayoría de los métodos del controlador Es probable que deba asignarse a un método HTTP en lugar de utilizar la anotación @RequestMapping, que está asignada a todos los métodos HTTP de forma predeterminada. Sin embargo, la anotación @RequestMapping todavía es necesaria a nivel de clase para expresar asignaciones generales.

El siguiente ejemplo utiliza asignaciones a nivel de tipo y método:

@RestController
@RequestMapping("/persons") 
class PersonController {
@GetMapping("/{id}")
public Person getPerson(@PathVariable Long id)  {
// ...
}
@PostMapping
@ResponseStatus( HttpStatus.CREATED) 
public void add(@RequestBody Person person) {
// ...
}
}

@RestController
@RequestMapping("/persons")
class PersonController {
@GetMapping("/{id}") 
fun getPerson(@PathVariable id: Long): Person {
// ...
}
@PostMapping
@ResponseStatus(HttpStatus.CREATED)
fun add(@RequestBody person: Person) {
 // ...
}
}

Plantillas URI

Puede mostrar consultas utilizando máscaras estándar (también conocidas como patrón de búsqueda (patrones globales ) y comodines:

Se puede acceder a las variables URI capturadas mediante una anotación @PathVariable, como se muestra en el siguiente ejemplo:

@GetMapping("/owners/{ownerId}/pets/{petId}")
public Pet findPet(@PathVariable Long ownerId, @PathVariable Long petId) {
// ...
}

@GetMapping("/owners/{ownerId}/pets/{petId}") 
fun findPet(@PathVariable ownerId: Long , @PathVariable petId: Long): Pet {
// ... 

Puede declarar variables URI a nivel de clase y método, como se muestra en la siguiente ejemplo:

@Controller
@RequestMapping("/owners/{ownerId}") 
public class OwnerController {
@GetMapping("/pets/{petId}")  
public Pet findPet(@PathVariable Long ownerId, @PathVariable Long petId) {
 // ...
}
}

@Controller 
@RequestMapping("/owners/{ownerId}") 
class OwnerController {
@GetMapping("/pets/{petId}")   
fun findPet(@PathVariable ownerId: Long, @PathVariable petId: Long): Pet {
// ...
}
}

Las variables URI se convierten al tipo apropiado; de lo contrario, se Se produce un error TypeMismatchException . Los tipos simples (int, long, Date, etc.) son compatibles de forma predeterminada, pero puede registrar la compatibilidad con cualquier otro tipo de datos.

Puede nombrar explícitamente variables URI (por ejemplo, @PathVariable("customId")), pero también puede omitir esta información si los nombres son los mismos y su código se compila. usando información de depuración o con el indicador del compilador -parameters en Java 8.

La sintaxis {*varName} declara una variable URI que coincide con cero o más segmentos restantes formas. Por ejemplo, /resources/{*path} coincide con todos los archivos en el directorio /resources/ y la variable "path" refleja la información completa. ruta en /resources.

Sintaxis {varName:regex} declara una variable URI con una expresión regular, que tiene la sintaxis: {varName:regex}. Por ejemplo, dada la URL /spring-web-3.0.5.jar, el siguiente método recupera el nombre del archivo, la versión y la extensión:

@GetMapping("/{name:[a-z-]+}-{version:\\d\\.\\d\\.\\d}{ext:\ \.[a-z]+}") 
public void handle(@PathVariable String version, @PathVariable String ext) {
// ...
} 

@GetMapping("/{name:[a-z-]+}-{version:\\d\\.\\d\\.\\d}{ext:\\.[a-z]+}") 
fun handle(@PathVariable version: String, @PathVariable ext: String) {
// ... }

Los patrones de ruta de URI también pueden contener marcadores de posición en línea ${...}, que son reconocido cuando se ejecuta con PropertySourcesPlaceholderConfigurer en local, fuentes de propiedades del sistema, fuentes de propiedades del entorno, etc. Puede usar esto, por ejemplo, para parametrizar una URL base basada en alguna configuración externa.

Spring WebFlux no admite la asignación de sufijos a una imagen, a diferencia de Spring MVC, donde una asignación como /person también coincide con /person.*. Para negociar contenido basado en una URL, si es necesario, recomendamos utilizar un parámetro de consulta que sea más simple, más explícito y menos vulnerable a exploits basados en rutas URL.

Comparación de patrones

Si varios patrones coinciden con una URL, se deben comparar para encontrar la mejor coincidencia. Esto se hace usando PathPattern.SPECIFICITY_COMPARATOR, que busca patrones que son más específicos.

Para cada patrón, se calcula una puntuación en función del número de identificadores URI y variables comodín. Donde la variable URI puntúa por debajo del comodín. Gana la muestra con la puntuación total más baja. Si dos muestras tienen las mismas puntuaciones, se selecciona la más larga.

Muestras generales (por ejemplo, **, {*varName}) se excluyen del recuento y siempre se ordenan en último lugar. Si dos muestras son generales, se elige la más larga.

Tipos de medios consumidos

Puede limitar la visualización de la consulta según el Content-Type de la consulta, como se muestra en el siguiente ejemplo:

@PostMapping(path = "/pets", consumes = "application /json") 
public void addPet(@RequestBody Pet pet) {
// ...
}

@PostMapping("/pets", consumes = ["application/json"])
fun addPet(@RequestBody pet: Pet) {
// ...
}

El atributo "consume" también admite expresiones de negación; por ejemplo, !text/plain significa cualquier tipo de contenido que no sea text/plain.

Puedes declarar un atributo genérico consume a nivel de clase. Sin embargo, a diferencia de la mayoría de los otros atributos de mapeo de solicitudes, cuando se usa a nivel de clase, el atributo consume a nivel de método anula en lugar de extender la declaración a nivel de clase.

Tipos de medios producidos

Puede limitar el rango de solicitudes que se muestran según el encabezado de solicitud Aceptar y la lista de tipos de contenido que produce el método del controlador. , como se muestra en el siguiente ejemplo:

@GetMapping(path = "/pets/{petId}", produces = "application/json" )
@ResponseBody
public Pet getPet(@PathVariable String petId)  {
// ...
}

@GetMapping("/pets/{petId}", produces = ["application/json"])
@ResponseBody
fun getPet(@PathVariable String petId): Pet {
// ...
}

El tipo de medio puede determinar el juego de caracteres. Se admiten expresiones negables; por ejemplo, !text/plain significa cualquier tipo de contenido que no sea text/plain.

Puedes declarar un genérico produces el atributo a nivel de clase. Sin embargo, a diferencia de la mayoría de los otros atributos de mapeo de solicitudes, cuando se usa a nivel de clase, el atributo produce a nivel de método anula en lugar de extender la declaración a nivel de clase.

Parámetros y encabezados

Puede limitar la visualización de consultas según las condiciones de los parámetros de consulta. Puede verificar la presencia de un parámetro de consulta myParam, su ausencia (!myParam) o la presencia de un valor específico (myParam=myValue). Los siguientes ejemplos comprueban la presencia de un parámetro con un valor:

@GetMapping(path = "/pets/{petId}", params = "myParam=myValue") 
public void findPet (@PathVariable String petId) {
// ...
}

@GetMapping("/pets/{petId}", params = ["myParam=myValue"])  
fun findPet(@PathVariable petId: String) {
// ...
}

Lo mismo se puede utilizar con condiciones de encabezado de solicitud, como se muestra en el siguiente ejemplo:

@GetMapping(path = "/pets", headers = "myHeader=myValue")  
public  void findPet(@PathVariable String petId) {
// ...
}

@GetMapping("/pets", headers = ["myHeader=myValue"]) 
fun findPet(@PathVariable petId: String) {
// ... }

Métodos HTTP HEAD, OPTIONS

@GetMapping (y @RequestMapping(method=HttpMethod.GET)) admiten de forma transparente el método HTTP HEAD para solicitudes de mapeo. No es necesario cambiar los métodos del controlador. La función contenedora de respuesta utilizada en HttpHandler garantiza que el encabezado Content-Length se establezca en el número de bytes escritos (sin escribir realmente en la respuesta).

Predeterminado El método OPCIONES HTTP se maneja configurando el encabezado de respuesta Allow en la lista de métodos HTTP enumerados en todos los métodos marcados con la anotación @RequestMapping.

En el caso de la anotación @RequestMapping sin declarar métodos HTTP, el encabezado Allow se establece en GET, HEAD, POST, PUT, PATCH, DELETE , OPCIONES. Los métodos del controlador siempre deben declarar métodos HTTP admitidos (por ejemplo, utilizando variantes específicas del método HTTP: @GetMapping, @PostMapping y otros).

Puede asignar explícitamente un método anotado con @RequestMapping al método HEAD HTTP y al método OPTIONS HTTP, pero en casos normales esto no es necesario.

Anotaciones personalizadas

Spring WebFlux admite el uso de anotaciones compuestas para mostrar consultas. Estas son anotaciones que son en sí mismas metanotaciones @RequestMapping y están compuestas para volver a declarar un subconjunto (o todos) de los atributos marcados con la anotación @RequestMapping para un alcance más limitado. , propósito más específico.

@GetMapping, @PostMapping, @PutMapping, @DeleteMapping y @PatchMapping son ejemplos de anotaciones compuestas. Se proporcionan porque es probable que la mayoría de los métodos del controlador deban asignarse a un método HTTP específico en lugar de utilizar la anotación @RequestMapping, que se asigna a todos los métodos HTTP de forma predeterminada. Si necesita un ejemplo de anotaciones compuestas, observe cómo se declaran.

Spring WebFlux también admite atributos de visualización de consultas personalizados con lógica de visualización de consultas personalizada. Esta es una opción más avanzada que requiere subclasificar RequestMappingHandlerMapping y anular el método getCustomMethodCondition en el que puede verificar el atributo personalizado y devolver su propia RequestCondition.

Registro explícito

Puede registrar mediante programación métodos de controlador, que se pueden usar para registro dinámico o en casos más complejos, como si hay diferentes instancias del mismo controlador en diferentes URL. El siguiente ejemplo muestra cómo hacer esto:

@Configuration
public class MyConfig {
@Autowired
public void setHandlerMapping(RequestMappingHandlerMapping mapping, UserHandler handler) (1)
    throws NoSuchMethodException {
RequestMappingInfo info = RequestMappingInfo
        .paths("/user/{id}").methods(RequestMethod.GET).build(); 
Method method = UserHandler.class.getMethod("getUser", Long.class); 
mapping.registerMapping(info, handler, method); 
}
}

@Configuration
class MyConfig {
@Autowired
fun setHandlerMapping(mapping: RequestMappingHandlerMapping, handler: UserHandler) { 
val info = RequestMappingInfo.paths("/user/{id}").methods(RequestMethod.GET).build() 
val method = UserHandler::class.java.getMethod("getUser", Long::class.java) 
mapping.registerMapping(info, handler, method) 
}
}

Métodos de controlador

Métodos de controlador con @RequestMapping La anotación tiene una firma flexible y se puede elegir entre varios argumentos de métodos de controlador admitidos y valores de retorno.

Argumentos de método

La siguiente tabla enumera los argumentos de métodos de controlador admitidos.

Los tipos reactivos (Reactor, RxJava u otros) se admiten en argumentos que requieren bloquear E/S para resolverse (por ejemplo, leer el cuerpo de la solicitud). Esto se indica en la columna "Descripción". No se esperan tipos reactivos para argumentos que no requieren bloqueo.

El argumento java.util.Optional de JDK 1.8 se admite como argumento de método en combinación con anotaciones que tienen un atributo required (por ejemplo, @RequestParam, @RequestHeader y otros), y es equivalente a required=false .

Valores devueltos

La siguiente tabla enumera los retornos admitidos. valores de un método controlador. Tenga en cuenta que los tipos reactivos de bibliotecas como Reactor, RxJava u otras generalmente son compatibles con todos los valores de retorno.

Conversión de tipo

Algunos argumentos de métodos de controlador anotados que representan entradas de solicitud basadas en cadenas (como @RequestParam, @RequestHeader, @PathVariable, @MatrixVariable y @CookieValue)) pueden requerir una conversión de tipo si el argumento no se declara como String.

En tales casos, la conversión de tipos se aplica automáticamente en función de los convertidores configurados. De forma predeterminada, se admiten tipos simples (como int, long, Date y otros). La conversión de tipos se puede configurar usando WebDataBinder o registrando Formatters con FormattingConversionService.

Un problema práctico con la conversión de tipos es el manejo valor de cadena original vacío. Dicho valor se considera faltante si se vuelve null como resultado de una conversión de tipo. Esto puede ser cierto para Long, UUID y otros tipos de destino. Si necesita permitir la inyección null, utilice el indicador required en la anotación del argumento o declare el argumento como @Nullable.

Variables de matriz

En RFC 3986 Los pares "nombre" se describen -valor" en segmentos de ruta. En Spring WebFlux las llamamos "variables de matriz", según la "publicación anterior" de Tim Berners -Lee, pero también pueden denominarse parámetros de ruta URI.

Las variables de matriz pueden aparecer en cualquier segmento de ruta, con cada variable separada por un punto y coma y varios valores separados por comas, por ejemplo, "/cars;color=red,green;year=2012". También se pueden especificar múltiples valores a través de nombres de variables repetidos, por ejemplo, color=red;color=green;color= azul) .

A diferencia de Spring MVC, en WebFlux la presencia o ausencia de variables matriciales en la URL no afecta la representación de las solicitudes. En otras palabras, no es necesario utilizar una variable URI para enmascarar el contenido de la variable. Sin embargo, si necesita acceder a variables matriciales desde un método de controlador, debe agregar una variable URI al segmento de ruta donde se esperan variables matriciales. El siguiente ejemplo muestra cómo hacer esto:

// GET /pets/42;q=11;r=22
@GetMapping("/pets/{petId}")
public void findPet(@PathVariable String petId, @MatrixVariable int q) {
// petId == 42
// q == 11
}

 // GET /pets/42;q=11;r=22
@GetMapping("/pets/{petId}")
fun findPet(@PathVariable petId: String, @MatrixVariable q: Int) {
// petId == 42
// q == 11
}

Considerando que todos los segmentos de ruta pueden contener variables matriciales , a veces es posible que necesite definir en qué variable de ruta debe estar la variable de matriz, como se muestra en el siguiente ejemplo:

// GET /owners/42;q=11/pets/21;q=22
@GetMapping("/owners/{ownerId}/pets/{petId}")
public void findPet(
@MatrixVariable(name="q", pathVar="ownerId") int q1,
@MatrixVariable(name="q", pathVar="petId") int q2) {
// q1 == 11
// q2 == 22
}

@GetMapping("/owners/{ownerId}/pets/{petId}")
fun findPet(
@MatrixVariable(name = "q", pathVar = "ownerId") q1: Int,
@MatrixVariable(name = "q", pathVar = "petId") q2: Int) {
// q1 == 11
// q2 == 22
}

Puede definir una variable de matriz como opcional y proporcionar un valor predeterminado, como se muestra en el siguiente ejemplo:

// GET /pets/42
@GetMapping("/pets/{petId}")
public void findPet(@MatrixVariable(required=false, defaultValue="1") int q) {
// q == 1
}

// GET /pets/42
@GetMapping("/pets/{petId}")
fun findPet(@MatrixVariable(required = false, defaultValue = "1") q: Int) {
// q == 1
}

Para obtener todas las variables de una matriz, use MultiValueMap como se muestra en el siguiente ejemplo:

// GET /owners/42;q=11;r=12/pets/21;q=22;s=23
@GetMapping("/owners/{ownerId}/pets/{petId}")
public void findPet(
@MatrixVariable MultiValueMap<String, String> matrixVars,
@MatrixVariable(pathVar="petId") MultiValueMap<String, String> petMatrixVars) {
// matrixVars: ["q" : [11,22], "r" : 12, "s" : 23]
// petMatrixVars: ["q" : 22, "s" : 23]
}

// GET /owners/42;q=11;r=12/pets/21;q=22;s=23
@GetMapping("/owners/{ownerId}/pets/{petId}")
fun findPet(
@MatrixVariable matrixVars: MultiValueMap<String, String>,
@MatrixVariable(pathVar="petId") petMatrixVars: MultiValueMap<String, String>) {
// matrixVars: ["q" : [11,22], "r" : 12, "s" : 23]
// petMatrixVars: ["q" : 22, "s" : 23]
}

@RequestParam

Puede utilizar la anotación @RequestParam para vincular los parámetros de solicitud a un argumento de método en el controlador. El siguiente fragmento de código demuestra el uso:

@Controller
@RequestMapping("/pets")
public class EditPetForm {
// ...
@GetMapping
public String setupForm(@RequestParam("petId") int petId, Model model) { 
Pet pet = this.clinic.loadPet(petId);
model.addAttribute("pet", pet);
return "petForm";
}
// ...
}

import org.springframework.ui.set
@Controller
@RequestMapping("/pets")
class EditPetForm {
// ...
@GetMapping
fun setupForm(@RequestParam("petId") petId: Int, model: Model): String { 
val pet = clinic.loadPet(petId)
model["pet"] = pet
return "petForm"
}
// ...
}

Parámetros del método que utilizan la anotación @RequestParam es obligatoria de forma predeterminada, pero también puede configurar un parámetro de método para que sea opcional estableciendo el indicador apropiado para @RequestParam en false o declarando el argumento usando el contenedor java.util.Optional.

Si el tipo de parámetro del método de destino no es String, la conversión de tipo es se aplica automáticamente.

Si la anotación @RequestParam se declara para Map<String, String> o MultiValueMap<String, String>, el mapa se completa con todos los parámetros de solicitud.

Tenga en cuenta que usar la anotación @RequestParam es opcional, por ejemplo, para establecer sus atributos. De forma predeterminada, cualquier argumento que sea un tipo de valor simple (como se define en BeanUtils#isSimpleProperty) y no se resuelve mediante ningún otro solucionador de argumentos, se trata como si estuviera anotado con @RequestParam.

@RequestHeader

Puede utilizar la anotación @RequestHeader para vincular un encabezado de solicitud a un argumento de método en un controlador.

El siguiente ejemplo muestra una solicitud con encabezados:

 
Host                    localhost:8080
Accept                  text/html,application/xhtml+xml,application/xml;q=0.9
Accept-Language         fr,en-gb;q=0.7,en;q=0.3
Accept-Encoding         gzip,deflate
Accept-Charset          ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive              300

El siguiente código de ejemplo le permite obtener el valor de Accept-headers Encoding y Keep-Alive:

 
@GetMapping("/demo")
public void handle(
@RequestHeader("Accept-Encoding") String encoding, (1)
@RequestHeader("Keep-Alive") long keepAlive) { 
//...
}

@GetMapping("/demo")
fun handle(
@RequestHeader("Accept-Encoding") encoding: String, (1)
@RequestHeader("Keep-Alive") keepAlive: Long) { 
//...
}

Si el tipo del parámetro del método de destino no es String, la conversión de tipo se aplica automáticamente.

Si la anotación @RequestHeader se utiliza en el argumento Map<String, String>, MultiValueMap<String, String> o HttpHeaders, el mapa se completa con todos los valores de encabezado.

@CookieValue

Puedes usar la anotación @CookieValue para vincular un valor de cookie HTTP al argumento del método en el controlador.

El siguiente ejemplo muestra una solicitud con una cookie:

JSESSIONID=415A4AC178C59DACE0B2C9CA727CDD84

El siguiente ejemplo de código muestra cómo obtener el valor de la cookie:

@GetMapping("/demo")
public void handle(@CookieValue("JSESSIONID") String cookie) { 
//...
}

@GetMapping("/demo")
fun handle(@CookieValue("JSESSIONID") cookie: String) { 
//...
}

Si el tipo de parámetro del método de destino no es String, la conversión de tipo se aplica automáticamente.

@ModelAttribute

Puedes usar la anotación @ModelAttribute en un argumento de método para acceder al atributo desde el modelo o crear una instancia. de él si falta. El atributo del modelo también se superpone con los valores de los parámetros de consulta y los campos del formulario, cuyos nombres coinciden con los nombres de los campos. Esto se denomina enlace de datos y elimina la necesidad de analizar y transformar parámetros de consulta y campos de formulario individuales. El siguiente ejemplo muestra cómo se vincula una instancia de Pet:

@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
public String processSubmit(@ModelAttribute Pet pet) { }

@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
fun processSubmit(@ModelAttribute pet: Pet): String { }

La instancia Pet del ejemplo anterior se resuelve de la siguiente manera:

• Del modelo, si tiene ya se ha agregado a través de Model.

• Desde una sesión HTTP a través de la anotación @SessionAttributes.

• Desde una llamada al constructor predeterminado.

• Desde una llamada al "constructor principal" con argumentos correspondientes a parámetros de solicitud o campos de formulario. Los nombres de los argumentos se especifican mediante la anotación @ConstructorProperties para JavaBeans o mediante nombres de parámetros almacenados en código de bytes en tiempo de ejecución.

Después de obtener una instancia del atributo del modelo, se aplica el enlace de datos. La clase WebExchangeDataBinder asigna parámetros de consulta y nombres de campos de formulario a nombres de campos del Objeto de destino. Los campos correspondientes se completan después de la conversión de tipo cuando sea necesario.

La vinculación de datos puede provocar errores. De forma predeterminada, se genera una WebExchangeBindException, pero para verificar dichos errores en un método de controlador, puede agregar un argumento BindingResult directamente al lado de @ModelAttribute. anotación, como se muestra en el siguiente ejemplo:

@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
public String processSubmit(@ModelAttribute("pet") Pet pet, BindingResult result) { 
if (result.hasErrors()) {
return "petForm";
}
// ...
}

@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
fun processSubmit(@ModelAttribute("pet") pet: Pet, result: BindingResult): String { 
if (result.hasErrors()) {
return "petForm"
}
// ...
}

Puede aplicar automáticamente la validación después del enlace de datos agregando la anotación javax.validation.Valid o @Validated código de anotación de Spring. El siguiente ejemplo utiliza la anotación @Valid:

@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
public String processSubmit(@Valid @ModelAttribute("pet") Pet pet, BindingResult result) { 
if (result.hasErrors()) {
return "petForm";
}
// ...
}

@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
fun processSubmit(@Valid @ModelAttribute("pet") pet: Pet, result: BindingResult): String { 
if (result.hasErrors()) {
return "petForm"
}
// ...
}

Spring WebFlux, a diferencia de Spring MVC, admite tipos reactivos en el modelo, por ejemplo, Mono<Account> o io.reactivex.Single<Account>. Puede declarar un argumento marcado con la anotación @ModelAttribute con o sin una función contenedora de tipo reactivo, después de lo cual se resolverá de acuerdo con el valor real si es necesario. Sin embargo, tenga en cuenta que para utilizar el argumento BindingResult, debe declarar el argumento con la anotación @ModelAttribute antes, sin una función contenedora de tipo reactivo, como se mostró anteriormente. Además, puede manejar cualquier error mediante un tipo reactivo, como se muestra en el siguiente ejemplo:

@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
public Mono<String> processSubmit(@Valid @ModelAttribute("pet") Mono<Pet> petMono) {
return petMono
.flatMap(pet -> {
    // ...
})
.onErrorResume(ex -> {
    // ...
});
}

@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
fun processSubmit(@Valid @ModelAttribute("pet") petMono: Mono<Pet>): Mono<String> {
return petMono
    .flatMap { pet ->
        // ...
    }
    .onErrorResume{ ex ->
        // ...
    }
}

Tenga en cuenta que utilice la anotación @ModelAttribute es opcional, por ejemplo, para establecer sus atributos. De forma predeterminada, cualquier argumento que no sea un tipo de valor simple (como se define en BeanUtils#isSimpleProperty) y no se resuelve mediante ningún otro solucionador de argumentos, se trata como si estuviera anotado con @ModelAttribute.

@SessionAttributes

@SessionAttributes se utiliza para almacenar atributos del modelo en WebSession entre solicitudes. Esta es una anotación de nivel de tipo que declara los atributos de sesión utilizados por un controlador en particular. Por lo general, esto enumera los nombres de atributos del modelo o los tipos de atributos del modelo que deben almacenarse de forma transparente en la sesión para solicitudes de acceso posteriores.

Considere el siguiente ejemplo:

 
@Controller
@SessionAttributes("pet") 
public class EditPetForm {
// ...
}        
    

@Controller
@SessionAttributes("pet") 
class EditPetForm {
// ...
} 

@Controller
@SessionAttributes("pet") 
public class EditPetForm {
// ...
@PostMapping("/pets/{id}")
public String handle(Pet pet, BindingResult errors, SessionStatus status) { 
if (errors.hasErrors()) {
    // ...
}
    status.setComplete();
    // ...
}
}
}

@Controller
@SessionAttributes("pet") 
class EditPetForm {
// ...
@PostMapping("/pets/{id}")
fun handle(pet: Pet, errors: BindingResult, status: SessionStatus): String { 
if (errors.hasErrors()) {
    // ...
}
status.setComplete()
// ...
}
}

@GetMapping("/")
public String handle(@SessionAttribute User user) { 
// ...
}

@GetMapping("/")
fun handle(@SessionAttribute user: User): String { 
// ...
} 

@GetMapping("/")
public String handle(@RequestAttribute Client client) { 
// ...
}

@GetMapping("/")
fun handle(@RequestAttribute client: Client): String { 
// ...
}

class MyForm {
private String name;
private MultipartFile file;
// ...
}
@Controller
public class FileUploadController {
@PostMapping("/form")
public String handleFormUpload(MyForm form, BindingResult errors) {
// ...
}
}

class MyForm(
val name: String,
val file: MultipartFile)
@Controller
class FileUploadController {
@PostMapping("/form")
fun handleFormUpload(form: MyForm, errors: BindingResult): String {
// ...
}
}

POST /someUrl
Content-Type: multipart/mixed
--edt7Tfrdusa7r3lNQc79vXuhIIMlatb7PQg7Vp
Content-Disposition: form-data; name="meta-data"
Content-Type: application/json; charset=UTF-8
Content-Transfer-Encoding: 8bit
{
"name": "value"
}
--edt7Tfrdusa7r3lNQc79vXuhIIMlatb7PQg7Vp
Content-Disposition: form-data; name="file-data"; filename="file.properties"
Content-Type: text/xml
Content-Transfer-Encoding: 8bit
... File Data ...

@PostMapping("/")
public String handle(@RequestPart("meta-data") Part metadata, 
@RequestPart("file-data") FilePart file) { 
// ...
}

@PostMapping("/")
fun handle(@RequestPart("meta-data") Part metadata,
@RequestPart("file-data") FilePart file): String { 
// ...
}

@PostMapping("/")
public String handle(@RequestPart("meta-data") MetaData metadata) { 
// ...
}

@PostMapping("/")
fun handle(@RequestPart("meta-data") metadata: MetaData): String { 
// ...
}

@PostMapping("/")
public String handle(@Valid @RequestPart("meta-data") Mono<MetaData> metadata) {
// use uno de los onError*...
}

@PostMapping("/")
fun handle(@Valid @RequestPart("meta-data") metadata: MetaData): String {
// ...
}

@PostMapping("/")
public String handle(@RequestBody Mono<MultiValueMap<String, Part>> parts) { 
// ...
}

@PostMapping("/")
fun handle(@RequestBody parts: MultiValueMap<String, Part>): String { 
// ...
}

@PostMapping("/")
public String handle(@RequestBody Flux<Part> parts) { 
// ...
}

@PostMapping("/")
fun handle(@RequestBody parts: Flow<Part>): String { 
// ...
}

@PostMapping("/accounts")
public void handle(@RequestBody Account account) {
// ...
}

 
@PostMapping("/accounts")
fun handle(@RequestBody account: Account) {
// ...
}

@PostMapping("/accounts")
public void handle(@RequestBody Mono<Account> account) {
// ...
}

@PostMapping("/accounts")
fun handle(@RequestBody accounts: Flow<Account>) {
// ...
}

@PostMapping("/accounts")
public void handle(@Valid @RequestBody Mono<Account> account) {
// use uno de los onError*...
}}

@PostMapping("/accounts")
fun handle(@Valid @RequestBody account: Mono<Account>) {
// ...
}

@PostMapping("/accounts")
public void handle(HttpEntity<Account> entity) {
// ...
}

@PostMapping("/accounts")
fun handle(entity: HttpEntity<Account>) {
// ...
}

@GetMapping("/accounts/{id}")
@ResponseBody
public Account handle() {
// ...
}

@GetMapping("/accounts/{id}")
@ResponseBody
fun handle(): Account {
// ...
}

@GetMapping("/something")
public ResponseEntity<String> handle() {
String body = ... ;
String etag = ... ;
return ResponseEntity.ok().eTag(etag).body(body);
}

@GetMapping("/something")
fun handle(): ResponseEntity<String> {
val body: String = ...
val etag: String = ...
return ResponseEntity.ok().eTag(etag).build(body)
}

@RestController
public class UserController {
@GetMapping("/user")
@JsonView(User.WithoutPasswordView.class)
public User getUser() {
return new User("eric", "7!jd#h23");
}
}
public class User {
public interface WithoutPasswordView {};
public interface WithPasswordView extends WithoutPasswordView {};
private String username;
private String password;
public User() {
}
public User(String username, String password) {
this.username = username;
this.password = password;
}
@JsonView(WithoutPasswordView.class)
public String getUsername() {
return this.username;
}
@JsonView(WithPasswordView.class)
public String getPassword() {
return this.password;
}
}

@RestController
class UserController {
@GetMapping("/user")
@JsonView(User.WithoutPasswordView::class)
fun getUser(): User {
return User("eric", "7!jd#h23")
}
}
class User(
@JsonView(WithoutPasswordView::class) val username: String,
@JsonView(WithPasswordView::class) val password: String
) {
interface WithoutPasswordView
interface WithPasswordView : WithoutPasswordView
}

@ModelAttribute
public void populateModel(@RequestParam String number, Model model) {
model.addAttribute(accountRepository.findAccount(number));
// agregar más ...
}

 
@ModelAttribute
fun populateModel(@RequestParam number: String, model: Model) {
model.addAttribute(accountRepository.findAccount(number))
// agregar más ...
}
        

@ModelAttribute
public Account addAccount(@RequestParam String number) {
return accountRepository.findAccount(number);
}

@ModelAttribute
fun addAccount(@RequestParam number: String): Account {
return accountRepository.findAccount(number);
}

@ModelAttribute
public void addAccount(@RequestParam String number) {
Mono<Account> accountMono = accountRepository.findAccount(number);
model.addAttribute("account", accountMono);
}
@PostMapping("/accounts")
public String handle(@ModelAttribute Account account, BindingResult errors) {
// ...
}

import org.springframework.ui.set
@ModelAttribute
fun addAccount(@RequestParam number: String) {
val accountMono: Mono<Account> = accountRepository.findAccount(number)
model["account"] = accountMono
}
@PostMapping("/accounts")
fun handle(@ModelAttribute account: Account, errors: BindingResult): String {
// ...
}

@GetMapping("/accounts/{id}")
@ModelAttribute("myAccount")
public Account handle() {
// ...
return account;
}

@GetMapping("/accounts/{id}")
@ModelAttribute("myAccount")
fun handle(): Account {
// ...
return account
}

@Controller
public class FormController {
@InitBinder 
public void initBinder(WebDataBinder binder) {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
dateFormat.setLenient(false);
binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, false));
}
// ...
}

@Controller
class FormController {
@InitBinder 
fun initBinder(binder: WebDataBinder) {
val dateFormat = SimpleDateFormat("yyyy-MM-dd")
dateFormat.isLenient = false
binder.registerCustomEditor(Date::class.java, CustomDateEditor(dateFormat, false))
}
// ...
}

@Controller
public class FormController {
@InitBinder
protected void initBinder(WebDataBinder binder) {
binder.addCustomFormatter(new DateFormatter("yyyy-MM-dd")); 
}
// ...
}

@Controller
class FormController {
@InitBinder
fun initBinder(binder: WebDataBinder) {
binder.addCustomFormatter(DateFormatter("yyyy-MM-dd")) 
}
// ...
}

public class ChangeEmailForm {
private String oldEmailAddress;
private String newEmailAddress;
public void setOldEmailAddress(String oldEmailAddress) {
this.oldEmailAddress = oldEmailAddress;
}
public String getOldEmailAddress() {
return this.oldEmailAddress;
}
public void setNewEmailAddress(String newEmailAddress) {
this.newEmailAddress = newEmailAddress;
}
public String getNewEmailAddress() {
return this.newEmailAddress;
}
}

 
@Controller
public class ChangeEmailController {
@InitBinder
void initBinder(WebDataBinder binder) {
binder.setAllowedFields("oldEmailAddress", "newEmailAddress");
}
// métodos @RequestMapping, etc.
}

@Controller
public class SimpleController {
// ...
@ExceptionHandler 
public ResponseEntity<String> handle(IOException ex) {
// ...
}
}

@Controller
class SimpleController {
// ...
@ExceptionHandler 
fun handle(ex: IOException): ResponseEntity<String> {
// ...
}
}

// Apunte a todos los controladores anotados con @RestController
@ControllerAdvice(annotations = RestController.class)
public class ExampleAdvice1 {}
// Apunte a todos los controladores en ciertos paquetes
@ControllerAdvice("org.example.controllers")
public class ExampleAdvice2 {}
// Apunte a todos los controladores asignados a clases específicas
@ControllerAdvice(assignableTypes = {ControllerInterface.class, AbstractController.class})
public class ExampleAdvice3 {}}

// Apunte a todos los controladores anotados con @RestController
@ControllerAdvice(annotations = [RestController::class])
public class ExampleAdvice1 {}
// Seleccione todos los controladores en el apuntar a ciertos paquetes
@ControllerAdvice("org.example.controllers")
public class ExampleAdvice2 {}
// Apunta a todos los controladores asignados a determinadas clases
@ControllerAdvice(assignableTypes = [ControllerInterface::class, AbstractController::class])
public class ExampleAdvice3 {}