Spring MVC Architecture: DispatcherServlet Flow

Spring MVC Architecture is a request-driven web framework that follows the Model-View-Controller (MVC) design pattern. It is part of the Spring Framework and is widely used to build robust, scalable, and maintainable web applications.

The main goal of Spring MVC is to separate concerns by dividing an application into three interconnected components:

1. Model – Represents the application data and business logic. It typically consists of Java objects, DTOs, or entities that carry data between the layers.
2. View – Represents the presentation layer or user interface, such as JSP, Thymeleaf, HTML, or JSON for REST APIs.
3. Controller – Handles incoming HTTP requests, processes user input, interacts with the service layer, and prepares the Model for the View.

Advantages of Spring MVC Architecture

• Separation of Concerns: Keeps presentation, business logic, and data layers separate.
• Flexibility: Supports multiple view technologies and REST APIs.
• Annotation-Driven: Easy configuration using @Controller, @RestController, @RequestMapping, etc.
• Extensible: Supports interceptors, exception handling, and custom message converters.
• Scalable & Maintainable: Suitable for enterprise-level applications.

Key Components of Spring MVC Architecture

Learn about the key building blocks of Spring MVC Architecture, including DispatcherServlet, Controllers, Models, Views, and HttpMessageConverters, that power request handling and response rendering in modern web applications.

1. DispatcherServlet

The DispatcherServlet is the front controller in Spring MVC. It intercepts all incoming HTTP requests and manages the entire request-processing lifecycle. This includes routing requests to the appropriate controllers, invoking handler methods, and rendering responses. In Spring Boot, it is auto-configured, while in traditional Spring MVC, it can be configured in web.xml.

2. HandlerMapping

The HandlerMapping maps incoming request URLs to the appropriate controller methods. It uses annotations like @RequestMapping, @GetMapping, and @PostMapping to identify which controller method should handle the request.

Example:

@GetMapping("/users/{id}")
public User getUser(@PathVariable Long id) {
    return userService.getUserById(id);
}

3. HandlerAdapter

The HandlerAdapter acts as a bridge between the DispatcherServlet and the controller method. It prepares the method arguments (e.g., @RequestParam, @PathVariable, @ModelAttribute) and invokes the controller. Spring automatically provides adapters like RequestMappingHandlerAdapter for annotated controllers.

4. Controller

Controllers contain the application logic. They process user input, interact with the service layer, and return either a ModelAndView object for UI views or a response object for REST APIs.

Example (UI View):

@Controller
public class UserController {
    @GetMapping("/users/{id}")
    public ModelAndView userDetail(@PathVariable Long id) {
        User user = userService.getUserById(id);
        ModelAndView mv = new ModelAndView("userView");
        mv.addObject("user", user);
        return mv;
    }
}

Example (REST API):

@RestController
public class UserRestController {
    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUserById(id);
    }
}

5. Model

The Model holds the application data that needs to be displayed in the view or returned in the response. It typically consists of Java objects, DTOs, or entities that carry data between the controller and view.

Example:

mv.addObject("user", user); // Adding user data to the model

6. ViewResolver

The ViewResolver resolves logical view names returned by the controller to actual templates. This allows controllers to remain decoupled from view technologies.

Example:

Logical view name "userView" → JSP file /WEB-INF/views/userView.jsp.

7. View

The View is responsible for rendering the final output. It can generate HTML pages for UI or use HttpMessageConverters to produce JSON/XML for REST APIs.

Example (Thymeleaf/JSP):

<p>User Name: ${user.name}</p>

Example (REST JSON):

{
  "id": 1,
  "name": "John Doe"
}

8. HttpMessageConverter

The HttpMessageConverter automatically converts Java objects returned by controllers into JSON, XML, or other formats based on the client’s Accept header. It also converts incoming requests into Java objects for method parameters.

Example (REST API):

@RestController
public class UserRestController {
    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUserById(id);
    }
}

Spring automatically converts the User object into JSON:

{
  "id": 1,
  "name": "John Doe"
}

How These Components Work Together (Example Flow)

