Method Argument Injection in Spring MVC Controllers: A Detailed Guide

Spring MVC diagram [Spring Official Docs]

Spring MVC provides a rich set of options for injecting method arguments into your controller methods. This powerful feature allows you to access request details, session information, security principals, locale settings, and more—all without manual wiring. In this guide, we’ll explore the most common types you can use as controller method arguments, along with real-world examples.

Common Controller Method Argument Types

Spring MVC automatically resolves several types of arguments, allowing you to write clean and concise controller methods. Here are some of the most useful ones:

1. HttpServletRequest

Inject the raw HTTP request to access parameters, headers, cookies, and other request metadata.

@GetMapping("/example")
public String handleRequest(HttpServletRequest request) {
    String clientIp = request.getRemoteAddr();
    // Use request data as needed...
    return "exampleView";
}

2. HttpServletResponse

Access the HTTP response object to set headers, status codes, or write binary data directly.

@GetMapping("/download")
public void downloadFile(HttpServletResponse response) {
    response.setContentType("application/pdf");
    // Write file contents to response output stream...
}

3. HttpSession

Access the session associated with the current user, enabling you to store or retrieve user-specific data.

@GetMapping("/session")
public String sessionExample(HttpSession session) {
    session.setAttribute("userAttribute", "someValue");
    return "sessionView";
}

Note: Among the options provided in some exam questions, HttpSession is the correct type (not just Session) for injecting session data.

4. Principal

Access the currently authenticated user's details. This is particularly useful for security-sensitive applications.

@GetMapping("/profile")
public String userProfile(Principal principal) {
    String username = principal.getName();
    // Load user-specific data based on the username...
    return "profileView";
}

5. Locale

Retrieve the current locale associated with the request. This is especially useful for internationalization.

@GetMapping("/welcome")
public String welcomeUser(Locale locale) {
    String language = locale.getLanguage();
    // Use the locale to customize responses, e.g., greeting messages...
    return "welcomeView";
}

Tip: The exam question often lists Locale as a valid injection type. Unlike a generic "Language" type, Locale is a concrete Java type that Spring can automatically resolve.

Additional Argument Types You Might Encounter

In addition to the types listed above, Spring MVC supports many other method argument types:

Model / ModelMap: For passing data to the view.

@GetMapping("/data")
public String getData(Model model) {
    model.addAttribute("key", "value");
    return "dataView";
}

• @RequestParam / @PathVariable: For binding request parameters or URI path variables.

@GetMapping("/user/{id}")
public String getUser(@PathVariable Long id) {
    // Use the path variable 'id'
    return "userView";
}

• WebRequest / NativeWebRequest: For accessing both request and session attributes in a more generic fashion.

• @RequestBody: To bind the HTTP request body to a method parameter.

Each of these types serves a specific purpose, making your controllers more expressive and easier to maintain.

Summary: Answering the Exam Question

Based on the provided options:

• Session: Not valid as a stand-alone type (use HttpSession instead).

• HttpSession: Valid – Injects the HTTP session.

• Principal: Valid – Provides access to the authenticated user.

• Request: Not valid in the absence of the proper type (use HttpServletRequest).

• Language: Not valid – There’s no such injection type.

• Locale: Valid – Automatically resolves the locale of the request.

Thus, the three correct options for injection as controller method arguments are HttpSession, Principal, and Locale.

By leveraging these injection capabilities, you can write controller methods that are both powerful and clean, seamlessly accessing all the contextual data your application needs to serve dynamic content.

Happy coding!