DispatcherServlet Internal Processing Flow

The DispatcherServlet is the Front Controller of Spring MVC.

Every HTTP request in a Spring Boot / Spring MVC application passes through it. It coordinates request handling, controller invocation, view resolution, and response generation.

Understanding its internal flow is essential for debugging request issues, customizing MVC behavior, and mastering Spring Boot internals.

What is DispatcherServlet?

DispatcherServlet is a central dispatcher that:

• Receives all incoming HTTP requests
• Delegates requests to the appropriate controllers
• Applies cross-cutting concerns (interceptors, exception handling)
• Renders views (HTML) or returns REST responses (JSON/XML)

It implements the Front Controller design pattern and provides a centralized entry point for Spring MVC applications.

High-Level Request Flow

Client Request
      ↓
DispatcherServlet
      ↓
HandlerMapping
      ↓
HandlerAdapter
      ↓
Controller Execution
      ↓
ReturnValue /Exception
      ↓
ViewResolverOR HttpMessageConverter
      ↓
HTTP Response

Step-by-Step Internal Processing Flow

1. HTTP Request Received

• The client sends an HTTP request (GET, POST, PUT, DELETE).
• The embedded server (Tomcat, Jetty, Undertow) forwards the request to DispatcherServlet.
• DispatcherServlet becomes the single entry point for request processing.

2. Handler Mapping

• DispatcherServlet consults HandlerMapping implementations to find the matching controller.
• Matches based on:
  • URL path
  • HTTP method
  • Annotations like @RequestMapping, @GetMapping

Example:

@GetMapping("/users")
public List<User>getUsers() { }

• Result: Handler object (controller method) is identified.

3. HandlerAdapter Selection

• DispatcherServlet selects a suitable HandlerAdapter.
• The adapter knows how to invoke the controller method, regardless of controller style.

Common adapters:

This abstraction allows multiple controller styles to coexist seamlessly.

4. Controller Execution

• Controller method is invoked by the HandlerAdapter.
• Spring performs:
  • Parameter binding
  • Validation (@Valid)
  • Dependency injection
  • Business logic execution
• Return types supported:
  • ModelAndView
  • View name (String)
  • @ResponseBody / REST object
  • ResponseEntity

5. Model Processing (MVC Only)

• For MVC:
  • Prepares model data
  • Returns logical view name
• For REST:
  • Prepares response body
  • Skips view resolution

6. View Resolution (MVC Only)

• DispatcherServlet uses ViewResolver to resolve view names to actual templates.

Example:

"user" →user.html (Thymeleaf)

Common ViewResolvers:

7. Response Rendering

• MVC: View renders HTML using model data
• REST: HttpMessageConverter converts objects → JSON/XML

Example (REST):

@ResponseBody
public UsergetUser(@PathVariable Long id) {return user; }

8. HTTP Response Returned

• DispatcherServlet sends the final response back to the client:

9. Interceptors

• Spring MVC supports HandlerInterceptors:

Common uses:

• Logging
• Authentication / Authorization
• Metrics / Monitoring

Interceptors are Spring MVC–specific (different from servlet filters).

10. Exception Handling

• If exceptions occur, DispatcherServlet delegates to:
  • @ExceptionHandler
  • @ControllerAdvice
  • HandlerExceptionResolver
• Result:
  • Error view for MVC
  • Error JSON response for REST

Difference Between REST vs MVC Flow

Why DispatcherServlet Matters

• Centralized Control: Single entry point for all requests
• Extensibility: Supports interceptors, filters, and custom resolvers
• Separation of Concerns: Decouples routing, logic, and rendering
• Debugging: Clear flow helps trace request issues

Key Components Involved

Conclusion

The DispatcherServlet Internal Processing Flow is the backbone of Spring MVC. Understanding it allows developers to:

• Build cleaner, maintainable controller logic
• Customize request processing
• Debug issues effectively
• Master Spring Boot MVC internals