What is @ModelAttribute in Spring MVC?

后端 未结 13 854
一个人的身影
一个人的身影 2020-11-22 08:43

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

相关标签:
13条回答
  • 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

    0 讨论(0)
  • 2020-11-22 09:40

    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";
      }
    
    0 讨论(0)
  • 2020-11-22 09:42

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

    0 讨论(0)
  • 2020-11-22 09:44

    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>
    

    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 the form tag.

    We have StudentController that includes the 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 your form those were submitted 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

    0 讨论(0)
  • 2020-11-22 09:46

    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.

    0 讨论(0)
  • 2020-11-22 09:47

    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.

    0 讨论(0)
提交回复
热议问题