Introduzione ai moduli in Spring MVC

1. Panoramica

In questo articolo, discuteremo i moduli Spring e l'associazione dei dati a un controller. Inoltre, daremo uno sguardo a una delle annotazioni principali in Spring MVC, ovvero @ModelAttribute .

Naturalmente, Spring MVC è un argomento complesso con molte cose che devi capire per usarlo al massimo delle sue potenzialità, quindi approfondisci qui il framework.

2. Il modello

Innanzitutto, definiamo un'entità semplice che visualizzeremo e assoceremo al modulo:

public class Employee { private String name; private long id; private String contactNumber; // standard getters and setters }

Questo sarà il nostro oggetto di supporto del modulo.

3. La vista

Successivamente, definiamo il modulo effettivo e, naturalmente, il file HTML che lo contiene. Utilizzeremo una pagina in cui viene creato / registrato un nuovo dipendente:

Welcome, Enter The Employee Details

Name
Id
Contact Number

Innanzitutto, nota che stiamo includendo una libreria di tag nella nostra pagina JSP - il modulo taglib - per aiutare a definire il nostro modulo.

Avanti: il il tag gioca un ruolo importante qui; è molto simile al normale HTLMtag ma l' attributo modelAttribute è la chiave che specifica un nome dell'oggetto del modello che supporta questa forma:

Questo corrisponderà a @ModelAttribute più avanti nel controller.

Avanti - ogni campo di input utilizza ancora un altro tag utile dal taglib di Spring Form - form: prefix . Ciascuno di questi campi specifica un attributo di percorso : questo deve corrispondere a un getter / setter dell'attributo del modello (in questo caso, la classe Employee). Quando la pagina viene caricata, i campi di input vengono popolati da Spring, che chiama il getter di ogni campo associato a un campo di input. Quando il modulo viene inviato, i setter vengono chiamati per salvare i valori del modulo nell'oggetto.

Infine, quando il modulo viene inviato , viene richiamato il gestore POST nel controller e il modulo viene automaticamente associato all'argomento dipendente che abbiamo passato.

4. Il Titolare

Ora, diamo un'occhiata al controller che gestirà il back-end:

@Controller public class EmployeeController { @RequestMapping(value = "/employee", method = RequestMethod.GET) public ModelAndView showForm() { return new ModelAndView("employeeHome", "employee", new Employee()); } @RequestMapping(value = "/addEmployee", method = RequestMethod.POST) public String submit(@Valid @ModelAttribute("employee")Employee employee, BindingResult result, ModelMap model) { if (result.hasErrors()) { return "error"; } model.addAttribute("name", employee.getName()); model.addAttribute("contactNumber", employee.getContactNumber()); model.addAttribute("id", employee.getId()); return "employeeView"; } }

Il controller definisce due semplici operazioni: il GET per la visualizzazione dei dati nel modulo e il POST per l'operazione di creazione, tramite l'invio del modulo.

Si noti inoltre che se l'oggetto chiamato "dipendente" non viene aggiunto al modello, Spring si lamenterebbe quando proviamo ad accedere al JSP perché il JSP verrà impostato per associare il modulo all'attributo del modello "dipendente":

java.lang.IllegalStateException: Neither BindingResult nor plain target object for bean name 'employee' available as request attribute at o.s.w.s.s.BindStatus.(BindStatus.java:141) 

Per accedere al nostro oggetto di supporto del modulo, dobbiamo iniettarlo tramite l' annotazione @ModelAttribute .

Un @ModelAttribute argomento su un metodo indica che l'argomento verrà recuperato dal modello. Se non è presente nel modello, l'argomento verrà prima istanziato e poi aggiunto al modello.

5. Gestione degli errori di binding

Per impostazione predefinita, Spring MVC genera un'eccezione quando si verificano errori durante l'associazione della richiesta. Questo di solito non è quello che vogliamo, invece, dovremmo presentare questi errori all'utente. Useremo un BindingResult aggiungendone uno come argomento al nostro metodo controller:

public String submit( @Valid @ModelAttribute("employee") Employee employee, BindingResult result, ModelMap model)

L' argomento BindingResult deve essere posizionato subito dopo il nostro oggetto di supporto del modulo: è uno dei rari casi in cui l'ordine degli argomenti del metodo è importante. Altrimenti, ci imbatteremo nella seguente eccezione:

java.lang.IllegalStateException: Errors/BindingResult argument declared without preceding model attribute. Check your handler method signature!

Ora, non viene più lanciata un'eccezione; gli errori verranno invece registrati nel BindingResult passato al metodo submit . A questo punto, possiamo gestire questi errori in vari modi, ad esempio l'operazione può essere annullata:

@RequestMapping(value = "/addEmployee", method = RequestMethod.POST) public String submit(@Valid @ModelAttribute("employee")Employee employee, BindingResult result, ModelMap model) { if (result.hasErrors()) { return "error"; } //Do Something return "employeeView"; }

Notare come, nel caso in cui il risultato contenga errori, restituiamo all'utente un'altra visualizzazione per visualizzare correttamente questi errori. Diamo un'occhiata a quella vista - error.jsp :

Please enter the correct details

Retry

6. Visualizzazione di un dipendente

Infine, oltre a creare un nuovo dipendente, possiamo anche semplicemente visualizzarne uno: ecco il codice di visualizzazione rapida per questo:

Submitted Employee Information

Name : ${name}
ID : ${id}
Contact Number : ${contactNumber}

La pagina JSP utilizza semplicemente espressioni EL per visualizzare i valori delle proprietà dell'oggetto Employee nel modello.

7. Test dell'applicazione

La semplice applicazione può essere distribuita, ad esempio in un server Tomcat, e accessibile localmente:

// localhost: 8080 / spring-mvc-xml / dipendente

Questa è la vista contenente il form principale - prima dell'operazione di invio:

Esempio di modulo Spring MVC - Invia

Dopo l'invio, vengono visualizzati i dati:

Esempio di modulo Spring MVC - Visualizza

E questo è tutto: un esempio funzionante di un modulo semplice con Spring MVC, con convalida .

L'implementazione di questo tutorial Spring MVC può essere trovata nel progetto GitHub: questo è un progetto basato su Maven, quindi dovrebbe essere facile da importare ed eseguire così com'è.

Infine, come stavo dicendo all'inizio dell'articolo, dovresti assolutamente approfondire Spring MVC.