HandlerAdapter – Controller Invocation

In Spring MVC, HandlerAdapter is the component that actually invokes (calls) the controller method after the correct handler has been found. If HandlerMapping decides which controller should handle a request, then HandlerAdapter decides how that controller method should be executed.

In simple words,

HandlerAdapter acts as a translator between DispatcherServlet and your controller methods, allowing Spring MVC to support different types of controllers in a flexible and clean way.

What is HandlerAdapter?

HandlerAdapter is a core Spring MVC component that knows how to execute a specific type of controller.

After HandlerMapping determines which controller should handle the request, the DispatcherServlet asks:

“Which adapter can execute this controller?”

The HandlerAdapter then:

• Converts HTTP request data into method arguments
• Invokes the controller method
• Returns the result to DispatcherServlet

Why Do We Need HandlerAdapter?

Spring MVC supports multiple controller styles, such as annotation-based controllers, legacy controllers, and functional handlers.

Without HandlerAdapter, DispatcherServlet would need separate execution logic for each controller type, which would make the framework complex and hard to maintain.

HandlerAdapter solves this by:

• Providing a common execution mechanism
• Keeping DispatcherServlet lightweight
• Making Spring MVC loosely coupled and extensible
• Allowing easy support for future controller styles

How HandlerAdapter Works (Step-by-Step)

When a client sends an HTTP request, Spring MVC follows this flow:

1. DispatcherServlet receives the request
2. HandlerMapping finds the correct controller method
3. DispatcherServlet selects a compatible HandlerAdapter
4. HandlerAdapter executes the controller method
5. The result is returned to DispatcherServlet
6. The response is sent back to the client

Most Common HandlerAdapter

RequestMappingHandlerAdapter

• The most widely used HandlerAdapter in Spring MVC.
• Supports annotation-based controllers:
  • @Controller and @RestController
  • @RequestMapping
  • @GetMapping, @PostMapping, @PutMapping, @DeleteMapping
  • @PathVariable
  • @RequestParam
  • @RequestBody
  • @ResponseBody

Example:

@RestController
@RequestMapping("/users")
publicclassUserController {

@GetMapping("/{id}")
public UsergetUser(@PathVariable Long id) {
return userService.findById(id);
    }

@PostMapping
public UsercreateUser(@RequestBody User user) {
return userService.save(user);
    }
}

Handles request-to-method mapping, argument binding, and response conversion automatically.

What HandlerAdapter Actually Does

After a suitable HandlerAdapter is selected, it takes care of executing the controller method in a structured way. Its main responsibilities include:

• Invoking the selected controller method
• Resolving method arguments such as @PathVariable, @RequestParam, and @RequestBody
• Handling return values like View names, JSON, or ResponseEntity
• Passing the processed result back to the DispatcherServlet

This separation ensures that routing and execution remain independent and well organized.

Example – HandlerAdapter in Action

@RestController
@RequestMapping("/users")
publicclassUserController {

@GetMapping("/{id}")
public UsergetUser(@PathVariable Long id) {
return userService.findById(id);
    }
}

What Happens Internally

When a request like GET /users/10 arrives, Spring MVC processes it step by step:

1. DispatcherServlet receives the request
2. HandlerMapping identifies the getUser(Long id) method
3. DispatcherServlet selects RequestMappingHandlerAdapter
4. HandlerAdapter converts "10" into Long
5. The controller method getUser(10) is invoked
6. The return value (User) is converted to JSON using HttpMessageConverter
7. The response is sent back to the client

This entire process happens automatically without extra configuration in Spring Boot.

Types of HandlerAdapter in Spring MVC

Spring MVC provides several HandlerAdapter implementations to support different controller styles. Each type is designed to handle a specific kind of controller, ensuring flexible and consistent request execution.

1. RequestMappingHandlerAdapter

• Handles annotation-based controllers (@Controller, @RestController).
• Supports @RequestMapping, @GetMapping, @PostMapping, @PathVariable, @RequestBody, etc.
• Converts request/response automatically.

Example:

@RestController
@RequestMapping("/users")
publicclassUserController {
@GetMapping("/{id}")
public UsergetUser(@PathVariable Long id) {
return userService.findById(id);
    }
}

2. HttpRequestHandlerAdapter

• Executes controllers implementing HttpRequestHandler.
• Direct access to HttpServletRequest and HttpServletResponse.
• Used for streaming, file downloads.

Example:

publicclassCustomHttpRequestHandlerimplementsHttpRequestHandler {
@Override
publicvoidhandleRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
        response.getWriter().write("Handled by HttpRequestHandlerAdapter");
    }
}

3. SimpleControllerHandlerAdapter

• Supports old Controller interface.
• One method per controller, no annotations.

Example:

publicclassLegacyUserControllerimplementsController {
@Override
public ModelAndViewhandleRequest(HttpServletRequest request, HttpServletResponse response)
throws Exception {
ModelAndViewmv=newModelAndView("userView");
        mv.addObject("message","Handled by SimpleControllerHandlerAdapter");
return mv;
    }
}

4. HandlerFunctionAdapter

• For reactive, functional endpoints in WebFlux.
• Non-blocking, high-throughput apps.

Example:

RouterFunction<ServerResponse> route = RouterFunctions.route(
    GET("/users"), request -> ServerResponse.ok().bodyValue(userService.findAll())
);

HandlerMapping vs HandlerAdapter

Why HandlerAdapter Is Important

• Enables support for multiple controller types
• Handles argument binding and return value processing
• Supports both MVC views and REST APIs
• Separates routing from execution
• Keeps DispatcherServlet lightweight and clean

Conclusion

HandlerAdapter is the execution engine of Spring MVC.

Once routing is completed by HandlerMapping, HandlerAdapter takes over to:

• Bind request data
• Invoke controller methods
• Process return values

Together with DispatcherServlet and HandlerMapping, it ensures a clean, flexible, scalable, and production-ready Spring MVC architecture.