Spring MVC et l'annotation @ModelAttribute

1. Vue d'ensemble

L'une des annotations Spring-MVC les plus importantes est l'annotation @ModelAttribute.

Le @ModelAttribute est une annotation qui se lie à un paramètre de procédé ou de la valeur de retour de la méthode à un attribut de modèle appelé et il expose ensuite à une vue Web.

Dans l'exemple suivant, nous démontrerons la convivialité et la fonctionnalité de l'annotation, à travers un concept commun: un formulaire soumis par un employé d'une entreprise.

2. Le @ModelAttribute en détail

Comme l'a révélé le paragraphe d'introduction, @ModelAttribute peut être utilisé soit comme paramètre de méthode, soit au niveau de la méthode.

2.1 Au niveau de la méthode

Lorsque l'annotation est utilisée au niveau de la méthode, elle indique que le but de cette méthode est d'ajouter un ou plusieurs attributs de modèle. Ces méthodes prennent en charge les mêmes types d'arguments que les méthodes @RequestMapping mais qui ne peuvent pas être mappées directement aux requêtes.

Jetons un coup d'œil à un exemple rapide ici pour commencer à comprendre comment cela fonctionne:

@ModelAttribute public void addAttributes(Model model) { model.addAttribute("msg", "Welcome to the Netherlands!"); } 

Dans l'exemple, nous montrons une méthode qui ajoute un attribut nommé msg à tous les modèles définis dans la classe de contrôleur.

Bien sûr, nous verrons cela en action plus tard dans l'article.

En général, Spring-MVC effectuera toujours un appel d'abord à cette méthode, avant d'appeler des méthodes de gestionnaire de requêtes. Autrement dit, les méthodes @ModelAttribute sont appelées avant que les méthodes de contrôleur annotées avec @RequestMapping soient appelées. La logique derrière la séquence est que l'objet modèle doit être créé avant que tout traitement ne démarre dans les méthodes du contrôleur.

Il est également important que vous annotiez la classe respective en tant que @ControllerAdvice. Ainsi, vous pouvez ajouter des valeurs dans Model qui seront identifiées comme globales. Cela signifie en fait que pour chaque requête, une valeur par défaut existe, pour chaque méthode de la partie réponse.

2.2 En tant qu'argument de méthode

Lorsqu'il est utilisé comme argument de méthode, il indique que l'argument doit être récupéré du modèle. Lorsqu'il n'est pas présent, il doit d'abord être instancié, puis ajouté au modèle et une fois présent dans le modèle, les champs d'arguments doivent être remplis à partir de tous les paramètres de demande qui ont des noms correspondants.

Dans l'extrait de code qui suit, l' attribut de modèle d' employé est rempli avec les données d'un formulaire soumis au point de terminaison addEmployee . Spring MVC fait cela dans les coulisses avant d'appeler la méthode de soumission:

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

Plus loin dans cet article, nous verrons un exemple complet d'utilisation de l' objet employé pour remplir le modèle employeeView .

Ainsi, il lie les données du formulaire avec un bean. Le contrôleur annoté avec @RequestMapping peut avoir des arguments de classe personnalisés annotés avec @ModelAttribute .

C'est ce que l'on appelle communément la liaison de données dans Spring-MVC, un mécanisme commun qui vous évite d'avoir à analyser chaque champ de formulaire individuellement.

3. Exemple de formulaire

Dans cette section, nous fournirons l'exemple mentionné dans la section vue d'ensemble: un formulaire très basique qui invite un utilisateur (employé d'une entreprise, dans notre exemple spécifique), à ​​saisir certaines informations personnelles (en particulier le nom et l' identifiant). Une fois la soumission terminée et sans aucune erreur, l'utilisateur s'attend à voir les données précédemment soumises, affichées sur un autre écran.

3.1 La vue

Commençons par créer un formulaire simple avec des champs id et name:

 Name  Id    

3.2 Le contrôleur

Voici la classe de contrôleur, où la logique de la vue mentionnée ci-dessus est implémentée:

@Controller @ControllerAdvice public class EmployeeController { private Map employeeMap = new HashMap(); @RequestMapping(value = "/addEmployee", method = RequestMethod.POST) public String submit( @ModelAttribute("employee") Employee employee, BindingResult result, ModelMap model) { if (result.hasErrors()) { return "error"; } model.addAttribute("name", employee.getName()); model.addAttribute("id", employee.getId()); employeeMap.put(employee.getId(), employee); return "employeeView"; } @ModelAttribute public void addAttributes(Model model) { model.addAttribute("msg", "Welcome to the Netherlands!"); } }

Dans la méthode submit () , nous avons un objet Employee lié à notre View . Pouvez-vous voir la puissance de cette annotation? Vous pouvez mapper vos champs de formulaire à un modèle objet aussi simplement que cela. Dans la méthode, nous récupérons les valeurs du formulaire et les définissons sur ModelMap .

À la fin, nous retournons employeeView , ce qui signifie que le fichier JSP correspondant sera appelé en tant que représentant View .

De plus, il existe également une méthode addAttributes () . Son but est d'ajouter des valeurs dans le modèle qui seront identifiées globalement. Autrement dit, une valeur par défaut sera renvoyée en tant que réponse pour chaque requête adressée à chaque méthode de contrôleur. Nous devons également annoter la classe spécifique comme @ControllerAdvice .

3.3 Le modèle

Comme mentionné précédemment, l' objet Model est très simpliste et contient tout ce qui est requis par les attributs «front-end». Maintenant, regardons un exemple:

@XmlRootElement public class Employee { private long id; private String name; public Employee(long id, String name) { this.id = id; this.name = name; } // standard getters and setters removed }

3.4 Récapitulation

Le @ControllerAdvice assiste un contrôleur et en particulier les méthodes @ModelAttribute qui s'appliquent à toutes les méthodes @RequestMapping . Bien sûr, notre méthode addAttributes () sera la toute première à s'exécuter, avant le reste des méthodes @RequestMapping .

En gardant cela à l'esprit et après l' exécution de submit () et addAttributes () , nous pourrions simplement nous y référer dans la vue renvoyée par la classe Controller , en mentionnant leur nom dans un duo d'accolades dollarisé, comme par exemple $ {nom} .

3.5 Affichage des résultats

Imprimons maintenant ce que nous avons reçu du formulaire:

${msg}

Name : ${name} ID : ${id}

4. Conclusion

Dans ce didacticiel, nous avons étudié l'utilisation de l' annotation @ModelAttribute , à la fois pour les arguments de méthode et les cas d'utilisation au niveau de la méthode .

L'implémentation de ce tutoriel simple se trouve dans le projet github.