@ModelAttribute

#Introduction

@ModelAttribute is one of the most misunderstood annotations in Spring. Many developers think it's only for HTML forms. In reality it's used for Spring MVC form binding, request-parameter binding, global model data, view rendering, data preloading, edit forms and legacy enterprise applications.

Interviewers frequently ask: What is @ModelAttribute? How is it different from @RequestBody? When should we use it? How does Spring populate the object? Can it work without the annotation? Which internal class handles it?

#What is @ModelAttribute?

Unlike @RequestBody, it does not read JSON. Instead it binds:

• Query parameters
• Form data (application/x-www-form-urlencoded)
• Multipart form fields (non-file fields)

First Example

POST /users
Content-Type: application/x-www-form-urlencoded

name=Rahul&age=25

@PostMapping("/users")
public String save(@ModelAttribute UserForm form) {
    return "Saved";
}

Spring automatically does the equivalent of:

UserForm form = new UserForm();
form.setName("Rahul");
form.setAge(25);

No JSON parsing happens.

Complete Request Flow

#Why Do We Need @ModelAttribute?

Without Spring:

UserForm form = new UserForm();
form.setName(request.getParameter("name"));
form.setAge(Integer.parseInt(request.getParameter("age")));

With Spring, @ModelAttribute UserForm form — everything is automatic.

#Data Sources

@ModelAttribute binds values from query parameters, form fields and multipart form fields — e.g. GET /users?name=Rahul&age=25 or a POST with Content-Type: application/x-www-form-urlencoded.

GET Example

@GetMapping("/search")
public String search(@ModelAttribute SearchFilter filter) {
}

GET /search?city=Bangalore&active=true → SearchFilter { city = Bangalore, active = true }.

POST Form Example

<form action="/users" method="post">
    <input name="name">
    <input name="age">
    <button>Save</button>
</form>

@PostMapping("/users")
public String save(@ModelAttribute UserForm form) {
}

Spring fills the object automatically.

#Nested Object Binding

name=Rahul
address.city=Bangalore
address.state=Karnataka

public class UserForm {
    private Address address;
}

public class Address {
    private String city;
    private String state;
}

Spring binds address.city → Address.city automatically.

#Collection Binding

skills[0]=Java
skills[1]=Spring
skills[2]=MySQL

private List<String> skills;

Spring populates the list.

#Validation and BindingResult

public class UserForm {

    @NotBlank
    private String name;

    @Min(18)
    private Integer age;
}

@PostMapping
public String save(@Valid @ModelAttribute UserForm form) {
}

Validation executes after binding.

BindingResult

A favourite interview question.

@PostMapping
public String save(@Valid @ModelAttribute UserForm form,
                   BindingResult result) {

    if (result.hasErrors()) {
        return "user-form";
    }
    return "success";
}

Instead of throwing an exception, validation errors stay inside BindingResult. This is especially useful for server-rendered forms (redisplay the form with error messages).

#@ModelAttribute on Methods — Global Model Data

@ModelAttribute can also be placed on methods:

@Controller
public class UserController {

    @ModelAttribute("countries")
    public List<String> countries() {
        return List.of("India", "USA", "Japan");
    }
}

Every view rendered by this controller receives countries automatically. (These methods run before each handler method in the controller.)

Across All Controllers

@ControllerAdvice
public class GlobalModel {

    @ModelAttribute("applicationName")
    public String app() {
        return "Ticket Booking";
    }
}

Now every view receives applicationName. Common in Spring MVC applications.

#@ModelAttribute vs @RequestBody

One of the most common interview questions.

#@ModelAttribute vs @RequestParam

For GET /users?name=Rahul&age=25:

// Option 1
@RequestParam String name, @RequestParam Integer age

// Option 2 — better when there are many fields
@ModelAttribute UserFilter filter

#File Upload Example

name=Rahul
age=25
profilePhoto=file.jpg

@PostMapping("/upload")
public String upload(@ModelAttribute UserForm form,
                     @RequestParam MultipartFile profilePhoto) {
}

@ModelAttribute binds the form fields; MultipartFile handles the uploaded file.

#Internal Working

Important classes: ModelAttributeMethodProcessor, WebDataBinder, ConversionService and Validator — interview favourites.

#@ModelAttribute Without the Annotation

For complex (non-simple) types in Spring MVC controllers, Spring treats the parameter as a model attribute even if you omit the annotation:

@PostMapping
public String save(UserForm form) {
}

Spring binds request parameters into form automatically. Adding @ModelAttribute makes the intent explicit and is recommended for readability.

#Enterprise Architecture

#Summary

#Key Takeaways

• @ModelAttribute binds request parameters and form fields to Java objects.
• It's designed for Spring MVC and HTML form processing, not JSON REST APIs.
• ModelAttributeMethodProcessor creates and binds the object.
• WebDataBinder handles property binding, type conversion and validation.
• BindingResult captures validation errors for server-rendered forms.
• @ModelAttribute methods provide common model data, per controller or globally via @ControllerAdvice.
• Prefer @RequestBody for REST APIs and @ModelAttribute for form submissions.