What is @ModelAttribute in Spring MVC?

问题:

What is the purpose and usage of @ModelAttribute in Spring MVC?

回答1:

@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();
}

Check here for an example (Spring 2.5), also see \"Using @ModelAttribute on a method argument\" (Spring 3.1).

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 on a method\" (Spring 3.1).

Hope this helped.

回答2:

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.

回答3:

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

回答4:

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 Arras.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.

1. 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.

2. Of course we have tons of different situations - @ModelAttribute methods can also be defined in an @ControllerAdvice and so on...

回答5:

I know I am late to the party, but I\'ll quote like they say, \"better be late than never\". So lets 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\'ve 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>

path=\"firstName\" path=\"lastName\" These are the fields/properties in the StudentClass when the form is called their getters are called but once submitted their setters are called and their values are set in the bean that was indicated in the modelAttribute=\"student\" in form tag.

We have StudentController that includes following methods;

@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 

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 ur form that were submitting by it and then holds them for you to bind or assign them to the object. It works same like the @RequestParameter where we only get a parameter and assign the value to some field. Only difference is @ModelAttribute holds all form data rather than a single parameter. It creates a bean for you that holds form submitted data to be used by the developer later on.

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 is forwarded to the form. theModel.addAttribute(\"student\", new Student());

Step 2 : modelAttribute=\"student\" on form submission model changes the student and now it holds all parameters of the form

Step 3 : @ModelAttribute(\"student\") Student theStudent We fetch the values being hold by @ModelAttribute and assign the whole bean/object to Student.

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

回答6:

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.

回答7:

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) {
    ...
}

回答8:

@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/

回答9:

@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.

回答10:

@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.