¿Cuál es @ModelAttribute en Spring MVC?

https://stackoverflow.com/questions/3423262

26-09-2019
|

Pregunta

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

Solución

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

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

Por otro lado, la anotación se utiliza para definir los objetos que deben 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 para la primavera.

Consulte " Uso @ModelAttribute ".

Otros consejos

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

He encontrado mi lucha inicial para entender @ModelAttribute fue el resultado de la decisión de la primavera de combinar varias anotaciones en una sola. Se hizo más clara una vez que dividirlo en varias anotaciones más pequeños:

En las anotaciones de los parámetros, piensa 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 llamado, en lugar de tirar un error o regresar null, se necesita de manera implícita en el papel de @Bean es decir, crear una nueva instancia utilizando el constructor por defecto y añadir el grano al modelo.

Para anotaciones método, pensar en @ModelAttribute como el equivalente de @Bean + @Before, es decir, se pone el grano construido por el código de usuario en el modelo y que siempre se llama antes de método de gestión de una solicitud.

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, Primavera tomó la decisión correcta para hacer @ModelAttribute una anotación que lo abarca todo; nadie quiere ver una mezcla heterogénea de anotación.

Para mi estilo, yo siempre uso @ModelAttribute al objeto de captura de la forma del resorte JSP. por ejemplo, I diseño del formulario en la página JSP, que forma existen 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 sub-elemento de la forma

Así que voy a tratar de explicarlo de manera más sencilla. Vamos a tener:

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 métodos o en Método de argumentos . Y, por supuesto, podemos tener tanto para uso al mismo tiempo en un solo controlador.

1.Method anotación

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

Objetivo de este método consiste en añadir el atributo en el modelo. Así, en nuestro caso las ciudades llave tendrán la lista new Arras.asList(new[]{“Sofia”,”Pleven","Ruse”}) como valor en el modelo (se puede pensar en modelos como mapa (clave: valor)). @ModelAttribute métodos en un controlador se invocan antes @RequestMapping métodos, dentro del mismo controlador.

Aquí queremos añadir a la información común de modelo que será utilizado en el formulario para mostrar al usuario. Por ejemplo se puede utilizar para llenar un HTML seleccione:

argumento 2.Method

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. Así que en este caso se esperaría que tenemos en el modelo persona objeto como clave y queremos obtener su valor y ponerlo al argumento método Persona persona . Si tal no existe o (a veces se escribe incorrectamente el (valor = "Persson")), entonces la primavera no lo encontrará en el modelo y creará objeto Person vacío usando sus valores por defecto. A continuación, se llevará a los parámetros de la petición y tratar los datos se unen en la persona objeto de divulgar su nombre.

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

Así que tenemos nombre y será unen a Person.name usando setName (String name). Así que en

//..Some logic with person

tenemos acceso a este nombre lleno de valor "Dimitrij".

Por supuesto primavera se puede unir objetos más complejos, como listas, mapas, lista de conjuntos de mapas y así sucesivamente, pero detrás de la escena que hace que los datos de la magia vinculante.

puede tener al mismo tiempo modelo anotada controlador de métodos y método de la petición con @ModelAttribute en los argumentos. Entonces tenemos que la unión de las reglas.
Por supuesto, tenemos toneladas de diferentes situaciones - @ModelAttribute métodos también se pueden definir en un @ControllerAdvice y así sucesivamente ...

Yo sé que estoy tarde a la fiesta, pero voy a citar como dicen, "Mejor tarde que nunca". Así que vamos a ponerse en marcha, Todo el mundo tiene sus propias formas de explicar las cosas, vamos a tratar de resumir y simple, para que te en unos pocos pasos con un ejemplo; Suponga que tiene una forma simple, 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 son llamados pero una vez presentado sus emisores son llamados y sus valores se establecen en el grano que se indica en el modelAttribute = "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 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- la-modelattribute-anotación La @ModelAttribute es una anotación que se une a un parámetro del método o el valor de retorno del método a un atributo de modelo llamada y luego lo expone a una vista web.

Lo que realmente ocurre es que se lleva todos los valores de su formulario de aquellos fue formulada por éste y luego se las mantiene para que se unen o asignarlos al objeto. Funciona como el mismo @RequestParameter , donde sólo tenemos un parámetro y asignar el valor a algún campo. La única diferencia es @ModelAttribute contiene todos los datos del formulario en lugar de un único parámetro. Se crea un frijol para usted que contiene los datos del formulario presentado para ser utilizado por el desarrollador más adelante.

Para recapitular todo el asunto. Paso 1 : Se envía una solicitud y nuestras carreras ShowForm método y un modelo, un grano temporal se establece con el nombre del estudiante es enviado a la forma. theModel.addAttribute ( "estudiante", nuevo estudiante ());

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

