¿Qué es @ModelAttribute en Spring MVC?

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

@ModelAttribute refiere a una propiedad del objeto Modelo (la M en MVC;) así que digamos que tenemos un formulario con un objeto de respaldo de formulario que se llama “Persona” Entonces puede hacer que Spring MVC suministre este objeto a un método de Controlador usando la anotación @ModelAttribute :

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

Consulte aquí un ejemplo (Spring 2.5), también consulte “Uso de @ModelAttribute en un argumento de método” (Spring 3.1).

Por otro lado, la anotación se usa para definir objetos que deberían ser parte de un Modelo. Entonces, si desea tener un objeto Persona al que se haga referencia 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 se agrega automáticamente a los Modelos por Spring.

Consulte “Uso de @ModelAttribute en un método” (Spring 3.1).

Espero que esto haya ayudado.

Sé que este es un hilo viejo, pero pensé que arrojaría mi sombrero al ring y vería si podía enturbiar el agua un poco más 🙂

Descubrí que mi lucha inicial para comprender @ModelAttribute fue el resultado de la decisión de Spring de combinar varias anotaciones en una. Se hizo más claro una vez que lo dividí en varias anotaciones más pequeñas:

Para las anotaciones de parámetros, piense en @ModelAttribute como el equivalente de @Autowired + @Qualifier es decir, trata de recuperar un bean con el nombre dado del modelo administrado por Spring. Si el bean nombrado no se encuentra, en lugar de arrojar un error o devolver null , implícitamente toma el rol de @Bean es decir, @Bean 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 por el código del usuario en el modelo y siempre se llama antes de un método de manejo de solicitudes.

En sentido @ModelAttribute , veo @ModelAttribute como el siguiente (¡¡¡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 de hacer que @ModelAttribute una anotación que lo abarque todo; nadie quiere ver una mezcla heterogénea de anotaciones.

Para mi estilo, siempre utilizo @ModelAttribute para atrapar objetos desde el formulario de spring jsp. por ejemplo, diseño formulario en la página jsp, esa forma existe con commandName

    

y atrapo 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 de la forma

Entonces 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; } } 

Tal 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 usar ambos al mismo tiempo en un controlador.

1.Method anotación

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

El propósito de tal método es agregar un atributo en el modelo. Entonces, en nuestro caso, la clave de ciudades tendrá la lista new Arras.asList(new[]{“Sofia”,”Pleven","Ruse”}) como valor en el Modelo (puede pensar en Modelo como mapa (clave: valor) ) Se invocan los métodos @ModelAttribute en un controlador antes de los métodos @RequestMapping , 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 usar para completar una selección de HTML:

enter image description here

2.Método argumento

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

Un @ModelAttribute en un argumento de método indica que el argumento debe recuperarse del modelo. Entonces, en este caso, esperamos que tengamos en el objeto Persona modelo la clave y queremos obtener su valor y ponerlo en el argumento del método Persona persona . Si no existe o (a veces escribe mal el (valor = “persson”)), Spring no lo encontrará en el Modelo y creará el objeto Person vacío utilizando 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=& 

Entonces tenemos un nombre y se vinculará a Person.name usando setName (String name). Entonces en

 //..Some logic with person 

tenemos acceso a este nombre lleno con el valor “Dimitrij”.

Por supuesto, Spring puede enlazar objetos más complejos como Lists, Maps, List of Sets of Maps, etc., pero detrás de la escena hace que el enlace de datos sea mágico.

  1. Podemos tener al mismo tiempo el método anotado de modelo y el controlador de método de solicitud con @ModelAttribute en los argumentos. Entonces tenemos que unir las reglas.

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

Esto se usa con fines de enlace de datos en Spring MVC . Te permite tener un jsp que tenga un elemento de formulario, por ejemplo

en JSP

(El método Spring Form, también se puede usar el elemento Simple form)

En el lado del controlador

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

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

Sé que llego tarde a la fiesta, pero citaré como dicen: “será mejor que lleguemos tarde”. Así que vamos, todo el mundo tiene sus propias maneras de explicar las cosas, permítanme tratar de resumirlo y simplificarlo en unos pocos pasos con un ejemplo; Supongamos que tiene un formulario simple, form.jsp

  First Name :  

Last Name :

path = “firstName” path = “lastName” Estos son los campos / propiedades en el StudentClass cuando se llama al formulario se llaman sus getters pero una vez enviados se llaman sus setters y sus valores se establecen en el bean que se indicó en el modeloAttribute = “estudiante” en la etiqueta de 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 finalmente tenemos un form-details.jsp

 Student Information ${student.firstName} ${student.lastName} 

Volvamos a la pregunta ¿Qué es @ModelAttribute en Spring MVC? Una definición de muestra de la fuente para usted, http://www.baeldung.com/spring-mvc-and-the-modelattribute-annotation El atributo @ModelAttribute es una anotación que vincula un parámetro de método o un valor de retorno de método a un atributo de modelo con nombre. y luego lo expone a una vista web.

Lo que sucede realmente es que obtiene todos los valores de su formulario que envió y luego 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 del estudiante que se reenvía al formulario. theModel.addAttribute (“estudiante”, nuevo Estudiante ());

Paso 2: modelAttribute = “student” en el modelo de envío de formularios cambia al estudiante y ahora contiene todos los parámetros del formulario

Paso 3: @ModelAttribute (“student”) Student theStudent Traemos los valores que se mantienen en @ModelAttribute y asignamos el bean / object entero a Student.

Paso 4: Y luego lo usamos como ofertamos, al igual que mostrarlo en la página, etc. como lo hice

Espero que te ayude a entender el concepto. Gracias

Anotación que vincula 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.

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

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

Árbitro. http://www.javabeat.net/modelattribute-spring-mvc/

La anotación @ModelAttribute se usa como parte de una aplicación web Spring MVC y se puede usar en dos escenarios.

En primer lugar, puede usarse para inyectar objetos de datos al modelo antes de que se cargue un JSP. Esto lo hace particularmente útil para garantizar que un JSP tenga todos los datos necesarios para mostrarse. La inyección se logra vinculando un valor de retorno de método al modelo. En segundo lugar, se puede utilizar para leer datos de un modelo existente asignándolo a los parámetros del método del controlador. Para demostrar @ModelAttributes, estoy usando los escenarios más simples: agregando una cuenta de usuario a un sistema hipotético y luego, una vez que se ha creado la cuenta de usuario, se muestran los detalles del nuevo usuario en una pantalla de bienvenida.

Para comenzar a rodar la pelota, necesitaré un simple Bean de usuario con algunos campos familiares: nombre, apellido, alias y dirección de correo electrónico: los sospechosos habituales.

@ModelAttribute simplemente vincula el valor de los campos jsp a Pojo calss para realizar nuestra lógica en la clase de controlador. Si está familiarizado con los puntales, entonces es como poblar el objeto Formbean al momento de la presentación.

@ModelAttribute creará un atributo con el nombre especificado por usted (@ModelAttribute("Testing") Test test) as Testing en el ejemplo dado, Test siendo el test de bean la referencia al bean y Testing estará disponible en el modelo para que puede seguir utilizándolo en páginas jsp para recuperar los valores que almacenó en su ModelAttribute .