¿Qué es @ModelAttribute en Spring MVC?

Question

¿Cuál es el propósito y el uso de @ModelAttribute en Spring MVC?

Answer 1

@ModelAttribute se refiere a una propiedad del objeto modelo (la M en MVC;) así que vamos a decir que tenemos un formulario con un objeto de formulario respaldo que se llama "Persona" , entonces puede tener Spring MVC suministrar este objeto para un método de controlador mediante el uso de la anotación @ModelAttribute:

public String processForm(@ModelAttribute("person") Person person){ 
    person.getStuff(); 
} 

Check here para un ejemplo (primavera 2.5), también ver "Using @ModelAttribute on a method argument" (primavera 3,1).

Por otro lado, la anotación se usa para definir objetos que deberían ser parte de un Modelo. Así que si usted quiere tener un objeto Persona que se hace referencia en el modelo se puede utilizar el siguiente método:

@ModelAttribute("person") 
public Person getPerson(){ 
    return new Person(); 
} 

Este método anotado permitirá el acceso al objeto Persona en su opinión, ya que se agrega automáticamente a los modelos por Spring.

Ver "Using @ModelAttribute on a method" (Spring 3.1).

Espero que esto haya ayudado.

Answer 2

Sé que esto es un viejo hilo, pero pensé que tirar mi sombrero en el anillo y ver si puedo enturbiar el agua un poco más :)

encontré mi lucha inicial para entender @ModelAttribute era una resultado de la decisión de Spring de combinar varias anotaciones en una. Se hizo más clara una vez que dividirlo en varias anotaciones más pequeños:

para las anotaciones de los parámetros, pensar en @ModelAttribute como el equivalente de @Autowired + @Qualifier es decir, intenta recuperar un grano con el nombre dado a partir del modelo de Primavera administrado. Si no se encuentra el bean indicado, en lugar de arrojar un error o devolver null, toma implícitamente el rol de @Bean, es decir, crea una nueva instancia usando el constructor predeterminado y agrega el bean al modelo.

Para las anotaciones de métodos, piense en @ModelAttribute como el equivalente de @Bean + @Before, es decir, coloca el bean construido con el código del usuario en el modelo y siempre se invoca antes de un método de manejo de solicitudes.

