Che cos'è @ModelAttribute in Spring MVC?

Qual è lo scopo e l'uso di @ModelAttributein Spring MVC?

@ModelAttributefa riferimento a una proprietà dell'oggetto Model (la M in MVC;) quindi diciamo che abbiamo un modulo con un oggetto di supporto del modulo che si chiama "Person" Quindi puoi fare in modo che MVC Spring fornisca questo oggetto a un metodo Controller usando l' @ModelAttributeannotazione :

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

D'altra parte l'annotazione viene utilizzata per definire oggetti che dovrebbero far parte di un modello. Pertanto, se si desidera che un oggetto Person faccia riferimento nel modello, è possibile utilizzare il seguente metodo:

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

Questo metodo annotato consentirà l'accesso all'oggetto Persona nella tua vista, poiché viene automaticamente aggiunto ai modelli entro la primavera.

Vedi "Uso di @ModelAttribute" .

So che questo è un vecchio filo, ma ho pensato di gettare il cappello sul ring e vedere se riesco a confondere un po 'di più l'acqua :)

Ho scoperto che la mia lotta iniziale per capire @ModelAttributeera il risultato della decisione di Spring di combinare diverse annotazioni in una sola. È diventato più chiaro quando l'ho diviso in diverse annotazioni più piccole:

Per le annotazioni dei parametri, si @ModelAttributeconsideri l'equivalente di @Autowired + @Qualifiercioè tenta di recuperare un bean con il nome specificato dal modello gestito Spring. Se il bean denominato non viene trovato, invece di generare un errore o restituirlo null, assume implicitamente il ruolo di @Beancreare una nuova istanza utilizzando il costruttore predefinito e aggiungere il bean al modello.

Per le annotazioni del metodo, si pensi @ModelAttributeall'equivalente di @Bean + @Before, ovvero inserisce il bean costruito dal codice dell'utente nel modello e viene sempre chiamato prima di un metodo di gestione delle richieste.

In senso figurato, vedo @ModelAttributequanto segue (per favore, non prenderlo alla lettera !!):

@Bean("person")
@Before
public Person createPerson(){
  return new Person();
}

@RequestMapping(...)
public xxx handlePersonRequest( (@Autowired @Qualifier("person") | @Bean("person")) Person person, xxx){
  ...
}

Come puoi vedere, Spring ha preso la decisione giusta per fare @ModelAttributeun'annotazione onnicomprensiva; nessuno vuole vedere un smorgasbord di annotazione.

Per il mio stile, uso sempre @ModelAttribute per catturare oggetti dalla molla jsp. per esempio, disegno il modulo sulla pagina jsp, quel modulo esiste con commandName

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

e prendo l'oggetto sul controller con il seguente codice

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

e ogni nome di campo del libro deve corrispondere al percorso nel sottoelemento del modulo

Quindi proverò a spiegarlo in modo più semplice. Diamo:

public class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(final String name) {
        this.name = name;
    }
}

Come descritto nella documentazione di Spring MVC, l' annotazione @ModelAttribute può essere utilizzata sui metodi o sugli argomenti dei metodi . E ovviamente possiamo utilizzarli entrambi contemporaneamente in un controller.

1. Annotazione di metodi

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

Lo scopo di tale metodo è quello di aggiungere l'attributo nel modello. Quindi nel nostro caso la chiave città avrà l'elenco new Arras.asList(new[]{“Sofia”,”Pleven","Ruse”})come valore nel Modello (puoi pensare a Modello come mappa (chiave: valore)). I metodi @ModelAttribute in un controller vengono richiamati prima dei metodi @RequestMapping , all'interno dello stesso controller.

Qui vogliamo aggiungere al Modello informazioni comuni che verranno utilizzate nel modulo per essere visualizzate all'utente. Ad esempio può essere utilizzato per riempire una selezione HTML:

2. Argomento di metodo

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

Un @ModelAttribute su un argomento del metodo indica che l'argomento deve essere recuperato dal modello. Quindi in questo caso ci aspettiamo di avere l' oggetto Model person come chiave e vogliamo ottenere il suo valore e inserirlo nell'argomento del metodo Person person . Se tale non esiste o (a volte si scrive male (value = "persson")), Spring non lo troverà nel Modello e creerà un oggetto Person vuoto usando i suoi valori predefiniti. Quindi prenderà i parametri della richiesta e proverà a collegarli ai dati nell'oggetto Person usando i loro nomi.

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

