¿Qué es @ModelAttribute en Spring MVC?
¿ Cuál es el propósito y uso de @ModelAttributeSpring MVC?
@ModelAttributese refiere a una propiedad del objeto Modelo (la M en MVC;), así que digamos que tenemos un formulario con un objeto de respaldo que se llama "Persona". Luego puede hacer que Spring MVC proporcione este objeto a un método Controlador usando la @ModelAttributeanotación . :
public String processForm(@ModelAttribute("person") Person person){
person.getStuff();
}
Por otro lado la anotación se utiliza para definir objetos que deberían formar parte de un Modelo. Entonces, si desea que se haga referencia a un objeto Persona en el Modelo, puede usar el siguiente método:
@ModelAttribute("person")
public Person getPerson(){
return new Person();
}
Este método anotado permitirá el acceso al objeto Persona en su Vista, ya que Spring lo agrega automáticamente a los Modelos.
Consulte "Uso de @ModelAttribute" .
Sé que este es un hilo viejo, pero pensé en tirar mi sombrero al ring y ver si puedo enturbiar el agua un poco más :)
Descubrí que mi lucha inicial por comprender @ModelAttributefue el resultado de la decisión de Spring de combinar varias anotaciones en una. Quedó más claro una vez que lo dividí en varias anotaciones más pequeñas:
Para las anotaciones de parámetros, considérelo @ModelAttributeel equivalente, es @Autowired + @Qualifierdecir, intenta recuperar un bean con el nombre de pila del modelo administrado por Spring. Si no se encuentra el bean nombrado, en lugar de generar un error o devolver null, implícitamente asume la función de @Bean, es decir, crear una nueva instancia utilizando el constructor predeterminado y agregar el bean al modelo.
Para las anotaciones de métodos, piense en @ModelAttributeel equivalente de @Bean + @Before, es decir, coloca el bean construido por el código del usuario en el modelo y siempre se llama antes de un método de manejo de solicitudes.
En sentido figurado, veo @ModelAttributelo siguiente (¡¡por favor no lo tome literalmente!!):
@Bean("person")
@Before
public Person createPerson(){
return new Person();
}
@RequestMapping(...)
public xxx handlePersonRequest( (@Autowired @Qualifier("person") | @Bean("person")) Person person, xxx){
...
}
Como puede ver, Spring tomó la decisión correcta al hacer @ModelAttributeuna anotación que lo abarque todo; nadie quiere ver una mezcla heterogénea de anotaciones.
Así que intentaré explicarlo de una manera más sencilla. Tengamos:
public class Person {
private String name;
public String getName() {
return name;
}
public void setName(final String name) {
this.name = name;
}
}
Como se describe en la documentación de Spring MVC, la anotación @ModelAttribute se puede usar en métodos o en argumentos de métodos . Y, por supuesto, podemos utilizar ambos al mismo tiempo en un solo controlador.
1.Anotación del método
@ModelAttribute("cities")
public List<String> checkOptions(){
return new Arrays.asList(new[]{"Sofia","Pleven","Ruse"});//and so on
}
El propósito de dicho método es agregar atributos en el modelo. Entonces, en nuestro caso, la clave de ciudades tendrá la lista new Arrays.asList(new[]{"Sofia","Pleven","Ruse"})como valor en el Modelo (puede pensar en el Modelo como mapa (clave: valor)). Los métodos @ModelAttribute en un controlador se invocan antes que los métodos @RequestMapping , dentro del mismo controlador.
Aquí queremos agregar al modelo información común que se utilizará en el formulario para mostrarla al usuario. Por ejemplo, se puede utilizar para completar una selección HTML:
2. Argumento del método
public String findPerson(@ModelAttriute(value="person") Person person) {
//..Some logic with person
return "person.jsp";
}
Un @ModelAttribute en el argumento de un método indica que el argumento debe recuperarse del modelo. Entonces, en este caso esperamos tener en el objeto Persona modelo como clave y queremos obtener su valor y ponerlo en el argumento del método Persona persona . Si no existe o (a veces escribe mal (valor="persona")), Spring no lo encontrará en el Modelo y creará un objeto Persona vacío usando sus valores predeterminados. Luego tomará los parámetros de la solicitud e intentará vincularlos en el objeto Persona usando sus nombres.
name="Dmitrij"&countries=Lesoto&sponsor.organization="SilkRoad"&authorizedFunds=&authorizedHours=&
Entonces tenemos nombre y se vinculará a Person.name usando setName (nombre de cadena). Entonces en
//..Some logic with person
tenemos acceso a este nombre completo con valor "Dimitrij".
Por supuesto, Spring puede vincular objetos más complejos como listas, mapas, listas de conjuntos de mapas, etc., pero detrás de escena hace que la vinculación de datos sea mágica.
Podemos tener al mismo tiempo el método anotado del modelo y el controlador del método de solicitud con @ModelAttribute en los argumentos. Entonces tenemos que unir las reglas.
Por supuesto, tenemos toneladas de situaciones diferentes: los métodos @ModelAttribute también se pueden definir en un @ControllerAdvice y así sucesivamente...
Para mi estilo, siempre uso @ModelAttribute para capturar objetos desde el formulario jsp de primavera. por ejemplo, diseño un formulario en una página jsp, ese formulario existe con nombre de comando
<form:form commandName="Book" action="" methon="post">
<form:input type="text" path="title"></form:input>
</form:form>
y capto el objeto en el controlador con el siguiente código
public String controllerPost(@ModelAttribute("Book") Book book)
y cada nombre de campo del libro debe coincidir con la ruta en el subelemento del formulario