Paso 3: @ModelAttribute ( "estudiante") Estudiante theStudent Buscamos a los valores que espera por @ModelAttribute y asignar el conjunto de frijol / objeto con el estudiante.

Paso 4: Y luego lo usamos como nos 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

Tome cualquier aplicación web si se trata de Gmail o Facebook o Instagram o cualquier otra aplicación web, es todo sobre el intercambio de datos o información entre el usuario final y la aplicación o la interfaz de usuario y la aplicación back-end. Incluso en Spring MVC mundo hay dos formas de intercambio de datos:

desde el controlador a la interfaz de usuario, y
desde la interfaz de usuario al controlador.

Lo que nos interesa aquí es cómo los datos son comunicados desde la interfaz de usuario con el controlador. Esto también se puede hacer de 2 maneras:

Uso de un formulario HTML
Uso de parámetros de consulta.

El uso de un formulario HTML: Considere el siguiente escenario,

Cuando nos sometemos los datos del formulario desde el navegador web, se puede acceder a esos datos en nuestra clase controlador como un objeto. Cuando nos sometemos un formulario HTML, el contenedor de la primavera hace cuatro cosas. Será,

leer primero todos los datos que se han presentado que viene en la solicitud utilizando el método request.getParameter.
una vez que los lee, los convertirá en el tipo Java adecuada usando Integer.parseInt , double.parseDouble y todos los demás métodos de análisis sintáctico que están disponibles sobre la base de el tipo de datos de los datos.
una vez analizada, se creará un objeto de la clase del modelo que hemos creado. Por ejemplo, en este escenario, es la información del usuario que está siendo sometido y creamos una clase llamada del usuario, la cual el contenedor creará un objeto de y fijará todos los valores que vienen en forma automática en ese objeto.
A continuación, se entrega dicho objeto mediante el establecimiento de los valores para el controlador.

Para conseguir todo esto funcione, tendremos que seguir ciertos pasos.

En primer lugar, hay que definir una clase de modelo, como usuario, en el que el número de campos debe coincidir exactamente con el número de campos en el formulario HTML. Además, los nombres que utilizamos en el formulario HTML deben coincidir con los nombres que tenemos en la clase Java. Estos dos son muy importantes. Los nombres deben coincidir con el número de campos en el formulario debe coincidir con el número de campos en la clase que creamos. Una vez que hagamos eso, el contenedor leerá automáticamente los datos que entra, crea un objeto de este modelo, establece los valores y se lo entrega al controlador. Para leer esos valores dentro del controlador, se utiliza el @ModelAttribute anotación en los parámetros del método. Cuando creamos métodos en el controlador, vamos a utilizar el @ModelAttribute y añadir un parámetro a la misma que tendrá automáticamente este objeto dado por el contenedor.

Aquí hay un código de ejemplo para el registro de un usuario:

@RequestMapping(value = "registerUser", method = RequestMethod.POST)
public String registerUser(@ModelAttribute("user") User user, ModelMap model) {
    model.addAttribute("user", user);
    return "regResult";
}

La esperanza esta explicación esquemática ayudó!

Esto se utiliza para los propósitos de unión en MVC primavera de datos. 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 la forma del resorte, el elemento de forma simple también se puede utilizar)

El controlador lateral

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

}

Ahora, cuando se le envíe el formulario de los valores de los campos de formulario estará disponible para usted.

anotación que se une a un parámetro del método o el valor de retorno del método a un atributo de modelo llamado, expuesto a una vista web.

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

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

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

@ModelAttribute creará un atributo con el nombre especificado por usted (@ModelAttribute("Testing") Test test) as Testing en el ejemplo dado, prueba ser la prueba de frijol siendo la referencia al bean y pruebas estará disponible en el modelo de modo que se puede utilizar más que en las páginas JSP para la recuperación de los valores que se almacenaron en los que ModelAttribute.

@ModelAttribute simplemente se une el valor de los campos JSP para Pojo calss para llevar a cabo nuestra lógica en la clase controlador. Si está familiarizado con los puntales, entonces esto es como poblar el objeto FormBean tras la presentación.

La anotación ModelAttribute se utiliza como parte de una aplicación Spring MVC Web y se puede utilizar en dos escenarios.

En primer lugar, se puede utilizar para inyectar datos en un modelo de carga pre-JSP. Esto es especialmente útil para asegurar que una página JSP es necesario para visualizar todos los datos en sí. Una inyección se obtiene mediante la conexión de un método para el modelo.

En segundo lugar, se puede utilizar para leer datos de un modelo existente y asignarla a los parámetros del método del entrenador.

https://dzone.com/articles/using- primavera-mvc% E2% 80% 99s

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow