Qu'est-ce que @ModelAttribute dans Spring MVC?
https://stackoverflow.com/questions/3423262
-
26-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Quel est le but et l'utilisation de @ModelAttribute dans Spring MVC?
La solution
@ModelAttribute fait référence à une propriété de l'objet modèle (M dans MVC;)
Alors disons que nous avons une forme avec un objet de support de forme qui est appelé « personne »
Ensuite, vous pouvez fournir Spring MVC cet objet à une méthode en utilisant l'Controller annotation @ModelAttribute:
public String processForm(@ModelAttribute("person") Person person){
person.getStuff();
}
D'autre part, l'annotation est utilisée pour définir des objets qui devraient faire partie d'un modèle. Donc, si vous voulez avoir un objet référencé personne 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 ajouté automatiquement aux modèles au printemps.
Autres conseils
Je sais que c'est un vieux fil, mais je pensais que je jette mon chapeau dans le ring et voir si je peux brouiller les pistes un peu plus:)
J'ai trouvé mon combat initial pour comprendre @ModelAttribute est le résultat de la décision de printemps de combiner plusieurs annotations en un seul. Il est devenu plus clair une fois que je le diviser en plusieurs annotations plus petites:
Pour les annotations de paramètres, pensez @ModelAttribute comme l'équivalent de @Autowired + @Qualifier à-dire qu'elle tente de récupérer un haricot avec le nom donné à partir du modèle géré de printemps. Si le grain du nom ne se trouve pas, au lieu de jeter une erreur ou retour null, il faut implicitement le rôle de @Bean à savoir créer une nouvelle instance en utilisant le constructeur par défaut et ajouter le grain au modèle.
Pour les annotations de méthode, pensez @ModelAttribute comme l'équivalent de @Bean + @Before, à-dire qu'elle met le grain construit par le code de l'utilisateur dans le modèle et il est toujours appelé avant une méthode de gestion de la demande.
Métaphoriquement, je vois @ModelAttribute comme suit (s'il vous plaît ne 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 voir, le printemps a pris la décision de faire @ModelAttribute une annotation qui englobe tout; Personne ne veut voir un assortiment d'annotation.
Pour mon style, je l'utilise toujours @ModelAttribute pour objet de capture de la forme de ressort jsp. par exemple, je conception de formulaire à la page jsp, cette forme EXISTER commandName
<form:form commandName="Book" action="" methon="post">
<form:input type="text" path="title"></form:input>
</form:form>
et I attraper l'objet sur commande avec le code de suivi
public String controllerPost(@ModelAttribute("Book") Book book)
et tous les noms de domaine de produit doit être correspondre avec le chemin en sous-élément de forme
Je vais donc essayer de l'expliquer de 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 cela est décrit dans la documentation Spring MVC - @ModelAttribute annotation peut être utilisé sur méthodes ou arguments de la méthode . Et bien sûr, nous pouvons avoir à la fois l'utilisation en même temps dans un contrôleur.
1.Méthode annotation
@ModelAttribute(“cities”)
public List<String> checkOptions(){
return new Arrays.asList(new[]{“Sofia”,”Pleven","Ruse”});//and so on
}
Objet de cette méthode consiste à ajouter l'attribut dans le modèle. Dans notre cas villes clés auront la liste new Arras.asList(new[]{“Sofia”,”Pleven","Ruse”}) comme valeur dans le modèle (vous pouvez penser du modèle comme carte (clé: valeur)). @ModelAttribute méthodes dans un contrôleur sont invoquées devant @RequestMapping méthodes, dans le même contrôleur.
Ici, nous voulons ajouter au modèle commun d'informations qui seront utilisés sous la forme pour afficher à l'utilisateur. Par exemple, il peut être utilisé pour remplir un HTML sélectionnez:
arguments 2.Méthode
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 récupéré à partir du modèle. Donc, dans ce cas, nous nous attendons à ce que nous avons dans le modèle personne objet comme clé et nous voulons obtenir sa valeur et de le mettre à l'argument de la méthode personne à personne . Si tel n'existe pas ou (parfois vous Misspell la (valeur = « persson »)) alors printemps ne le trouverez pas dans le modèle et va créer un objet vide personne en utilisant ses paramètres par défaut. Ensuite, prendra les paramètres de la requête et essayer de les lier des données dans l'objet personne utilisant leurs noms.
name="Dmitrij"&countries=Lesoto&sponsor.organization="SilkRoad"&authorizedFunds=&authorizedHours=&
Nous avons donc le nom et ce sera se lient à l'aide Person.name setName (String name). Ainsi, dans
//..Some logic with person
nous avons accès à ce nom rempli de valeur « Dimitrij ».
Bien sûr Spring peut lier des objets plus complexes tels que des listes, cartes, liste des jeux de cartes et ainsi de suite, mais derrière la scène, il fait la liaison de données magique.
-
Nous pouvons avoir à la même méthode annotée modèle de temps et la méthode de requête gestionnaire avec @ModelAttribute dans les arguments. Ensuite, nous avons à l'union des règles.
-
Bien sûr, nous avons des tonnes de différentes situations - méthodes de @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 vais citer comme ils disent, « Mieux être en retard que jamais ». Alors laissez-nous aller, Tout le monde a ses propres façons d'expliquer les choses, je vais essayer de résumer et simple, il pour vous en quelques étapes avec un exemple; Supposons que vous ayez une forme simple, 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 = "prenom" path = "lastName" Ce sont les champs / propriétés dans le StudentClass lorsque le formulaire est appelé leurs apporteurs sont appelés, mais une fois soumis leurs setters sont appelés et leurs valeurs sont définies dans la fève qui a été indiqué dans le modelAttribute = « étudiant » dans la balise form.
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, nous avons une forme details.jsp
<b>Student Information</b>
${student.firstName}
${student.lastName}
Revenons donc à la question Qu'est-ce que @ModelAttribute dans Spring MVC? Une définition de l'échantillon de la source pour vous, http://www.baeldung.com/spring-mvc-and- la modelattribute-annotation @ModelAttribute est une annotation qui lie un paramètre de méthode ou de la valeur de retour de la méthode à un attribut de modèle nommé et expose ensuite à une vue web.
Qu'est-ce qui se passe réellement est-il obtient toutes les valeurs de votre formulaire celles ont été faites par elle et les maintient alors pour vous de lier ou de les affecter à l'objet. Il fonctionne même comme @RequestParameter où nous ne recevons un paramètre et attribuer la valeur à un champ. La seule différence est @ModelAttribute détient toutes les données de formulaire plutôt qu'un seul paramètre. Il crée un haricot pour vous qui détient des données de formulaire soumis à utiliser plus tard par le développeur sur.
Pour récapituler l'ensemble. Étape 1 : Une demande est envoyée et notre méthode exécute ShowForm et un modèle, un haricot temporaire est définie avec l'étudiant du nom est transmis au formulaire. theModel.addAttribute ( "étudiant", nouvel étudiant ());
Étape 2: modelAttribute = "étudiant" le modèle de soumission du formulaire change l'étudiant et maintenant il détient tous les paramètres de la forme
Étape 3: @ModelAttribute ( "étudiant") étudiant theStudent Nous récupérons les valeurs étant prise par @ModelAttribute et affecter l'ensemble haricot / objet à l'élève.
Étape 4: Et nous l'utilisons comme nous offre, tout comme le montrer sur la page etc comme je l'ai fait
J'espère que cela vous aide à comprendre le concept. Merci
Prenez une application Web que ce soit Gmail ou Facebook ou Instagram ou toute autre application Web, il est tout au sujet de l'échange de données ou d'informations entre l'utilisateur final et l'application ou l'interface utilisateur et l'application finale arrière. Même dans le monde Spring MVC, il y a deux façons d'échanger des données:
- du contrôleur à l'interface utilisateur, et
- de l'interface utilisateur au contrôleur.
Ce qui nous intéresse ici est de savoir comment les données sont communiquées de l'interface utilisateur au contrôleur. Cela peut aussi se faire de 2 façons:
- L'utilisation d'un formulaire HTML
- Utilisation de paramètres de requête.
L'utilisation d'un formulaire HTML: Considérons 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 Controller comme un objet. Lorsque nous soumettons un formulaire HTML, le conteneur Spring fait quatre choses. Il sera,
- lire toutes les données qui ont fait valoir que la demande vient à l'aide de la méthode request.getParameter .
- une fois qu'il les lit, il les convertit dans le type Java approprié à l'aide Integer.parseInt , Double.parseDouble et toutes les autres méthodes d'analyse grammaticale qui sont disponibles sur la base le type de données des données.
- une fois analysé, il va créer un objet de la classe de modèle que nous avons créé. Par exemple, dans ce scénario, il est l'information d'utilisateur qui est soumis et nous créons une classe appelée utilisateur, que le conteneur va créer un objet et il établira toutes les valeurs qui viennent automatiquement dans cet objet.
- il sera ensuite remise de cet objet en définissant les valeurs au contrôleur.
Pour tout cela au travail, nous allons devoir suivre certaines étapes.
Nous avons d'abord besoin de définir une classe de modèle, comme utilisateur, dans lequel le nombre de champs doit correspondre exactement au nombre de champs du formulaire HTML. En outre, les noms que nous utilisons dans le formulaire HTML doivent correspondre aux noms que nous avons dans la classe Java. Ces deux sont très importants. Les noms doivent correspondre, le nombre de champs du formulaire doivent correspondre au nombre de champs dans la classe que nous créons. Une fois que nous faisons cela, le conteneur lit automatiquement les données qui arrive, crée un objet de ce modèle, définit les valeurs et le remet au contrôleur. Pour lire ces valeurs à l'intérieur du contrôleur, nous utilisons le @ModelAttribute annotation sur les paramètres de la méthode. Lorsque nous créons des méthodes dans le contrôleur, nous allons utiliser le @ModelAttribute et ajouter un paramètre à ce qui aura automatiquement cet objet donné par le conteneur.
Voici un exemple de code pour l'enregistrement d'un utilisateur:
@RequestMapping(value = "registerUser", method = RequestMethod.POST)
public String registerUser(@ModelAttribute("user") User user, ModelMap model) {
model.addAttribute("user", user);
return "regResult";
}
Hope cette explication schématique a aidé!
Il est utilisé à des fins de liaison de données au printemps MVC. Laissez-vous un jsp ayant un élément de forme en elle par exemple
sur
JSP
<form:form action="test-example" method="POST" commandName="testModelAttribute"> </form:form>
(méthode formulaire Spring, élément de forme simple peut également être utilisé)
Le contrôleur Côté
@RequestMapping(value = "/test-example", method = RequestMethod.POST)
public ModelAndView testExample(@ModelAttribute("testModelAttribute") TestModel testModel, Map<String, Object> map,...) {
}
Maintenant, quand vous soumettez le formulaire les champs de formulaire valeurs seront à votre disposition.
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 nommé, exposé à une vue Web.
public String add(@ModelAttribute("specified") Model model) {
...
}
@ModelAttribute peut être utilisé en tant que arguments de la méthode paramètre / ou avant la déclaration de la méthode. L'objectif principal de cette annotation pour lier les paramètres de la requête ou de champs de formulaire à un objet de modèle
@ModelAttribute va créer un attribut avec le nom spécifié par vous (@ModelAttribute("Testing") Test test) as Testing dans l'exemple donné, test étant le test de haricot étant la référence à la fève et d'essai seront disponibles dans le modèle afin que vous pouvez continuer à l'utiliser sur les pages jsp pour la récupération des valeurs sauvegardées dans les ModelAttribute vous.
@ModelAttribute lie simplement la valeur des champs jsp à Pojo calss pour réaliser notre logique en classe de contrôleur. Si vous êtes familier avec jambes de force, alors c'est comme peuplant l'objet FormBean sur présentation.
L'annotation ModelAttribute est utilisée dans le cadre d'une application Web Spring MVC et peut être utilisé dans deux scénarios.
Tout d'abord, il peut être utilisé pour injecter des données dans un modèle de pré-charge JSP. Ceci est particulièrement utile pour garantir qu'un JSP est nécessaire pour afficher toutes les données elles-mêmes. Une injection est obtenue en connectant une méthode pour le modèle.
En second lieu, il peut être utilisé pour lire des données à partir d'un modèle existant et l'affecter aux paramètres de la méthode de l'entraîneur.
https://dzone.com/articles/using- printemps-mvc% E2% 80% 99s
