Qual è @ModelAttribute in Spring MVC?
https://stackoverflow.com/questions/3423262
-
26-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Qual è lo scopo e l'utilizzo di @ModelAttribute in Spring MVC?
Soluzione
@ModelAttribute si riferisce ad una proprietà dell'oggetto Modello (M in MVC;)
Quindi diciamo che abbiamo un modulo con un oggetto form supporto che si chiama "Persona"
Allora si può avere Spring MVC fornire questo oggetto a un metodo di controllo utilizzando l'annotazione @ModelAttribute:
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. Quindi, se si vuole avere un oggetto Person si fa 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 vostra vista, dal momento che viene automaticamente aggiunto ai modelli entro la primavera.
Vedere " Utilizzo @ModelAttribute ".
Altri suggerimenti
So che questo è un vecchio thread, ma ho pensato che mi passi il mio cappello sul ring e vedere se riesco a intorbidire l'acqua un po 'di più:)
Ho trovato la mia lotta iniziale per capire @ModelAttribute è stato il risultato della decisione di primavera di combinare diversi annotazioni in uno solo. E 'diventato più chiaro una volta ho diviso in varie annotazioni più piccoli:
Per le annotazioni dei parametri, pensare @ModelAttribute come l'equivalente di @Autowired + @Qualifier cioè si tenta di recuperare un fagiolo con il nome dato dal modello primavera gestito. Se il fagiolo di nome non viene trovato, invece di lanciare un errore o di ritorno null, ci vuole implicitamente il ruolo di @Bean vale a dire creare una nuova istanza utilizzando il costruttore predefinito e aggiungere il fagiolo al modello.
Per metodo annotazioni, pensare @ModelAttribute come equivalente @Bean + @Before, cioè esso mette il fagiolo costruito dal codice utente nel modello ed è sempre chiamato prima della richiesta metodo di movimentazione.
In senso figurato, vedo @ModelAttribute come la seguente (si prega di non prendere letteralmente !!):
@Bean("person")
@Before
public Person createPerson(){
return new Person();
}
@RequestMapping(...)
public xxx handlePersonRequest( (@Autowired @Qualifier("person") | @Bean("person")) Person person, xxx){
...
}
Come si può vedere, Primavera ha preso la decisione giusta per fare @ModelAttribute un'annotazione totalizzante; nessuno vuole vedere un ricco buffet di annotazione.
Per il mio stile, io uso sempre @ModelAttribute per oggetto fermo dalla forma primavera jsp. per esempio, io disegno modulo a pagina JSP, che forma esistere con CommandName
<form:form commandName="Book" action="" methon="post">
<form:input type="text" path="title"></form:input>
</form:form>
e prendere l'oggetto sul controller con il codice di follow
public String controllerPost(@ModelAttribute("Book") Book book)
ed ogni nome di campo di prodotto deve essere partita con percorso nel sub-elemento della forma
Quindi, cercherò di 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 Spring MVC - @ModelAttribute annotazione può essere utilizzato su Metodi o Metodo di argomenti . E naturalmente si può avere sia per uso al tempo stesso in un controller.
1. Metodo annotazione
@ModelAttribute(“cities”)
public List<String> checkOptions(){
return new Arrays.asList(new[]{“Sofia”,”Pleven","Ruse”});//and so on
}
Scopo di tale metodo è quello di aggiungere l'attributo nel modello. Quindi, nel nostro caso città chiave avranno la lista new Arras.asList(new[]{“Sofia”,”Pleven","Ruse”}) come valore nel modello (si può pensare di modello come mappa (chiave: value)). @ModelAttribute metodi in un controller vengono richiamati prima @RequestMapping metodi, all'interno dello stesso controllore.
Qui vogliamo aggiungere alla Common Information Model che verrà utilizzato il modulo per mostrare all'utente. Ad esempio può essere utilizzato per riempire un HTML selezionare:
argomento 2.METODO
public String findPerson(@ModelAttriute(value="person") Person person) {
//..Some logic with person
return "person.jsp";
}
Un @ModelAttribute su un argomento metodo indica l'argomento dovrebbe essere recuperate dal modello. Quindi, in questo caso ci aspettiamo che abbiamo nel modello persona oggetto come chiave e vogliamo ottenere il suo valore e metterlo all'argomento metodo di persona persona . Se tale non esiste o (a volte si misspell il (value = "Persson")) poi molla non troverete nel modello e creerà oggetto Person vuoto utilizzando le impostazioni predefinite. Poi prenderà i parametri di richiesta e cercare di dati li legano nell'oggetto persona utilizzando i loro nomi.
name="Dmitrij"&countries=Lesoto&sponsor.organization="SilkRoad"&authorizedFunds=&authorizedHours=&
Quindi abbiamo nome e sarà legano a Person.name utilizzando setName (String name). Quindi, in
//..Some logic with person
abbiamo accesso a questo nome pieno di valore "Dimitrij".
Naturalmente primavera può legare gli oggetti più complessi come liste, mappe, Lista di serie di mappe e così via, ma dietro le quinte che rende i dati magia vincolante.
-
può avere al gestore di metodo e il metodo di richiesta annotato stesso modello tempo con @ModelAttribute negli argomenti. Poi dobbiamo unione delle regole.
-
Naturalmente abbiamo tonnellate di situazioni diverse - metodi @ModelAttribute possono anche essere definiti in un @ControllerAdvice e così via ...
Lo so, sono in ritardo alla festa, ma io cito come si suol dire, "Meglio tardi che mai". Cerchiamo quindi di andare avanti, Ognuno ha i propri modi di spiegare le cose, vorrei provare a riassumere e semplice per voi in pochi passi con un esempio; Supponiamo di avere una forma 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 = "Cognome" Questi sono i campi / proprietà nella StudentClass quando il modulo viene chiamato loro getter sono chiamati ma una volta che hanno presentato le loro setter sono chiamate ed i loro valori sono impostati nel chicco che è stato indicato nel modelAttribute = "studente" nel tag form.
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 una forma-details.jsp
<b>Student Information</b>
${student.firstName}
${student.lastName}
Quindi, tornando alla domanda Che cosa è @ModelAttribute in Spring MVC? Una definizione campione dalla fonte per voi, http://www.baeldung.com/spring-mvc-and- the-modelattribute-annotazione Il @ModelAttribute è un'annotazione che lega un parametro di metodo o di valore di ritorno metodo per un attributo di modello di nome e poi lo espone a una visualizzazione web.
Quello che accade è che ottiene tutti i valori del modulo quelli sono stati da essa fornite e poi li tiene per voi di associare o assegnarli all'oggetto. Funziona stessa come la @RequestParameter , dove abbiamo solo un parametro e assegniamo il valore di qualche campo. L'unica differenza è @ModelAttribute tiene tutti i dati di un modulo piuttosto che un singolo parametro. Si crea un fagiolo per te, che detiene modulo inviato i dati per essere utilizzato dallo sviluppatore in seguito.
Per ricapitolare il tutto. Passo 1 : Una richiesta viene inviata e le nostre piste ShowForm metodo e un modello, un fagiolo temporanea viene impostata con lo studente nome viene trasmesso al modulo. theModel.addAttribute ( "studente", nuova Student ());
Passaggio 2: modelAttribute = "studente" sul modello di invio del modulo cambia lo studente e ora detiene tutti i parametri del modulo
Passo 3: @ModelAttribute ( "studente") Studente theStudent Abbiamo recuperare i valori in attesa da @ModelAttribute e assegnare l'intero chicco / oggetto a studente.
Passo 4: E poi lo usiamo come noi offerta, proprio come mostrando in prima pagina, ecc come ho fatto
spero che aiuta a capire il concetto. Grazie
Prendere qualsiasi applicazione web che si tratti di Gmail o Facebook o Instagram o qualsiasi altra applicazione web, è tutta una questione lo scambio di dati o di informazioni tra l'utente finale e l'applicazione o l'interfaccia utente e l'applicazione back-end. Anche in Spring MVC mondo ci sono due modi per scambiare dati:
- dal controller per l'interfaccia utente, e
- dall'interfaccia utente al controllore.
Quello che ci interessa qui è come i dati sono comunicati dall'interfaccia utente al controller. Questo può anche essere fatto in 2 modi:
- L'utilizzo di un modulo HTML
- Utilizzo dei parametri query.
Utilizzando un modulo HTML: Si consideri il sottostante scenario,
Quando sottoponiamo i dati del modulo dal browser web, siamo in grado di accedere ai dati nella nostra classe Controller come un oggetto. Quando inviamo un modulo HTML, la primavera Container fa quattro cose. Sarà,
- prima di leggere tutti i dati che vengono presentati che viene nella richiesta utilizzando il request.getParameter metodo.
- una volta che li legge, sarà convertirli nel tipo Java appropriato utilizzando Integer.parseInt , double.parseDouble e tutti gli altri metodi di parsing che sono disponibili sulla base di il tipo di dati dei dati.
- una volta analizzato, si creerà un oggetto della classe del modello che abbiamo creato. Ad esempio, in questo scenario, è l'informazione dell'utente che viene presentato e creiamo una classe chiamata dell'utente, che il contenitore creerà un oggetto di e sarà impostare tutti i valori che vengono automaticamente in quell'oggetto.
- lo farà allora handover quell'oggetto impostando i valori al controllore.
Per ottenere tutta questa cosa al lavoro, dovremo seguire alcuni passaggi.
Per prima cosa è necessario definire una classe modello, come d'uso, in cui il numero di campi dovrebbe corrispondere esattamente al numero di campi nel modulo HTML. Inoltre, i nomi che usiamo nel modulo HTML devono corrispondere i nomi che abbiamo in classe Java. Questi due sono molto importanti. I nomi dovrebbero corrispondere, il numero di campi nella forma dovrebbe corrispondere al numero di campi nella classe che creiamo. Una volta che lo facciamo, il contenitore leggerà automaticamente i dati che entra, crea un oggetto di questo modello, imposta i valori e lo consegna al controllore. Per leggere questi valori all'interno del controllore, usiamo il @ModelAttribute annotazioni sui parametri di metodo. Quando creiamo metodi nel controller, ci accingiamo a utilizzare il @ModelAttribute e aggiungere un parametro ad essa che avrà automaticamente questo oggetto proposta dal contenitore.
Ecco un codice di esempio 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 questo spiegazione schematica aiutato!
Questo è usato per i dati scopi nella primavera MVC vincolanti. Ti permettono di avere un jsp avere un elemento del modulo in esso per esempio
sulle
JSP
<form:form action="test-example" method="POST" commandName="testModelAttribute"> </form:form>
(metodo Primavera forma, semplice elemento di modulo può essere utilizzato anche)
su lato controllore
@RequestMapping(value = "/test-example", method = RequestMethod.POST)
public ModelAndView testExample(@ModelAttribute("testModelAttribute") TestModel testModel, Map<String, Object> map,...) {
}
Ora, quando si inviare il modulo i valori dei campi modulo sarà a vostra disposizione.
annotazione che lega un parametro di metodo o il valore di ritorno del metodo per un attributo di modello di nome, esposti ad una visione web.
public String add(@ModelAttribute("specified") Model model) {
...
}
@ModelAttribute può essere utilizzato come metodo di argomenti / parametro o prima della dichiarazione metodo. L'obiettivo primario di questa annotazione di legare i parametri di richiesta o campi del modulo a un oggetto del modello
@ModelAttribute creerà un attributo con il nome specificato dall'utente (@ModelAttribute("Testing") Test test) as Testing nell'esempio dato, Test essendo il test di fagioli essendo il riferimento al chicco e test sarà disponibile nel modello in modo che è possibile utilizzare ulteriormente sulle pagine JSP per il recupero di valori che è memorizzato in voi ModelAttribute.
@ModelAttribute si lega semplicemente il valore dai campi JSP per Pojo calss a svolgere la nostra logica nella classe controller. Se si ha familiarità con puntoni, allora questo è come popolano l'oggetto FormBean al momento della presentazione.
L'annotazione ModelAttribute viene utilizzato come parte di un'applicazione Web Spring MVC e può essere utilizzato in due scenari.
Innanzitutto, esso può essere utilizzato per iniettare dati in un modello di carico pre-JSP. Ciò è particolarmente utile per garantire che un JSP è necessaria per visualizzare tutti i dati stessi. Un'iniezione si ottiene collegando un metodo per il modello.
In secondo luogo, esso può essere utilizzato per leggere i dati da un modello esistente e assegnarlo ai parametri del metodo del coach.
