Spring MVC en de @ModelAttribute-annotatie

1. Overzicht

Een van de belangrijkste Spring-MVC-annotaties is de @ModelAttribute-annotatie.

De @ModelAttribute is een annotatie die een methodeparameter of methode-retourwaarde bindt aan een benoemd modelattribuut en deze vervolgens blootstelt aan een webweergave.

In het volgende voorbeeld zullen we de bruikbaarheid en functionaliteit van de annotatie demonstreren door middel van een gemeenschappelijk concept: een formulier dat is ingediend door de werknemer van een bedrijf.

2. Het @ModelAttribute diepgaand

Zoals de inleidende paragraaf onthulde, @ModelAttribute kan worden gebruikt als methodeparameter of op methodeniveau.

2.1 Op het niveau van de methode

Wanneer de annotatie wordt gebruikt op het niveau van de methode, geeft dit aan dat het doel van die methode is om een ​​of meer modelattributen toe te voegen. Dergelijke methoden ondersteunen dezelfde argumenttypen als @RequestMapping-methoden, maar die kunnen niet rechtstreeks aan verzoeken worden toegewezen.

Laten we hier een snel voorbeeld bekijken om te begrijpen hoe dit werkt:

@ModelAttribute public void addAttributes (Modelmodel) {model.addAttribute ("msg", "Welkom in Nederland!"); } 

In het voorbeeld laten we een methode zien die een attribuut met de naam toevoegt msg aan iedereen model-s gedefinieerd in de controller-klasse.

Natuurlijk zullen we dit later in het artikel in actie zien.

In het algemeen zal Spring-MVC altijd eerst die methode aanroepen, voordat het enige aanvraagbehandelingsmethoden aanroept. Dat is, @ModelAttribute methoden worden aangeroepen voordat de controllermethoden worden geannoteerd met @RequestMapping worden ingeroepen. De logica achter de reeks is dat het modelobject moet worden gemaakt voordat de verwerking begint binnen de controllermethoden.

Het is ook belangrijk dat u de respectieve klasse annoteert als @ControllerAdvice. U kunt dus waarden toevoegen in Model die zal worden geïdentificeerd als globaal. Dit betekent eigenlijk dat voor elk verzoek een standaardwaarde bestaat, voor elke methode in het antwoordgedeelte.

2.2 Als methode-argument

Als het als methode-argument wordt gebruikt, geeft het aan dat het argument uit het model moet worden opgehaald. Als het niet aanwezig is, moet het eerst worden geïnstantieerd en vervolgens aan het model worden toegevoegd. Als het eenmaal aanwezig is in het model, moeten de argumentenvelden worden gevuld met alle verzoekparameters die overeenkomende namen hebben.

In het codefragment dat volgt op het werknemer modelattribuut wordt gevuld met gegevens van een formulier dat is ingediend bij de addEmployee eindpunt. Spring MVC doet dit achter de schermen voordat de verzendmethode wordt aangeroepen:

@RequestMapping (value = "/ addEmployee", method = RequestMethod.POST) public String submit (@ModelAttribute ("employee") Werknemer werknemer) {// Code die het werknemerobject retour "employeeView" gebruikt; }

Verderop in dit artikel zullen we een compleet voorbeeld zien van het gebruik van de werknemer object om het employeeView sjabloon.

Het bindt dus de formuliergegevens met een boon. De controller heeft geannoteerd met @RequestMapping kunnen aangepaste klasseargument (en) hebben die zijn geannoteerd met @ModelAttribute.

Dit is wat algemeen bekend staat als gegevensbinding in Spring-MVC, een algemeen mechanisme waarmee u niet elk formulierveld afzonderlijk hoeft te parseren.

3. Formuliervoorbeeld

In deze sectie zullen we het voorbeeld geven waarnaar wordt verwezen in de overzichtsectie: een zeer eenvoudig formulier dat een gebruiker (werknemer van een bedrijf, in ons specifieke voorbeeld) ertoe aanzet om enkele persoonlijke gegevens in te voeren (in het bijzonder naam en ID kaart). Nadat de indiening is voltooid en zonder fouten, verwacht de gebruiker dat de eerder ingediende gegevens op een ander scherm worden weergegeven.

3.1 Het uitzicht

Laten we eerst een eenvoudig formulier maken met id- en naamvelden:

 Naam-ID 

3.2 De verantwoordelijke

Hier is de controller-klasse, waar de logica voor de bovengenoemde weergave wordt geïmplementeerd:

@Controller @ControllerAdvice openbare klasse EmployeeController {privékaart employeeMap = nieuwe HashMap (); @RequestMapping (value = "/ addEmployee", method = RequestMethod.POST) public String submit (@ModelAttribute ("employee") Werknemer werknemer, BindingResult resultaat, ModelMap model) {if (result.hasErrors ()) {return "error" ; } model.addAttribute ("naam", werknemer.getNaam ()); model.addAttribute ("id", employee.getId ()); employeeMap.put (employee.getId (), medewerker); retourneer "employeeView"; } @ModelAttribute public void addAttributes (Modelmodel) {model.addAttribute ("msg", "Welkom in Nederland!"); }}

In de indienen () methode hebben we een Werknemer object gebonden aan onze Visie. Zie je de kracht van deze annotatie? U kunt uw formuliervelden zo eenvoudig aan een objectmodel toewijzen. In de methode halen we waarden op uit het formulier en stellen we ze in op ModelMap.

Uiteindelijk keren we terug employeeView, wat betekent dat het respectieve JSP-bestand wordt aangeroepen als een Visie vertegenwoordiger.

Verder is er ook een addAttributes () methode. Het doel is om waarden toe te voegen in de Model die wereldwijd zullen worden geïdentificeerd. Dat wil zeggen dat er een standaardwaarde wordt geretourneerd als antwoord voor elk verzoek aan elke controllermethode. We moeten ook de specifieke klasse annoteren als @ControllerAdvice.

3.3 Het model

Zoals eerder vermeld, de Model object is erg simplistisch en bevat alles wat nodig is voor de "front-end" attributen. Laten we nu een voorbeeld bekijken:

@XmlRootElement openbare klasse Werknemer {privé lange id; private String naam; openbare werknemer (lange id, tekenreeksnaam) {this.id = id; this.name = naam; } // standaard getters en setters verwijderd}

3.4 Afronding

De @ControllerAdvice assisteert een controller en in het bijzonder, @ModelAttribute methoden die voor iedereen gelden @RequestMapping methoden. Natuurlijk, onze addAttributes () methode zal de allereerste zijn die wordt uitgevoerd, voorafgaand aan de rest van de @RequestMapping methoden.

Dat in gedachten houdend en na beide indienen () en addAttributes () worden uitgevoerd, kunnen we er gewoon naar verwijzen in de Visie keerde terug van de Controller klasse, door hun voornaam te noemen in een duo met accolades in dollars, zoals bijvoorbeeld $ {naam}.

3.5 Resultatenweergave

Laten we nu afdrukken wat we van het formulier hebben ontvangen:

$ {msg}

Naam: $ {name} ID: $ {id}

4. Conclusie

In deze tutorial hebben we het gebruik van @ModelAttribute annotatie, voor zowel methode-argumenten als gebruikssituaties op methode-niveau.

De implementatie van deze eenvoudige tutorial is te vinden in het github-project.