DispatcherServlet – Front Controller

In Spring MVC, the DispatcherServlet acts as the Front Controller. Think of it as the traffic manager of your web application: it receives all HTTP requests, decides which controller should handle them, and sends the appropriate response back to the user.

This central role makes your application clean, organized, and easy to maintain.

What is DispatcherServlet?

DispatcherServlet is a core component of Spring MVC. Its main purpose is to intercept all incoming HTTP requests and delegate them to the right controller.

Key points:

• It is automatically configured in Spring Boot.
• In traditional Spring MVC, it can be defined in web.xml.
• It handles all types of HTTP requests such as GET, POST, PUT, and DELETE.

In simple words:

“Every request passes through DispatcherServlet before reaching your controllers.”

Why is it Called Front Controller?

The Front Controller pattern is a widely-used design pattern in web development.

• It centralizes request handling.
• Instead of each controller handling requests independently, the DispatcherServlet manages all requests in one place.
• This leads to better organization, maintainability, and scalability of your application.

Responsibilities of DispatcherServlet

1. Intercept Requests: Captures all incoming HTTP requests.
2. Handler Mapping: Determines which controller method should handle the request using HandlerMapping.
3. Invoke Controller: Uses HandlerAdapter to call the appropriate controller method.
4. Process Response: Returns the response either as a view (HTML, JSP, Thymeleaf) or data (JSON/XML).
5. Exception Handling: Works with HandlerExceptionResolver to manage errors globally.

How DispatcherServlet Works – Step by Step

Client → DispatcherServlet → HandlerMapping → Controller → Model → ViewResolver → View → Response

Step-by-Step Process:

1. User sends an HTTP request (e.g., www.example.com/home).
2. DispatcherServlet intercepts the request.
3. HandlerMapping finds the appropriate controller method.
4. Controller executes business logic and updates the Model.
5. ViewResolver resolves the logical view name to an actual view template (JSP, Thymeleaf, etc.).
6. The view is rendered, and the HTTP response is sent back to the client.

Example in Spring Boot

@RestController
publicclassHomeController {

@GetMapping("/home")
public StringhomePage() {
return"Welcome to the Home Page!";
    }
}

• Here, DispatcherServlet automatically maps the /home request to the homePage() method.
• Spring Boot handles everything else, like sending the response back to the client.

Another Example with a View:

@Controller
publicclassUserController {

@GetMapping("/users/{id}")
public StringgetUser(@PathVariable Long id, Model model) {
Useruser= userService.findById(id);
        model.addAttribute("user", user);
return"userView";// ViewResolver resolves this to userView.jsp
    }
}

Flow:

1. User requests /users/1.
2. DispatcherServlet intercepts the request.
3. HandlerMapping maps it to getUser() in UserController.
4. Controller fetches the user and adds it to the model.
5. ViewResolver renders userView.jsp and sends the HTML response.

Benefits of Using DispatcherServlet

• Centralized Request Handling: All requests pass through one front controller.
• Clean Architecture: Separates responsibilities of controller, service, and view.
• Easy Maintenance: Adding new controllers doesn’t affect existing ones.
• Flexible Views: Works with JSP, Thymeleaf, FreeMarker, and more.
• Seamless Integration with Spring Boot: Auto-configured, highly customizable, and supports exception handling.

Conclusion

The DispatcherServlet is the backbone of Spring MVC:

• Centralizes request handling.
• Routes requests via HandlerMapping and HandlerAdapter.
• Works with Model and ViewResolver for rendering.
• Simplifies development in Spring Boot with auto-configuration.