Quindi abbiamo nome e sarà associato a Person.name usando setName (String name). Quindi dentro

//..Some logic with person

abbiamo accesso a questo nome completo con valore "Dimitrij".

Naturalmente Spring può associare oggetti più complessi come Elenchi, Mappe, Elenco di insiemi di mappe e così via, ma dietro la scena rende magici i dati.

3. Possiamo avere allo stesso tempo il metodo annotato e l'handler del metodo di richiesta con @ModelAttribute negli argomenti. Quindi dobbiamo unire le regole.

4. Naturalmente abbiamo tantissime situazioni diverse: i metodi @ModelAttribute possono anche essere definiti in un @ControllerAdvice e così via ...

So di essere in ritardo alla festa, ma citerò come si suol dire "meglio essere in ritardo che mai". Quindi andiamo avanti, ognuno ha i propri modi per spiegare le cose, lasciami provare a riassumere e semplificare per te in pochi passi con un esempio; Supponiamo di avere un modulo semplice, 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" Questi sono i campi / proprietà in StudentClass quando viene chiamato il modulo vengono chiamati i loro getter ma una volta inviati vengono chiamati i loro setter e i loro valori sono impostati nel bean indicato nel modelloAttribute = "studente" nel tag del modulo.

Abbiamo StudentController che include i seguenti metodi;

@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 

ora finalmente abbiamo un form-details.jsp

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

Quindi torna alla domanda Cos'è @ModelAttribute in Spring MVC? Una definizione campione dalla fonte per voi, http://www.baeldung.com/spring-mvc-and-the-modelattribute-annotation Il @ModelAttribute è un'annotazione che lega un parametro di metodo o di valore di ritorno metodo per un attributo di modello di nome e quindi lo espone a una visualizzazione Web.

Ciò che accade effettivamente è che ottiene tutti i valori del modulo che sono stati inviati da esso e li tiene per te per legarli o assegnarli all'oggetto. Funziona allo stesso modo di @RequestParameter in cui otteniamo solo un parametro e assegniamo il valore ad un campo. L'unica differenza è che @ModelAttribute contiene tutti i dati del modulo anziché un singolo parametro. Crea un bean per te che contiene i dati inviati dal modulo per essere successivamente utilizzati dallo sviluppatore.

Per ricapitolare il tutto. Passaggio 1: viene inviata una richiesta e il nostro metodo showForm viene eseguito e un modello, viene impostato un bean temporaneo con il nome studente viene inoltrato al modulo. theModel.addAttribute ("student", new Student ());

Passaggio 2: modelAttribute = "studente" sul modello di invio del modulo cambia lo studente e ora contiene tutti i parametri del modulo

Passaggio 3: @ModelAttribute ("studente") Studente theStudent Recuperiamo i valori mantenuti da @ModelAttribute e assegniamo l'intero bean / oggetto a Student.

Step 4: E poi lo usiamo mentre facciamo offerte, proprio come mostrarlo sulla pagina ecc. Come ho fatto io

Spero che ti aiuti a capire il concetto. Grazie

Prendi qualsiasi applicazione web che sia Gmail o Facebook o Instagram o qualsiasi altra applicazione web, si tratta di scambiare dati o informazioni tra l'utente finale e l'applicazione o l'interfaccia utente e l'applicazione back-end. Anche nel mondo Spring MVC ci sono due modi per scambiare dati:

1. dal controller all'interfaccia utente e
2. dall'interfaccia utente al controller.

Ciò che ci interessa qui è come i dati vengono comunicati dall'interfaccia utente al controller. Questo può anche essere fatto in 2 modi:

1. Utilizzando un modulo HTML
2. Utilizzo dei parametri della query.

Utilizzando un modulo HTML: considera lo scenario seguente,

Quando inviamo i dati del modulo dal browser Web, possiamo accedere a tali dati nella nostra classe Controller come oggetto. Quando inviamo un modulo HTML, Spring Container fa quattro cose. Lo farà,

