java - multiple - spring boot model attribute

¿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 puede usar como los argumentos / parámetros del método o antes de la declaración del método. El objetivo principal de esta anotación es vincular los parámetros de solicitud o los campos de formulario a un objeto modelo

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

Answer 2

@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 esto es como rellenar el objeto formbean al enviarlo.

Answer 3

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 usar ambos al mismo tiempo en un 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 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 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 mostrar al usuario. Por ejemplo, se puede utilizar para llenar una selección de HTML:

2.Metodo 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 como clave y deseamos obtener su valor y ponerlo en el argumento persona de persona . Si tal cosa no existe o (a veces escribe mal el (value = "persson")), Spring no lo encontrará en el Modelo y creará un objeto Person vacío utilizando sus valores predeterminados. Luego tomará los parámetros de solicitud e intentará vincularlos en el objeto Person utilizando sus nombres.

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

Así que tenemos nombre y se unirá a Person.name usando setName (nombre de cadena). Así que en

//..Some logic with person

Tenemos acceso a este nombre completo con el valor "Dimitrij".

Por supuesto, Spring puede enlazar objetos más complejos como Listas, Mapas, Lista de Conjuntos 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 controlador de método de solicitud con @ModelAttribute en los argumentos. Entonces tenemos que unir las reglas.

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

Answer 4

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

en JSP

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

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

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 5

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, se puede usar para inyectar objetos de datos en el 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 el método con un valor de retorno de método. En segundo lugar, se puede usar para leer datos de un modelo existente asignándolos a los parámetros del método del controlador. Para demostrar los atributos @ModelAttributes, estoy usando los escenarios más simples: agregar una cuenta de usuario a un sistema hipotético y luego, una vez que se haya 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 bean User simple con algunos campos familiares: nombre, apellido, nombre de usuario y dirección de correo electrónico, los sospechosos habituales.

Answer 6

Para mi estilo, siempre uso @ModelAttribute para capturar objetos de spring form jsp. por ejemplo, diseño formulario en la página jsp, ese formulario existe con commandName

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

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

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

Answer 7

Sé que este es un hilo viejo, pero pensé que tiro mi sombrero en el anillo y veo si puedo embarrar el agua un poco más :)

Encontré que mi primera dificultad para entender @ModelAttribute fue el resultado de la decisión de Spring de combinar varias anotaciones en una sola. 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 Spring. Si no se encuentra el bean nombrado, en lugar de lanzar un error o devolver un null , implícitamente asume el rol de @Bean es decir, @Bean una nueva instancia utilizando 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.

Figurativamente, veo @ModelAttribute como lo siguiente (por favor, ¡¡no lo tomes 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 convertir @ModelAttribute una anotación que lo abarca todo; Nadie quiere ver una mezcla heterogénea de anotaciones.

Answer 8

Sé que llego tarde a la fiesta, pero citaré como dicen, "es mejor llegar tarde que nunca". Así que vamos a seguir, Cada uno tiene sus propias maneras de explicar las cosas, déjeme intentar resumirlo y simplificarlo en unos pocos pasos con un ejemplo; Supongamos que tienes un formulario 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 = "firstName" path = "lastName" Estos son los campos / propiedades en StudentClass cuando se llama al formulario, se llama a sus captadores, pero una vez enviados, se llama a sus definidores y sus valores se configuran en el bean que se indicó en el atributo ModelAttribute = "Estudiante" en 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 formulario-detalles.jsp

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

Entonces, 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 @ModelAttribute es una anotación que enlaza un parámetro de método o un valor de retorno de método a un atributo de modelo nombrado y luego lo expone a una vista web.

Lo que realmente sucede es que obtiene todos los valores de su formulario que enviaba y luego los retiene para que usted los enlace o los asigne al objeto. Funciona igual que el @RequestParameter, donde solo obtenemos un parámetro y asignamos el valor a algún campo. La única diferencia es que @ModelAttribute contiene todos los datos de formulario en lugar de un solo parámetro. Crea un bean para usted que contiene los datos del formulario enviado para que el desarrollador los utilice más adelante.

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

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

Paso 3: @ModelAttribute ("student") Student theStudent Obtenemos los valores que mantiene @ModelAttribute y asignamos todo el bean / objeto a Student.

Paso 4: Y luego lo usamos como oferta, tal como lo mostramos en la página, etc., como hice yo

Espero que te ayude a entender el concepto. Gracias

Answer 9

Una anotación que vincula un parámetro de método o el método devuelve un valor a un atributo de modelo nombrado, expuesto a una vista web.

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

Answer 10

@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". Luego, puede hacer que Spring MVC suministre este objeto a un método del Controlador usando @ModelAttribute anotación @ModelAttribute :

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

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

Por otro lado, la anotación se utiliza para definir objetos que deben formar parte de un modelo. Por lo tanto, si desea que se haga referencia a un objeto Person 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 de Spring.

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

Espero que esto haya ayudado.

Answer 11

@ModelAttribute creará un atributo con el nombre especificado por usted (@ModelAttribute("Testing") Test test) as Testing en el ejemplo dado. Prueba es la prueba de frijol que es la referencia al frijol y la Prueba estará disponible en el modelo para que puede usarlo aún más en las páginas jsp para recuperar los valores que almacenó en su ModelAttribute .