Related
Recently I was working on a little RESTful API using Spring and I came across the ModelAttribute annotation.
I noticed that there is some very interesting behavior associated with it, mainly the fact that you can stick it onto a method and it will get called before the handler for a given request is called, allowing you to do anything before data is bound to the arguments of your handler method.
One usage that comes to mind is default values:
#ModelAttribute("defaultEntity")
public Entity defaultEntity() {
final var entity = new Entity();
entity.setName("default name");
return entity;
}
#PostMapping("/entity")
public Entity createNewEntity(#Valid #ModelAttribute("defaultEntity") Entity entity) {
dao.saveEntity(entity);
return entity;
}
In this case, when a POST request comes to /entity, the first thing that will happen is that defaultEntity will get called, creating an entity with some default values pre-filled. Then, Spring will bind the incoming data into it (potentially overwriting the defaults or keeping them as-is) and then pass it into the createNewEntity handler. This is actually pretty nice, IMO.
Another surprising fact is that the annotated method can actually take parameters in much the same way as the handler method. A simple way to do partial entity updates could be something like this:
// first fetch the original entity from the database
#ModelAttribute("originalEntity")
public Entity originalEntity(#PathVariable("id") long id ) {
return dao.getEntity(id);
}
// then let Spring bind data to the entity and validate it
#PostMapping("/entity/{id}")
public Entity updateEntity(#Valid #ModelAttribute("originalEntity") Entity entity) {
// and finally we save it
dao.saveEntity(entity);
return entity;
}
Again, this is surprisingly easy.
Even more surprising is that different model attributes can depend on each other, so you can have a complicated multi-stage monster if you want:
// first fetch the original entity from the database
#ModelAttribute("originalEntity")
public Entity originalEntity(#PathVariable("id") long id ) {
return dao.getEntity(id);
}
// then let Spring bind data to the entity, validate it and do some processing to it
#ModelAttribute("boundAndValidatedEntity")
public Entity boundAndValidatedEntity(#Valid #ModelAttribute("originalEntity") Entity entity) {
processEntity(entity);
return entity;
}
// finally check that the entity is still valid and then save it
#PostMapping("/entity/{id}")
public Entity updateEntity(#Valid #ModelAttribute(value = "boundAndValidatedEntity", binding = false) Entity entity) {
dao.saveEntity(entity);
return entity;
}
Obviously not all of the model attributes have to be of the same type, some can depend on multiple arguments from different places. It's like a mini-DI container within a single controller.
However, there are some drawbacks:
as far as I can tell, it only works with query parameters and there is no way to make it work with other kinds of request parameters, such as the request body or path variables
all of the ModelAttribute-annotated methods within a single controller will always be called, which can
have a performance impact
be annoying to work with, since Spring will need to be able to gather all of the method's arguments (which may be impossible, for example when they reference a path variable that doesn't exist in the current request)
So, while ModelAttribute doesn't really seem too useful by itself because of these issues, I feel like the main idea behind it - essentially allowing you to control the construction of a method's parameter before it's bound/validated while being able to easily access other request parameters - is solid and could be very useful.
So, my question is simple - is there anything in Spring that would essentially act like ModelAttribute but without the drawbacks that I mentioned? Or maybe in some 3rd party library? Or maybe I could write something like this myself?
What is the purpose and usage of #ModelAttribute in Spring MVC?
#ModelAttribute refers to a property of the Model object (the M in MVC ;)
so let's say we have a form with a form backing object that is called "Person"
Then you can have Spring MVC supply this object to a Controller method by using the #ModelAttribute annotation:
public String processForm(#ModelAttribute("person") Person person){
person.getStuff();
}
On the other hand the annotation is used to define objects which should be part of a Model.
So if you want to have a Person object referenced in the Model you can use the following method:
#ModelAttribute("person")
public Person getPerson(){
return new Person();
}
This annotated method will allow access to the Person object in your View, since it gets automatically added to the Models by Spring.
See "Using #ModelAttribute".
I know this is an old thread, but I thought I throw my hat in the ring and see if I can muddy the water a little bit more :)
I found my initial struggle to understand #ModelAttribute was a result of Spring's decision to combine several annotations into one. It became clearer once I split it into several smaller annotations:
For parameter annotations, think of #ModelAttribute as the equivalent of #Autowired + #Qualifier i.e. it tries to retrieve a bean with the given name from the Spring managed model. If the named bean is not found, instead of throwing an error or returning null, it implicitly takes on the role of #Bean i.e. Create a new instance using the default constructor and add the bean to the model.
For method annotations, think of #ModelAttribute as the equivalent of #Bean + #Before, i.e. it puts the bean constructed by user's code in the model and it's always called before a request handling method.
Figuratively, I see #ModelAttribute as the following (please don't take it literally!!):
#Bean("person")
#Before
public Person createPerson(){
return new Person();
}
#RequestMapping(...)
public xxx handlePersonRequest( (#Autowired #Qualifier("person") | #Bean("person")) Person person, xxx){
...
}
As you can see, Spring made the right decision to make #ModelAttribute an all-encompassing annotation; no one wants to see an annotation smorgasbord.
So I will try to explain it in simpler way. Let's have:
public class Person {
private String name;
public String getName() {
return name;
}
public void setName(final String name) {
this.name = name;
}
}
As described in the Spring MVC documentation - the #ModelAttribute annotation can be used on methods or on method arguments. And of course we can have both use at the same time in one controller.
1.Method annotation
#ModelAttribute("cities")
public List<String> checkOptions(){
return new Arrays.asList(new[]{"Sofia","Pleven","Ruse"});//and so on
}
Purpose of such method is to add attribute in the model. So in our case cities key will have the list new Arrays.asList(new[]{"Sofia","Pleven","Ruse"}) as value in the Model (you can think of Model as map(key:value)). #ModelAttribute methods in a controller are invoked before #RequestMapping methods, within the same controller.
Here we want to add to the Model common information which will be used in the form to display to the user. For example it can be used to fill a HTML select:
2.Method argument
public String findPerson(#ModelAttriute(value="person") Person person) {
//..Some logic with person
return "person.jsp";
}
An #ModelAttribute on a method argument indicates the argument should be retrieved from the model. So in this case we expect that we have in the Model person object as key and we want to get its value and put it to the method argument Person person. If such does not exists or (sometimes you misspell the (value="persson")) then Spring will not find it in the Model and will create empty Person object using its defaults. Then will take the request parameters and try to data bind them in the Person object using their names.
name="Dmitrij"&countries=Lesoto&sponsor.organization="SilkRoad"&authorizedFunds=&authorizedHours=&
So we have name and it will be bind to Person.name using setName(String name). So in
//..Some logic with person
we have access to this filled name with value "Dimitrij".
Of course Spring can bind more complex objects like Lists, Maps, List of Sets of Maps and so on but behind the scene it makes the data binding magic.
We can have at the same time model annotated method and request method handler with #ModelAttribute in the arguments. Then we have to union the rules.
Of course we have tons of different situations - #ModelAttribute methods can also be defined in an #ControllerAdvice and so on...
For my style, I always use #ModelAttribute to catch object from spring form jsp. for example, I design form on jsp page, that form exist with commandName
<form:form commandName="Book" action="" methon="post">
<form:input type="text" path="title"></form:input>
</form:form>
and I catch the object on controller with follow code
public String controllerPost(#ModelAttribute("Book") Book book)
and every field name of book must be match with path in sub-element of form
I know I am late to the party, but I'll quote like they say,
"better be late than never". So let us get going,
Everybody has their own ways to explain things, let me try to sum it up and simple it up for you in a few steps with an example;
Suppose you have a simple form, 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>
<form:input path="firstName" /> <form:input path="lastName" /> These are the fields/properties in the Student class. When the form is called/initialized their getters are invoked. On form submit their setters are invoked, and their values are transferred in the bean that was indicated with modelAttribute="student" in the form tag.
We have StudentController that includes the following methods:
#RequestMapping("/showForm")
// `Model` is used to pass data between controllers and views
public String showForm(Model theModel) {
// attribute name, value
theModel.addAttribute("student", new Student());
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
Now finally we have a form-details.jsp:
<b>Student Information</b>
${student.firstName}
${student.lastName}
So back to the question What is #ModelAttribute in Spring MVC?
A sample definition from the source for you,
http://www.baeldung.com/spring-mvc-and-the-modelattribute-annotation
The #ModelAttribute is an annotation that binds a method parameter or method return value to a named model attribute and then exposes it to a web view.
What actually happens is it gets all the values of your form those were submitted by it and then holds them for you to bind or assign them to the object. It works like the #RequestParameter where we only get a parameter and assign the value to some method argument.
The difference is that #ModelAttribute holds all form data rather than a single parameter. It creates a bean for you which holds the data submitted in the form.
To recap the whole thing:
Step 1:
A request is sent and our method showForm() runs and a model, a temporary bean, is set with the name student and forwarded to the form:
theModel.addAttribute("student", new Student());
Step 2:
Form attribute modelAttribute="student" defines that on form submission the model will update the student and will hold all parameters of the form.
Step 3:
On form submission the processForm() method is invoked with parameter #ModelAttribute("student") Student theStudent: the values being hold in the form with modelAttribute="student" were fetched and assigned to the fields in the Student object.
Step 4:
And then we use it as we bid, just like showing it on the page etc like I did
I hope it helps you to understand the concept. Thanks
Take any web application whether it is Gmail or Facebook or Instagram or any other web application, it's all about exchanging data or information between the end user and the application or the UI and the back end application. Even in Spring MVC world there are two ways to exchange data:
from the Controller to the UI, and
from the UI to the Controller.
What we are interested here is how the data is communicated from the UI to Controller. This can also be done in 2 ways:
Using an HTML Form
Using Query Parameters.
Using an HTML Form:
Consider the below scenario,
When we submit the form data from the web browser, we can access that data in our Controller class as an object. When we submit an HTML form, the Spring Container does four things. It will,
first read all the data that is submitted that comes in the request using the request.getParameter method.
once it reads them, it will convert them into the appropriate Java type using integer.parseInt, double.parseDouble and all the other parse methods that are available based on the data type of the data.
once parsed, it will create a object of the model class that we created. For example, in this scenario, it is the user information that is being submitted and we create a class called User, which the Container will create an object of and it will set all the values that come in automatically into that object.
it will then handover that object by setting the values to the Controller.
To get this whole thing to work, we'll have to follow certain steps.
We first need to define a model class, like User, in which the number of fields should exactly match the number of fields in the HTML form. Also, the names that we use in the HTML form should match the names that we have in the Java class. These two are very important. Names should match, the number of fields in the form should match the number of fields in the class that we create. Once we do that, the Container will automatically read the data that comes in, creates an object of this model, sets the values and it hands it over to the Controller. To read those values inside the Controller, we use the #ModelAttribute annotation on the method parameters. When we create methods in the Controller, we are going to use the #ModelAttribute and add a parameter to it which will automatically have this object given by the Container.
Here is an example code for registering an user:
#RequestMapping(value = "registerUser", method = RequestMethod.POST)
public String registerUser(#ModelAttribute("user") User user, ModelMap model) {
model.addAttribute("user", user);
return "regResult";
}
Hope this diagrammatic explanation helped!
#ModelAttribute can be used as the method arguments / parameter or before the method declaration.
The primary objective of this annotation to bind the request parameters or form fields to an model object
Ref. http://www.javabeat.net/modelattribute-spring-mvc/
This is used for data binding purposes in Spring MVC. Let you have a jsp having a form element in it e.g
on JSP
<form:form action="test-example" method="POST" commandName="testModelAttribute"> </form:form>
(Spring Form method, Simple form element can also be used)
On Controller Side
#RequestMapping(value = "/test-example", method = RequestMethod.POST)
public ModelAndView testExample(#ModelAttribute("testModelAttribute") TestModel testModel, Map<String, Object> map,...) {
}
Now when you will submit the form the form fields values will be available to you.
Annotation that binds a method parameter or method return value to a named model attribute, exposed to a web view.
public String add(#ModelAttribute("specified") Model model) {
...
}
#ModelAttribute will create a attribute with the name specified by you (#ModelAttribute("Testing") Test test) as Testing in the given example ,Test being the bean test being the reference to the bean and Testing will be available in model so that you can further use it on jsp pages for retrieval of values that you stored in you ModelAttribute.
#ModelAttribute simply binds the value from jsp fields to Pojo calss to perform our logic in controller class. If you are familiar with struts, then this is like populating the formbean object upon submission.
The ModelAttribute annotation is used as part of a Spring MVC Web application and can be used in two scenarios.
First of all, it can be used to inject data into a pre-JSP load model. This is especially useful in ensuring that a JSP is required to display all the data itself. An injection is obtained by connecting one method to the model.
Second, it can be used to read data from an existing model and assign it to the parameters of the coach's method.
refrence https://dzone.com/articles/using-spring-mvc%E2%80%99s
At the Method Level
1.When the annotation is used at the method level it indicates the purpose of that
method is to add one or more model attributes
#ModelAttribute
public void addAttributes(Model model) {
model.addAttribute("india", "india");
}
At the Method Argument
1. When used as a method argument, it indicates the argument should be retrieved from the model. When not present and should be first instantiated and then added to the model and once present in the model, the arguments fields should be populated from all request parameters that have matching names So, it binds the form data with a bean.
#RequestMapping(value = "/addEmployee", method = RequestMethod.POST)
public String submit(#ModelAttribute("employee") Employee employee) {
return "employeeView";
}
First of all, Models are used in MVC Spring (MVC = Model, View, Controller). This said, models are used together with "views".
What are these views? Views can be though as "html pages that are generated by our backend framework (Spring in our case) with some variable data in some parts of the html page".
So we have the model, which is an entity containing the data do be "injected" into the view.
There are several "view" libraries that you can work with Spring: among which, JSP, Thymeleaf, Mustache and others.
For example, let us assume we are using Thymeleaf (they are all similar. What's more, Spring does not even know, except for JSP, with which view libraries he is working with. All the models are served through the Servlet of Spring. This means that the Spring code will be the same for all these view libraries. The only thing you need to change is the syntax of such html pages, which are located in resources/static/templates)
resources/static/templates //All our view web pages are here
A Controller takes care of the routes. Let's say for example we have our site hosted on localhost:8080. We want a route (URL) showing us the students. Let us say that this is available at localhost:8080/students. The controller that will do this is StudentController:
#Controller //Not #RestController
public class StudentController {
#GetMapping(/students)
public String getStudentView() {
return "student";
}
}
What this code does, is saying that, if we are going to
localhost:8080/students
then the method getStudentView() is called. But notice it should return a String. However, when working with a view library, and the controller is annotated with #Controller (and not #RestController), what spring does is looking for an html view page with the name of the String that the method returns, in our case it will look for the view at
/resources/static/templates/student.html
This is good enough for static pages without data. However, if we need a dynamic page with some data, Spring offers another big advantage: the method above getStudentView(), will also pass, under the hood, a model to our view "student.html". Our model will contain data that we can access in the file "student.html" using the specific syntax from our view library. E.g., with thymeleaf:
<div th:text="${attribute1}"> </div>
This will access the attribute "attribute1" of our model.
We can pass different data through our model. This is done by assigning it various attributes. There are different ways of assigning attributes, with #ModelAttribute:
#Controller //Not #RestController
public class StudentController {
#ModelAttribute(name = "attribute1")
public int assignAttribute1() {
return 123454321
} // Think it as "model.attribute1 = 123454321"
#GetMapping(/students)
public String getStudentView() {
return "student";
}
}
The code above will assign to the model (created under the hood), an attribute with name "attribute1" (think it as of a key), with value 12354321. Something like "model.attribute1 = 123454321".
Finally, the model is passed to the view when we go to the url
localhost:8080/students
Notice: all the methods annotated with #ModelAttribute are invoked before a view is returned. The model, once all the attributes are created, is passed to our view. simply put, after the method getStudentView() is called, all the method with #ModelAttribute are called.
This being said, the html code written above, will be viewed from the browser as:
<div> 123454321 </div> // th:text is a command of
//THymeleaf, and says to substitute the text
// between the tags with the attribute "attribute1"
// of our model passed to this view.
This is the basic usage of #ModelAttribute.
There is also another important use case:
The model might be needed in the opposite direction: i.e., from the view to the controller. In the case described above, the model is passed from the controller to the view. However, let us say that the user, from our html page, sends back some data. We can catch it with out model attributes, #ModelAttribute. This has already been described by others
I've a simple RESTful API based on Spring MVC using a JPA connected MySQL database. Until now this API supports complete updates of an entity only. This means all fields must be provided inside of the request body.
#ResponseBody
#PutMapping(value = "{id}")
public ResponseEntity<?> update(#Valid #RequestBody Article newArticle, #PathVariable("id") long id) {
return service.updateById(id, newArticle);
}
The real problem here is the validation, how could I validate only provided fields while still require all fields during creation?
#Entity
public class Article {
#NotEmpty #Size(max = 100) String title;
#NotEmpty #Size(max = 500) String content;
// Getters and Setters
}
Example for a partial update request body {"content": "Just a test"} instead of {"title": "Title", "content": "Just a test"}.
The actual partial update is done by checking if the given field is not null:
if(newArticle.getTitle() != null) article.setTitle(newArticle.getTitle());
But the validation of course wont work! I've to deactivate the validation for the update method to run the RESTful service. I've essentially two questions:
How can I validate only a "existing" subset of properties in the
update method while still require all fields during creation?
Is there a more elegant way for update partially then checking for
null?
The complexity of partial updates and Spring JPA is that you may send half of the fields populated, and even that you will need to pull the entire entity from the data base, then just "merge" both entity and the pojo, because otherwise you will risk your data by sending null values to the database.
But merging itself is kind of tricky, because you need to operate over each field and take the decision of either send the new value to the data base or just keep the current one. And as you add fields, the validation needs to be updated, and tests get more complex. In one single statement: it doesn't scale. The idea is to always write code which is open for extension and closed for modifications. If you add more fields, then the validation block ideally doesn't need to change.
The way you deal with this in a REST model, is by operating over the entire entity each time you need. Let's say you have users, then you first pull a user:
GET /user/100
Then you have in your web page the entire fields of user id=100. Then you change its last name. You propagate the change calling the same resource URL with PUT verb:
PUT /user/100
And you send all the fields, or rather the "same entity" back with a new lastname. And you forget about validation, the validation will just work as a black box. If you add more fields, you add more #NotNull or whatever validation you need. Of course there may be situations where you need to actually write blocks of code for validation. Even in this case the validation doesn't get affected, as you will have a main for-loop for your validation, and each field will have its own validator. If you add fields, you add validators, but the main validation block remains untouchable.
I have a controller with 2 methods that return related objects via the #ModelAttribute annotation:
#ModelAttribute("site")
public Site getSite(){
.....
return site;
}
#ModelAttribute("document")
public Document getDocument(){
.....
return document;
}
These objects are related to each other with one Site having many Documents. This relationship is mapped in JPA. Both of these objects contain a field with the same name, called "urlAlias". This field is edited on a page using the following freemarker markup:
<#spring.bind "document" />
....
<#spring.formInput "document.urlAlias" />
When I submit the form to the controller, I retrieve the document object using the following syntax:
#RequestMapping(method = RequestMethod.POST)
public ModelAndView create(#ModelAttribute("document") #Valid Document document, BindingResult documentResult,
#ModelAttribute("site") Site site, Model model){
...Do Stuff...
}
It appears that any value that I enter into the Document's urlAlias field has also been set in the Site object, even though I only edited the value of the field in the Document object.
I'm perplexed as to what is going on here. Am I doing something untoward by mapping more than one ModelAttribute in the same controller? Are there any other likely causes of this behaviour?
It would appear that the problem is the site parameter in the create() method in my controller:
#ModelAttribute("site") Site site
Removing that stops Spring binding to fields in that object. For future googlers, I get hold of the Site object within the create() method using the code below instead:
if (!model.containsAttribute("site")) {
throw new IllegalArgumentException("Model must contain site attribute.");
}
Site site = (Site) model.asMap().get("site");
From this it would appear that it is fine to declare more than one ModelAttribute in a controller, but only one can be used at a time as a parameter in a method.
What is the purpose and usage of #ModelAttribute in Spring MVC?
#ModelAttribute refers to a property of the Model object (the M in MVC ;)
so let's say we have a form with a form backing object that is called "Person"
Then you can have Spring MVC supply this object to a Controller method by using the #ModelAttribute annotation:
public String processForm(#ModelAttribute("person") Person person){
person.getStuff();
}
On the other hand the annotation is used to define objects which should be part of a Model.
So if you want to have a Person object referenced in the Model you can use the following method:
#ModelAttribute("person")
public Person getPerson(){
return new Person();
}
This annotated method will allow access to the Person object in your View, since it gets automatically added to the Models by Spring.
See "Using #ModelAttribute".
I know this is an old thread, but I thought I throw my hat in the ring and see if I can muddy the water a little bit more :)
I found my initial struggle to understand #ModelAttribute was a result of Spring's decision to combine several annotations into one. It became clearer once I split it into several smaller annotations:
For parameter annotations, think of #ModelAttribute as the equivalent of #Autowired + #Qualifier i.e. it tries to retrieve a bean with the given name from the Spring managed model. If the named bean is not found, instead of throwing an error or returning null, it implicitly takes on the role of #Bean i.e. Create a new instance using the default constructor and add the bean to the model.
For method annotations, think of #ModelAttribute as the equivalent of #Bean + #Before, i.e. it puts the bean constructed by user's code in the model and it's always called before a request handling method.
Figuratively, I see #ModelAttribute as the following (please don't take it literally!!):
#Bean("person")
#Before
public Person createPerson(){
return new Person();
}
#RequestMapping(...)
public xxx handlePersonRequest( (#Autowired #Qualifier("person") | #Bean("person")) Person person, xxx){
...
}
As you can see, Spring made the right decision to make #ModelAttribute an all-encompassing annotation; no one wants to see an annotation smorgasbord.
So I will try to explain it in simpler way. Let's have:
public class Person {
private String name;
public String getName() {
return name;
}
public void setName(final String name) {
this.name = name;
}
}
As described in the Spring MVC documentation - the #ModelAttribute annotation can be used on methods or on method arguments. And of course we can have both use at the same time in one controller.
1.Method annotation
#ModelAttribute("cities")
public List<String> checkOptions(){
return new Arrays.asList(new[]{"Sofia","Pleven","Ruse"});//and so on
}
Purpose of such method is to add attribute in the model. So in our case cities key will have the list new Arrays.asList(new[]{"Sofia","Pleven","Ruse"}) as value in the Model (you can think of Model as map(key:value)). #ModelAttribute methods in a controller are invoked before #RequestMapping methods, within the same controller.
Here we want to add to the Model common information which will be used in the form to display to the user. For example it can be used to fill a HTML select:
2.Method argument
public String findPerson(#ModelAttriute(value="person") Person person) {
//..Some logic with person
return "person.jsp";
}
An #ModelAttribute on a method argument indicates the argument should be retrieved from the model. So in this case we expect that we have in the Model person object as key and we want to get its value and put it to the method argument Person person. If such does not exists or (sometimes you misspell the (value="persson")) then Spring will not find it in the Model and will create empty Person object using its defaults. Then will take the request parameters and try to data bind them in the Person object using their names.
name="Dmitrij"&countries=Lesoto&sponsor.organization="SilkRoad"&authorizedFunds=&authorizedHours=&
So we have name and it will be bind to Person.name using setName(String name). So in
//..Some logic with person
we have access to this filled name with value "Dimitrij".
Of course Spring can bind more complex objects like Lists, Maps, List of Sets of Maps and so on but behind the scene it makes the data binding magic.
We can have at the same time model annotated method and request method handler with #ModelAttribute in the arguments. Then we have to union the rules.
Of course we have tons of different situations - #ModelAttribute methods can also be defined in an #ControllerAdvice and so on...
For my style, I always use #ModelAttribute to catch object from spring form jsp. for example, I design form on jsp page, that form exist with commandName
<form:form commandName="Book" action="" methon="post">
<form:input type="text" path="title"></form:input>
</form:form>
and I catch the object on controller with follow code
public String controllerPost(#ModelAttribute("Book") Book book)
and every field name of book must be match with path in sub-element of form
I know I am late to the party, but I'll quote like they say,
"better be late than never". So let us get going,
Everybody has their own ways to explain things, let me try to sum it up and simple it up for you in a few steps with an example;
Suppose you have a simple form, 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>
<form:input path="firstName" /> <form:input path="lastName" /> These are the fields/properties in the Student class. When the form is called/initialized their getters are invoked. On form submit their setters are invoked, and their values are transferred in the bean that was indicated with modelAttribute="student" in the form tag.
We have StudentController that includes the following methods:
#RequestMapping("/showForm")
// `Model` is used to pass data between controllers and views
public String showForm(Model theModel) {
// attribute name, value
theModel.addAttribute("student", new Student());
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
Now finally we have a form-details.jsp:
<b>Student Information</b>
${student.firstName}
${student.lastName}
So back to the question What is #ModelAttribute in Spring MVC?
A sample definition from the source for you,
http://www.baeldung.com/spring-mvc-and-the-modelattribute-annotation
The #ModelAttribute is an annotation that binds a method parameter or method return value to a named model attribute and then exposes it to a web view.
What actually happens is it gets all the values of your form those were submitted by it and then holds them for you to bind or assign them to the object. It works like the #RequestParameter where we only get a parameter and assign the value to some method argument.
The difference is that #ModelAttribute holds all form data rather than a single parameter. It creates a bean for you which holds the data submitted in the form.
To recap the whole thing:
Step 1:
A request is sent and our method showForm() runs and a model, a temporary bean, is set with the name student and forwarded to the form:
theModel.addAttribute("student", new Student());
Step 2:
Form attribute modelAttribute="student" defines that on form submission the model will update the student and will hold all parameters of the form.
Step 3:
On form submission the processForm() method is invoked with parameter #ModelAttribute("student") Student theStudent: the values being hold in the form with modelAttribute="student" were fetched and assigned to the fields in the Student object.
Step 4:
And then we use it as we bid, just like showing it on the page etc like I did
I hope it helps you to understand the concept. Thanks
Take any web application whether it is Gmail or Facebook or Instagram or any other web application, it's all about exchanging data or information between the end user and the application or the UI and the back end application. Even in Spring MVC world there are two ways to exchange data:
from the Controller to the UI, and
from the UI to the Controller.
What we are interested here is how the data is communicated from the UI to Controller. This can also be done in 2 ways:
Using an HTML Form
Using Query Parameters.
Using an HTML Form:
Consider the below scenario,
When we submit the form data from the web browser, we can access that data in our Controller class as an object. When we submit an HTML form, the Spring Container does four things. It will,
first read all the data that is submitted that comes in the request using the request.getParameter method.
once it reads them, it will convert them into the appropriate Java type using integer.parseInt, double.parseDouble and all the other parse methods that are available based on the data type of the data.
once parsed, it will create a object of the model class that we created. For example, in this scenario, it is the user information that is being submitted and we create a class called User, which the Container will create an object of and it will set all the values that come in automatically into that object.
it will then handover that object by setting the values to the Controller.
To get this whole thing to work, we'll have to follow certain steps.
We first need to define a model class, like User, in which the number of fields should exactly match the number of fields in the HTML form. Also, the names that we use in the HTML form should match the names that we have in the Java class. These two are very important. Names should match, the number of fields in the form should match the number of fields in the class that we create. Once we do that, the Container will automatically read the data that comes in, creates an object of this model, sets the values and it hands it over to the Controller. To read those values inside the Controller, we use the #ModelAttribute annotation on the method parameters. When we create methods in the Controller, we are going to use the #ModelAttribute and add a parameter to it which will automatically have this object given by the Container.
Here is an example code for registering an user:
#RequestMapping(value = "registerUser", method = RequestMethod.POST)
public String registerUser(#ModelAttribute("user") User user, ModelMap model) {
model.addAttribute("user", user);
return "regResult";
}
Hope this diagrammatic explanation helped!
#ModelAttribute can be used as the method arguments / parameter or before the method declaration.
The primary objective of this annotation to bind the request parameters or form fields to an model object
Ref. http://www.javabeat.net/modelattribute-spring-mvc/
This is used for data binding purposes in Spring MVC. Let you have a jsp having a form element in it e.g
on JSP
<form:form action="test-example" method="POST" commandName="testModelAttribute"> </form:form>
(Spring Form method, Simple form element can also be used)
On Controller Side
#RequestMapping(value = "/test-example", method = RequestMethod.POST)
public ModelAndView testExample(#ModelAttribute("testModelAttribute") TestModel testModel, Map<String, Object> map,...) {
}
Now when you will submit the form the form fields values will be available to you.
Annotation that binds a method parameter or method return value to a named model attribute, exposed to a web view.
public String add(#ModelAttribute("specified") Model model) {
...
}
#ModelAttribute will create a attribute with the name specified by you (#ModelAttribute("Testing") Test test) as Testing in the given example ,Test being the bean test being the reference to the bean and Testing will be available in model so that you can further use it on jsp pages for retrieval of values that you stored in you ModelAttribute.
#ModelAttribute simply binds the value from jsp fields to Pojo calss to perform our logic in controller class. If you are familiar with struts, then this is like populating the formbean object upon submission.
The ModelAttribute annotation is used as part of a Spring MVC Web application and can be used in two scenarios.
First of all, it can be used to inject data into a pre-JSP load model. This is especially useful in ensuring that a JSP is required to display all the data itself. An injection is obtained by connecting one method to the model.
Second, it can be used to read data from an existing model and assign it to the parameters of the coach's method.
refrence https://dzone.com/articles/using-spring-mvc%E2%80%99s
At the Method Level
1.When the annotation is used at the method level it indicates the purpose of that
method is to add one or more model attributes
#ModelAttribute
public void addAttributes(Model model) {
model.addAttribute("india", "india");
}
At the Method Argument
1. When used as a method argument, it indicates the argument should be retrieved from the model. When not present and should be first instantiated and then added to the model and once present in the model, the arguments fields should be populated from all request parameters that have matching names So, it binds the form data with a bean.
#RequestMapping(value = "/addEmployee", method = RequestMethod.POST)
public String submit(#ModelAttribute("employee") Employee employee) {
return "employeeView";
}
First of all, Models are used in MVC Spring (MVC = Model, View, Controller). This said, models are used together with "views".
What are these views? Views can be though as "html pages that are generated by our backend framework (Spring in our case) with some variable data in some parts of the html page".
So we have the model, which is an entity containing the data do be "injected" into the view.
There are several "view" libraries that you can work with Spring: among which, JSP, Thymeleaf, Mustache and others.
For example, let us assume we are using Thymeleaf (they are all similar. What's more, Spring does not even know, except for JSP, with which view libraries he is working with. All the models are served through the Servlet of Spring. This means that the Spring code will be the same for all these view libraries. The only thing you need to change is the syntax of such html pages, which are located in resources/static/templates)
resources/static/templates //All our view web pages are here
A Controller takes care of the routes. Let's say for example we have our site hosted on localhost:8080. We want a route (URL) showing us the students. Let us say that this is available at localhost:8080/students. The controller that will do this is StudentController:
#Controller //Not #RestController
public class StudentController {
#GetMapping(/students)
public String getStudentView() {
return "student";
}
}
What this code does, is saying that, if we are going to
localhost:8080/students
then the method getStudentView() is called. But notice it should return a String. However, when working with a view library, and the controller is annotated with #Controller (and not #RestController), what spring does is looking for an html view page with the name of the String that the method returns, in our case it will look for the view at
/resources/static/templates/student.html
This is good enough for static pages without data. However, if we need a dynamic page with some data, Spring offers another big advantage: the method above getStudentView(), will also pass, under the hood, a model to our view "student.html". Our model will contain data that we can access in the file "student.html" using the specific syntax from our view library. E.g., with thymeleaf:
<div th:text="${attribute1}"> </div>
This will access the attribute "attribute1" of our model.
We can pass different data through our model. This is done by assigning it various attributes. There are different ways of assigning attributes, with #ModelAttribute:
#Controller //Not #RestController
public class StudentController {
#ModelAttribute(name = "attribute1")
public int assignAttribute1() {
return 123454321
} // Think it as "model.attribute1 = 123454321"
#GetMapping(/students)
public String getStudentView() {
return "student";
}
}
The code above will assign to the model (created under the hood), an attribute with name "attribute1" (think it as of a key), with value 12354321. Something like "model.attribute1 = 123454321".
Finally, the model is passed to the view when we go to the url
localhost:8080/students
Notice: all the methods annotated with #ModelAttribute are invoked before a view is returned. The model, once all the attributes are created, is passed to our view. simply put, after the method getStudentView() is called, all the method with #ModelAttribute are called.
This being said, the html code written above, will be viewed from the browser as:
<div> 123454321 </div> // th:text is a command of
//THymeleaf, and says to substitute the text
// between the tags with the attribute "attribute1"
// of our model passed to this view.
This is the basic usage of #ModelAttribute.
There is also another important use case:
The model might be needed in the opposite direction: i.e., from the view to the controller. In the case described above, the model is passed from the controller to the view. However, let us say that the user, from our html page, sends back some data. We can catch it with out model attributes, #ModelAttribute. This has already been described by others