1. prima leggi tutti i dati che vengono inviati nella richiesta usando il metodo request.getParameter .
2. una volta letti, li convertirà nel tipo Java appropriato usando integer.parseInt , double.parseDouble e tutti gli altri metodi di analisi disponibili in base al tipo di dati dei dati.
3. una volta analizzato, creerà un oggetto della classe del modello che abbiamo creato. Ad esempio, in questo scenario, sono le informazioni dell'utente che vengono inviate e creiamo una classe chiamata User, di cui il contenitore creerà un oggetto e imposterà tutti i valori che entrano automaticamente in quell'oggetto.
4. quindi consegnerà quell'oggetto impostando i valori sul Controller.

Per far funzionare tutto questo, dovremo seguire alcuni passaggi.

Dobbiamo innanzitutto definire una classe di modello, come Utente, in cui il numero di campi deve corrispondere esattamente al numero di campi nel modulo HTML. Inoltre, i nomi che utilizziamo nel modulo HTML dovrebbero corrispondere ai nomi che abbiamo nella classe Java. Questi due sono molto importanti. I nomi devono corrispondere, il numero di campi nel modulo deve corrispondere al numero di campi nella classe che creiamo. Una volta che lo facciamo, il Contenitore leggerà automaticamente i dati che arrivano, crea un oggetto di questo modello, imposta i valori e li passa al Controller. Per leggere quei valori all'interno del controller, utilizziamo @ModelAttributeannotazione sui parametri del metodo. Quando creiamo metodi nel Controller, useremo @ModelAttribute e vi aggiungeremo un parametro che avrà automaticamente questo oggetto dato dal Contenitore.

Ecco un esempio di codice per la registrazione di un utente:

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

Spero che questa spiegazione schematica abbia aiutato!

Viene utilizzato per scopi di associazione dei dati in primavera MVC. Lascia che tu abbia un jsp con un elemento form ad es

su JSP

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

(Metodo Spring Form, è possibile utilizzare anche un elemento modulo semplice)

Sul lato controller

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

}

Ora quando invierai il modulo, i valori dei campi del modulo saranno disponibili per te.

Annotazione che lega un parametro di metodo o un valore di ritorno metodo a un attributo modello denominato, esposto a una vista Web.

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

@ModelAttribute può essere utilizzato come argomento / parametro del metodo o prima della dichiarazione del metodo. L'obiettivo principale di questa annotazione è di associare i parametri della richiesta o i campi modulo a un oggetto modello

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

@ModelAttributecreerà un attributo con il nome da te (@ModelAttribute("Testing") Test test) as Testing specificato nell'esempio dato, Test essendo il bean test come riferimento al bean e Test sarà disponibile nel modello in modo da poterlo utilizzare ulteriormente sulle pagine jsp per il recupero dei valori memorizzati in te ModelAttribute.

@ModelAttribute associa semplicemente il valore dai campi jsp ai calss Pojo per eseguire la nostra logica nella classe controller. Se hai familiarità con i montanti, allora è come popolare l'oggetto formbean al momento dell'invio.

L'annotazione ModelAttribute viene utilizzata come parte di un'applicazione Web Spring MVC e può essere utilizzata in due scenari.

Innanzitutto, può essere utilizzato per iniettare dati in un modello di carico pre-JSP. Ciò è particolarmente utile per garantire che sia necessario un JSP per visualizzare tutti i dati stessi. Si ottiene un'iniezione collegando un metodo al modello.

In secondo luogo, può essere utilizzato per leggere i dati da un modello esistente e assegnarli ai parametri del metodo del coach.

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

A livello di metodo

1.Quando l'annotazione viene utilizzata a livello di metodo, indica che lo scopo di tale metodo è quello di aggiungere uno o più attributi del modello

@ModelAttribute
public void addAttributes(Model model) {
model.addAttribute("india", "india");
}

Argomento del metodo 1. Se utilizzato come argomento del metodo, indica che l'argomento deve essere recuperato dal modello. Quando non presenti e dovrebbero essere prima istanziati e quindi aggiunti al modello e una volta presenti nel modello, i campi degli argomenti dovrebbero essere popolati da tutti i parametri di richiesta che hanno nomi corrispondenti Quindi, lega i dati del modulo con un bean.

 @RequestMapping(value = "/addEmployee", method = RequestMethod.POST)
  public String submit(@ModelAttribute("employee") Employee employee) {
  return "employeeView";
  }