En sentido figurado, veo @ModelAttribute como las siguientes (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 se puede ver, el resorte hecho la decisión correcta para hacer @ModelAttribute una anotación que lo abarca todo; nadie quiere ver una mezcla heterogénea de anotaciones.

Answer 3

@ModelAttribute se puede utilizar como el método argumentos/parámetro o antes de la declaración del método. El objetivo principal de esta anotación es vincular los parámetros de solicitud o campos de formulario a un objeto de modelo

Ref. http://www.javabeat.net/modelattribute-spring-mvc/

Answer 4

Para mi estilo, siempre uso @ModelAttribute para atrapar objetos desde la forma de primavera jsp.por ejemplo, yo diseño del formulario en la página JSP, que forma existe con CommandName

<form:form commandName="Book" action="" methon="post"> 
     <form:input type="text" path="title"></form:input> 
</form:form> 

y coger el objeto en el controlador con el código de seguimiento

public String controllerPost(@ModelAttribute("Book") Book book) 

y cada nombre de campo del libro debe ser coincidencia con la ruta en el subelemento de la forma

Answer 5

@ModelAttribute creará un atributo con el nombre especificado por usted (@ModelAttribute("Testing") Test test) as Testing en el ejemplo dado, Prueba siendo la prueba de frijol la referencia al bean y la Prueba estará disponible en el modelo para que pueda f También úsela en páginas jsp para la recuperación de valores que almacenó en usted ModelAttribute.

Answer 6

Anotación que enlaza un parámetro de método o valor de retorno de método a un atributo de modelo con nombre, expuesto a una vista web.

private String add(@ModelAttribute("specified ") Model model) { 
    ... 
} 

Answer 7

Esto se utiliza para fines de enlace de datos en Spring MVC. Le permiten tener una JSP tiene un elemento de forma en la que por ejemplo

en JSP

<form:form action="test-example" method="POST" commandName="testModelAttribute"> </form:form>

(Método de formulario primavera, elemento forma simple se puede utilizar también)

En el lado del controlador

@RequestMapping(value = "/test-example", method = RequestMethod.POST) 
public ModelAndView testExample(@ModelAttribute("testModelAttribute") TestModel testModel, Map<String, Object> map,...) { 

} 

Ahora cuando envíe el formulario, los valores de los campos del formulario estarán disponibles para usted.

Answer 8

Así que trataré de explicarlo de una manera más simple. 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 Spring MVC - la @ModelAttribute anotación se puede utilizar en los métodos o en argumentos del método. Y, por supuesto, podemos usar ambos al mismo tiempo en un controlador.

1.Method anotación

@ModelAttribute(“cities”) 
public List<String> checkOptions(){ 
return new Arras.asList(new[]{“Sofia”,”Pleven","Ruse”});//and so on 
} 

propósito de tal método consiste en añadir el atributo en el modelo. Por lo tanto, en nuestro caso la clave ciudades tendrá la lista new Arras.asList(new[]{“Sofia”,”Pleven","Ruse”}) como valor en el Modelo (puede pensar en Modelo como mapa (clave: valor)). @ModelAttribute métodos en un controlador se invocan antes de @RequestMapping métodos, dentro del mismo controlador.

Aquí queremos agregar a la información común del modelo que se utilizará en el formulario para mostrar al usuario.Por ejemplo se puede utilizar para llenar un HTML seleccionar:

2.Method argumento

public String findPerson(@ModelAttriute(value="person") Person person) { 
    //..Some logic with person 
    return "person.jsp"; 
} 

Un @ModelAttribute en un argumento método indica el argumento debe ser recuperada a partir del modelo. Entonces, en este caso, esperamos que tengamos en el objeto persona como clave y queremos obtener su valor y ponerlo en el argumento Persona persona. Si no existe o (a veces se escribe mal el (valor = "persson")). Entonces Spring no lo encontrará en el Modelo y creará un objeto Person vacío usando sus valores predeterminados. A continuación, tomará los parámetros de solicitud y tratará de vincular los datos en el objeto Persona utilizando sus nombres.

name="Dmitrij"&countries=Lesoto&sponsor.organization="SilkRoad"&authorizedFunds=&authorizedHours=& 

Así que tenemos el nombre y se unirá a Person.name usando setName (String name). Entonces, en

//..Some logic with person 

tenemos acceso a este nombre rellenado con el valor "Dimitrij".

Por supuesto, Spring puede enlazar objetos más complejos como listas, mapas, lista de juegos de mapas, etc., pero detrás de la escena hace que el enlace de datos sea mágico.

3. Podemos tener al mismo tiempo un método anotado y un gestor de método de solicitud con @ModelAttribute en los argumentos. Entonces tenemos que unir las reglas.

4. Por supuesto, tenemos toneladas de diferentes situaciones - @ModelAttribute métodos también se pueden definir en un @ControllerAdvice y así sucesivamente ...

Answer 9

sé que estoy tarde a la fiesta, pero yo' Citaré como dicen, "mejor tarde que nunca". Así que vamos, Todos tienen sus propias maneras de explicar las cosas, permítanme tratar de resumirlo y simplificarlo en unos pocos pasos con un ejemplo; Supongamos que tienes una forma sencilla, form.jsp

<form:form action="processForm" modelAttribute="student"> 
First Name : <form:input path="firstName" /> 
<br><br> 
Last Name : <form:input path="lastName" /> 
<br><br> 
<input type="submit" value="submit"/> 
</form:form> 

path = "Nombre" path = "Apellido" Estos son los campos/propiedades en el StudentClass cuando el formulario se llama sus captadores se llaman pero una vez que se envía, se llama a sus instaladores y sus valores se establecen en el bean que se indicó en el modeloAttribute = "student" en la etiqueta del formulario.

Tenemos StudentController que incluye los siguientes métodos;

@RequestMapping("/showForm") 
public String showForm(Model theModel){ //Model is used to pass data between 
//controllers and views 
    theModel.addAttribute("student", new Student()); //attribute name, value 
return "form"; 
} 

@RequestMapping("/processForm") 
public String processForm(@ModelAttribute("student") Student theStudent){ 
    System.out.println("theStudent :"+ theStudent.getLastName()); 
return "form-details"; 
} 

//@ModelAttribute("student") Student theStudent 
//Spring automatically populates the object data with form data all behind the 
//scenes 

ahora por fin tenemos una forma-details.jsp

<b>Student Information</b> 
${student.firstName} 
${student.lastName} 

Así que de vuelta a la pregunta ¿Cuál es @ModelAttribute en Spring MVC? Una definición de ejemplo de la fuente para usted, http://www.baeldung.com/spring-mvc-and-the-modelattribute-annotation El @ModelAttribute es una anotación que se une un parámetro de método o el valor de retorno del método a un atributo llamado modelo y luego se expone a una vista web.

Lo que sucede en realidad es que obtiene todos los valores de su formulario que enviaba y los mantiene para que los vincule o los asigne al objeto. Funciona igual que @RequestParameter donde solo obtenemos un parámetro y asignamos el valor a algún campo. La única diferencia es @ModelAttribute contiene todos los datos del formulario en lugar de un solo parámetro. Crea un bean para ti que contiene los datos enviados para que el desarrollador los use más adelante.

Para recapitular todo. Paso 1: Se envía una solicitud y se ejecuta nuestro método showForm y un modelo, se establece un bean temporal con el nombre de estudiante que se reenvía al formulario. theModel.addAttribute ("student", new Student());

Paso 2: modelAttribute = "estudiante" en el modelo de formulario de presentación cambia el estudiante y ahora se mantiene todos los parámetros de la forma

Paso 3: @ModelAttribute (" estudiante ") Estudiante theStudent Traemos los valores que se mantienen por @ModelAttribute y asigne el bean/object entero a Student.

Paso 4: Y luego usarlo como lo hace una oferta, al igual que lo muestra en la página, etc como lo hice

espero que le ayuda a comprender el concepto. Gracias