1. What is DispatcherServlet?

DispatcherServlet is the front controller in the Spring MVC framework that handles all incoming HTTP requests and routes them to appropriate controllers. It's the central dispatcher that manages the entire request lifecycle in a Spring MVC application.

1.1 The Role of DispatcherServlet

DispatcherServlet acts as the entry point for every request in a Spring MVC application. It intercepts the request, determines which controller to delegate it to, and then forwards the request to the view layer for rendering.

1.2 How DispatcherServlet Works

Here’s a high-level overview of how DispatcherServlet works:

Request Handling : When an HTTP request is received, it is first passed to the DispatcherServlet.
Mapping to Controllers : DispatcherServlet uses handler mappings to map the request to the appropriate controller.
Processing : The controller processes the request and returns a ModelAndView object that contains the model (data) and the view name.
View Resolution : DispatcherServlet uses a ViewResolver to map the view name to an actual view (e.g., JSP, Thymeleaf template).
Response : Finally, DispatcherServlet renders the view and sends the response back to the client.

1.3 Key Components Involved

To understand DispatcherServlet better, let’s break down its interaction with key components:

HandlerMapping : Determines the controller method to handle the request.
HandlerAdapter : Executes the controller method.
ViewResolver : Resolves the view name to a view template.
ModelAndView : Holds the model data and view name.

1.4 DispatcherServlet Initialization

When you define DispatcherServlet in the web.xml or through Java configuration, Spring automatically registers it as the front controller and initializes it with the necessary beans (like HandlerMapping, ViewResolver, etc.).

<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <url-pattern>/</url-pattern>
</servlet-mapping>

2. Configuring DispatcherServlet in Spring

Now, let's look at how you can configure DispatcherServlet in a Spring application.

2.1 XML Configuration

If you’re using XML-based configuration, you can configure DispatcherServlet in the web.xml file:

<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/dispatcher-servlet.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <url-pattern>/</url-pattern>
</servlet-mapping>

This configuration tells Spring to use DispatcherServlet as the front controller and load it at startup.

2.2 Java Configuration

With Java-based configuration, you can register With Java-based configuration, you can register DispatcherServlet using WebApplicationInitializer:using WebApplicationInitializer :

public class MyWebAppInitializer implements WebApplicationInitializer {
    @Override
    public void onStartup(ServletContext container) {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(AppConfig.class);

        ServletRegistration.Dynamic dispatcher = container.addServlet("dispatcher", new DispatcherServlet(context));
        dispatcher.setLoadOnStartup(1);
        dispatcher.addMapping("/");
    }
}

2.3 Understanding Context Hierarchy

In a Spring MVC application, DispatcherServlet has its own application context, which is a child of the root application context. This hierarchy allows the separation of web-specific beans from other application-wide beans.

2.4 Demo: Creating a Simple Spring MVC Application

Let’s create a simple Spring MVC application to see DispatcherServlet in action.

Step 1: Set Up Spring MVC Project

Set up a basic Spring MVC project with Maven or Gradle. Ensure you have the necessary dependencies:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.10</version>
</dependency>

Step 2: Create Controller

Create a simple controller to handle a request:

@Controller
public class HelloController {
    @RequestMapping("/hello")
    public String hello(Model model) {
        model.addAttribute("message", "Hello, DispatcherServlet!");
        return "hello";
    }
}

Step 3: Create View

Create a JSP file named hello.jsp in WEB-INF/views :

<html>
<body>
    <h2>${message}</h2>
</body>
</html>

Step 4: Run the Application

Run your application and navigate to http://localhost:8080/your-app-context/hello. You should see the message "Hello, DispatcherServlet!" displayed.

2.5 Demo Results

The output of the demo should be a simple web page displaying the message configured in the controller. This demo illustrates how DispatcherServlet manages the entire request-response cycle seamlessly.

3. Conclusion

DispatcherServlet is the heart of the Spring MVC framework, acting as the front controller that orchestrates the entire request-response cycle. Understanding its role and how to configure it is crucial for any Spring developer. If you have any questions or need further clarification, feel free to comment below!

Read posts more at : What is DispatcherServlet, its importance and how to implement it?