1. Client sends an HTTP request: GET /users/1.
2. DispatcherServlet intercepts the request.
3. HandlerMapping identifies the correct controller method.
4. HandlerAdapter prepares method arguments and calls the controller.
5. Controller executes business logic and populates the Model.
6. Service Layer handles business logic; Repository Layer fetches data from the database.
7. Controller returns ModelAndView (for UI) or an object (for REST).
8. ViewResolver resolves logical view names to actual templates.
9. View / HttpMessageConverter renders the final output.
10. DispatcherServlet sends the response back to the client.

DispatcherServlet Flow: Step-by-Step

The DispatcherServlet in Spring MVC is the front controller that manages the entire request lifecycle. It coordinates request handling, controller execution, business logic, and response rendering. Below is a detailed step-by-step flow of how a request is processed.

1. Client Sends HTTP Request

A client (browser, mobile app, Postman) sends a request to the server.

Example:

GET /users/1

2. DispatcherServlet Receives Request

• Acts as the front controller for all incoming requests.
• Configured via web.xml in traditional Spring or auto-configured in Spring Boot.
• Intercepts and centralizes request processing.

3. HandlerMapping – Identify Controller

DispatcherServlet asks HandlerMapping to find the correct controller method for the URL and HTTP method.

Example Controller:

@GetMapping("/users/{id}")
public User getUser(@PathVariable Long id) {
    return userService.getUserById(id);
}

4. HandlerAdapter – Prepare & Invoke Controller

• Prepares method arguments (@RequestParam, @PathVariable, @ModelAttribute).
• Converts HTTP request data into Java objects.
• Invokes the corresponding controller method.

5. Controller Processes Request

• Handles business logic directly or delegates to the Service Layer.
• Prepares a Model with data for the view or returns a response object for REST APIs.

6. Service & Repository Layer (Optional)

• Service Layer: Contains business logic and application rules.
• Repository Layer: Handles data persistence and database queries.

Example: Fetch user by ID

User user = userRepository.findById(id).orElse(null);

7. Return Model & View

Controller returns ModelAndView for UI rendering or a response object for REST.

REST Example:

return new ResponseEntity<>(user, HttpStatus.OK);

8. ViewResolver (For UI Views)

• Resolves logical view names returned by controllers into actual templates (e.g., userView → userView.jsp).
• Not used in REST APIs (JSON/XML is returned directly).

9. HttpMessageConverter (For REST APIs)

• Converts Java objects into JSON, XML, or other formats automatically.
• Ensures proper serialization and content negotiation based on client requests.

Example JSON Response:

{
  "id": 1,
  "name": "John Doe"
}

10. Response Returned to Client

• DispatcherServlet sends the rendered response back to the client.
• The request lifecycle is complete.

Flowchart: Spring MVC DispatcherServlet Flow

Client Request (HTTP)
       │
       ▼
DispatcherServlet (Front Controller)
       │
       ▼
HandlerMapping (Find Controller)
       │
       ▼
HandlerAdapter (Invoke Controller)
       │
       ▼
Controller (Processes Request)
       │
       ▼
Service Layer (Business Logic) → Repository Layer (Database)
       │
       ▼
ModelAndView / Response Object
       │
       ▼
ViewResolver (Resolve Template)
       │
       ▼
View / HttpMessageConverter (Render HTML/JSON/XML)
       │
       ▼
Response Sent to Client

Spring MVC vs Spring Boot Web MVC – Key Differences

Why Spring MVC Architecture is Important

1. Separation of Concerns: Clean division between controller, service, and view.
2. Flexibility: Supports multiple view technologies (JSP, Thymeleaf, FreeMarker) and REST APIs.
3. Annotation-Driven Development: Easy configuration using @Controller, @RestController, @RequestMapping, etc.
4. Extensibility: Supports interceptors, exception handling, and custom message converters.
5. Scalability & Maintainability: Makes enterprise-level applications maintainable and testable.

Conclusion

• Spring MVC is a request-driven framework following the MVC pattern, separating presentation, business logic, and data layers.
• DispatcherServlet acts as the front controller, managing request flow, controller execution, service logic, view resolution, and response rendering.
• Key components like HandlerMapping, HandlerAdapter, Controller, Model, ViewResolver, View, and HttpMessageConverters ensure smooth request processing.
• Enables developers to build scalable, maintainable, and high-performance web applications.
• Ensures systematic request handling and accurate response rendering, supporting both UI and REST outputs efficiently.