Qu'est-ce que @ModelAttribute dans Spring MVC?
Quel est le but et l'utilisation de @ModelAttribute dans Spring MVC?
@ModelAttribute fait référence à une propriété de l'objet Model (le M dans MVC;) Nous avons donc un formulaire avec un objet de protection de formulaire appelé "Personne" Vous pouvez alors avoir Spring MVC fournissez cet objet à une méthode Controller à l'aide de l'annotation @ModelAttribute:
public String processForm(@ModelAttribute("person") Person person){
person.getStuff();
}
Consultez ici pour un exemple (Spring 2.5), voir aussi "Utilisation de @ModelAttribute sur un argument de méthode" (Spring 3.1).
D'autre part, l'annotation est utilisée pour définir des objets qui devraient faire partie d'un modèle . Ainsi, si vous souhaitez qu'un objet Personne soit référencé dans le modèle, vous pouvez utiliser la méthode suivante:
@ModelAttribute("person")
public Person getPerson(){
return new Person();
}
Cette méthode annotée permettra l'accès à l'objet Personne dans votre vue, car il est automatiquement ajouté aux modèles par Spring.
Voir "Utilisation de @ModelAttribute sur une méthode" (Spring 3.1).
J'espère que cela a aidé.
Je sais que c'est un vieux fil, mais je pensais jeter mon chapeau dans le ring et voir si je pouvais brouiller un peu l'eau un peu plus :)
J'ai trouvé que ma lutte initiale pour comprendre @ModelAttribute était le résultat de la décision de Spring de combiner plusieurs annotations en une. Cela est devenu plus clair une fois que je l'ai scindé en plusieurs annotations plus petites:
Pour les annotations de paramètres, considérez @ModelAttribute comme l’équivalent de @Autowired + @Qualifier, c’est-à-dire qu’il essaie de récupérer un bean portant le nom donné à partir du modèle géré Spring. Si le bean nommé n'est pas trouvé, au lieu de générer une erreur ou de renvoyer null, il assume implicitement le rôle de @Bean, à savoir créer une nouvelle instance à l'aide du constructeur par défaut et ajouter le bean au modèle.
Pour les annotations de méthode, pensez à @ModelAttribute comme l’équivalent de @Bean + @Before, c’est-à-dire qu’il place le bean construit par le code de l’utilisateur dans le modèle et qu’il est toujours appelé avant une méthode de traitement des demandes.
Au sens figuré, je vois @ModelAttribute comme ceci (s'il vous plaît, ne le prenez pas littéralement !!):
@Bean("person")
@Before
public Person createPerson(){
return new Person();
}
@RequestMapping(...)
public xxx handlePersonRequest( (@Autowired @Qualifier("person") | @Bean("person")) Person person, xxx){
...
}
Comme vous pouvez le constater, Spring a pris la bonne décision de faire de @ModelAttribute une annotation complète; personne ne veut voir un smorgasbord d'annotation.
Pour mon style, j'utilise toujours @ModelAttribute pour attraper un objet de la forme printanière jsp. par exemple, je conçois un formulaire sur une page jsp, ce formulaire existe avec commandName
<form:form commandName="Book" action="" methon="post">
<form:input type="text" path="title"></form:input>
</form:form>
et j'attrape l'objet sur le contrôleur avec le code de suivi
public String controllerPost(@ModelAttribute("Book") Book book)
et chaque nom de champ du livre doit correspondre à path dans un sous-élément de la forme
Je vais donc essayer de l'expliquer d'une manière plus simple. Ayons:
public class Person {
private String name;
public String getName() {
return name;
}
public void setName(final String name) {
this.name = name;
}
}
Comme décrit dans la documentation Spring MVC, l'annotation @ModelAttribute peut être utilisée sur méthodes ou sur arguments de méthode. Et bien sûr, nous pouvons utiliser les deux en même temps dans un contrôleur.
Annotation 1.Method
@ModelAttribute(“cities”)
public List<String> checkOptions(){
return new Arrays.asList(new[]{“Sofia”,”Pleven","Ruse”});//and so on
}
Le but de cette méthode est d’ajouter un attribut dans le modèle. Ainsi, dans notre cas, la clé villes aura la liste new Arras.asList(new[]{“Sofia”,”Pleven","Ruse”}) comme valeur dans le modèle (vous pouvez considérer le modèle comme une carte (clé: valeur)). Les méthodes @ModelAttribute d'un contrôleur sont appelées avant les méthodes @RequestMapping, au sein du même contrôleur.
Ici, nous voulons ajouter au modèle des informations communes qui seront utilisées dans le formulaire pour être affichées à l'utilisateur. Par exemple, il peut être utilisé pour remplir une sélection HTML:
Argument 2.Method
public String findPerson(@ModelAttriute(value="person") Person person) {
//..Some logic with person
return "person.jsp";
}
Un @ModelAttribute sur un argument de méthode indique que l'argument doit être extrait du modèle. Ainsi, dans ce cas, nous nous attendons à ce que l'objet Model personne soit la clé et nous voulons obtenir sa valeur et la placer dans l'argument de méthode Personne personne. Si tel n’existe pas ou (parfois vous mal orthographiez le (valeur = "persson")), Spring ne le trouvera pas dans le modèle et créera un objet Personne vide en utilisant ses valeurs par défaut. Ensuite, nous allons prendre les paramètres de la demande et essayer de les lier aux données dans l’objet Personne en utilisant leurs noms.
name="Dmitrij"&countries=Lesoto&sponsor.organization="SilkRoad"&authorizedFunds=&authorizedHours=&
Nous avons donc un nom et il sera lié à Person.name en utilisant setName (nom de chaîne). Donc dans
//..Some logic with person
nous avons accès à ce nom complet avec la valeur "Dimitrij".
Bien entendu, Spring peut lier des objets plus complexes tels que des listes, des cartes, des listes de jeux de cartes, etc., mais derrière la scène, la liaison de données devient magique.
Nous pouvons avoir à la fois une méthode de modèle annotée et un gestionnaire de méthode de requête avec @ModelAttribute dans les arguments. Ensuite, nous devons syndiquer les règles.
Bien sûr, nous avons des tonnes de situations différentes - les méthodes @ModelAttribute peuvent également être définies dans un @ControllerAdvice et ainsi de suite ...
Je sais que je suis en retard à la fête, mais je citerai comme on dit: "mieux vaut être en retard que jamais". Alors, allons-y, tout le monde a ses propres façons d'expliquer les choses, laissez-moi essayer de résumer et de simplifier cela pour vous en quelques étapes avec un exemple; Supposons que vous ayez un formulaire simple, un formulaire .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" Ce sont les champs/propriétés de StudentClass lorsque le formulaire est appelé, leurs getters sont appelés mais une fois soumis, leurs setters sont appelés et leurs valeurs sont définies le haricot indiqué dans modelAttribute = "student" dans la balise de formulaire.
Nous avons StudentController qui comprend les méthodes suivantes;
@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
enfin enfin nous avons un formulaire-details.jsp
<b>Student Information</b>
${student.firstName}
${student.lastName}
Revenons donc à la question Qu'est-ce que @ModelAttribute dans Spring MVC? Un exemple de définition de la source pour vous, http://www.baeldung.com/spring-mvc-and-the-modelattribute- annotation Le @ModelAttribute} _ est une annotation qui lie un paramètre de méthode ou une valeur de retour de méthode à un attribut de modèle nommé, puis l'expose à une vue Web.
Ce qui se passe réellement, c’est qu’il récupère toutes les valeurs de la forme ur qu’il soumet et les conserve pour que vous puissiez les lier ou les affecter à l’objet. Il fonctionne comme le @RequestParameter où nous obtenons seulement un paramètre et assignons la valeur à un champ. La seule différence est que @ModelAttribute} _ contient toutes les données de formulaire plutôt qu'un seul paramètre. Il crée pour vous un bean contenant les données du formulaire à utiliser par le développeur ultérieurement.
Pour récapituler le tout… .. Étape 1: Une demande est envoyée et notre méthode showForm est exécutée et un modèle, un bean temporaire est défini avec le nom student est transféré sous la forme .theModel.addAttribute ("étudiant", nouvel étudiant ());
Étape 2: modelAttribute = "student" Sur le modèle de soumission de formulaire change l’étudiant et conserve à présent tous les paramètres du formulaire
Étape 3: @ModelAttribute ("étudiant") étudiant l’étudiant Nous récupérons les valeurs retenues par @ModelAttribute et attribuons le haricot entier/objet à l'étudiant.
Étape 4: Et ensuite, nous l'utilisons comme nous enchérissons, comme si nous le montrions sur la page, etc. comme je l'ai fait
J'espère que cela vous aide à comprendre le concept. Merci
Ceci est utilisé à des fins de liaison de données dans Spring MVC. Permettez à jsp de contenir un élément de formulaire, par exemple
sur
JSP
<form:form action="test-example" method="POST" commandName="testModelAttribute"> </form:form>
(La méthode de formulaire Spring, un élément de formulaire simple peut également être utilisé)
Côté contrôleur
@RequestMapping(value = "/test-example", method = RequestMethod.POST)
public ModelAndView testExample(@ModelAttribute("testModelAttribute") TestModel testModel, Map<String, Object> map,...) {
}
Maintenant, lorsque vous soumettez le formulaire, les valeurs des champs de formulaire sont disponibles.
L'annotation qui lie un paramètre de méthode ou une valeur de retour de méthode à un attribut de modèle nommé, exposé à une vue Web.
public String add(@ModelAttribute("specified") Model model) {
...
}
@ModelAttribute peut être utilisé comme argument/paramètre de méthode ou avant la déclaration de méthode . L'objectif principal de cette annotation est de lier les paramètres de requête ou les champs de formulaire à un objet de modèle.
@ModelAttribute lie simplement la valeur des champs jsp aux Poals calss pour exécuter notre logique dans la classe du contrôleur. Si vous êtes familier avec struts, cela revient à renseigner l'objet formbean lors de sa soumission.
L'annotation ModelAttribute est utilisée dans le cadre d'une application Web Spring MVC et peut être utilisée dans deux scénarios.
Tout d'abord, il peut être utilisé pour injecter des données dans un modèle de charge pré-JSP. Ceci est particulièrement utile pour garantir qu’une JSP doit afficher toutes les données elle-même. Une injection est obtenue en connectant une méthode au modèle.
Deuxièmement, il peut être utilisé pour lire les données d'un modèle existant et les affecter aux paramètres de la méthode de l'entraîneur.
refrence https://dzone.com/articles/using-spring-mvc%E2%80%99s
Qu'il s'agisse de Gmail, de Facebook, d'Instagram ou de toute autre application Web, il s'agit d'échanger des données ou des informations entre l'utilisateur final et l'application ou l'interface utilisateur et l'application principale. Même dans Spring MVC, il existe deux méthodes pour échanger des données:
- du contrôleur à l'interface utilisateur, et
- de l'interface utilisateur au contrôleur.
Ce qui nous intéresse ici, c'est comment les données sont transmises de l'interface utilisateur au contrôleur. Cela peut aussi être fait de 2 manières:
- Utiliser un formulaire HTML
- Utilisation des paramètres de requête.
Utilisation d'un formulaire HTML: Envisagez le scénario ci-dessous,
Lorsque nous soumettons les données de formulaire à partir du navigateur Web, nous pouvons accéder à ces données dans notre classe de contrôleurs en tant qu'objet. Lorsque nous soumettons un formulaire HTML, le conteneur Spring fait quatre choses. Ce sera,
- commencez par lire toutes les données soumises qui entrent dans la requête à l’aide de la méthode request.getParameter.
- une fois qu'il les lit, il les convertit dans le type Java approprié à l'aide de integer.parseInt, double.parseDouble et de toutes les autres méthodes d'analyse disponibles en fonction du type de données.
- une fois analysé, il créera un objet de la classe de modèle que nous avons créée. Par exemple, dans ce scénario, ce sont les informations utilisateur qui sont soumises et nous créons une classe appelée User, dont le conteneur créera un objet et définira toutes les valeurs qui entrent automatiquement dans cet objet.
- il transmettra ensuite cet objet en définissant les valeurs sur le contrôleur.
Pour que tout cela fonctionne, nous devrons suivre certaines étapes.
Nous devons d’abord définir une classe de modèle, telle que User, dans laquelle le nombre de champs doit correspondre exactement au nombre de champs du formulaire HTML. De plus, les noms que nous utilisons dans le formulaire HTML doivent correspondre à ceux de la classe Java. Ces deux sont très importants. Les noms doivent correspondre, le nombre de champs du formulaire doit correspondre au nombre de champs de la classe que nous créons. Une fois que nous avons fait cela, le conteneur lit automatiquement les données qui arrivent, crée un objet de ce modèle, définit les valeurs et le transmet au contrôleur. Pour lire ces valeurs à l'intérieur du contrôleur, nous utilisons l'annotation @ModelAttribute dans les paramètres de la méthode. Lorsque nous créons des méthodes dans le contrôleur, nous allons utiliser le @ModelAttribute et lui ajouter un paramètre qui aura automatiquement cet objet donné par le conteneur.
Voici un exemple de code pour enregistrer un utilisateur:
@RequestMapping(value = "registerUser", method = RequestMethod.POST)
public String registerUser(@ModelAttribute("user") User user, ModelMap model) {
model.addAttribute("user", user);
return "regResult";
}
J'espère que cette explication schématique a aidé!