Giới thiệu Spring MVC và DispatcherServlet

01-dispatcherservlet/
  pom.xml
  src/main/java/dev/canhdominich/spring/mvc/
    Trace.java                  ghi lại các sự kiện theo thứ tự xảy ra
    TraceFilter.java            Filter của Servlet ghi trước và sau servlet
    TraceInterceptor.java       HandlerInterceptor ghi preHandle, postHandle, afterCompletion
    HelloController.java        hai endpoint: /hello trả view, /boom ném lỗi
    WebConfig.java              @EnableWebMvc, quét component, interceptor, view resolver JSP
    EmbeddedServer.java         dựng Tomcat, DispatcherServlet, JSP servlet và filter
    ServerMain.java             chạy server thật ở cổng 8080
    DispatcherDemo.java         gửi yêu cầu HTTP thật và in kết quả cùng thứ tự sự kiện
  src/main/webapp/WEB-INF/views/
    hello.jsp                   view của /hello

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>dev.canhdominich.javabackend</groupId>
    <artifactId>spring-mvc-dispatcherservlet</artifactId>
    <version>1.0.0</version>
    <name>Spring MVC - DispatcherServlet</name>

    <properties>
        <maven.compiler.release>17</maven.compiler.release>
        <maven.compiler.parameters>true</maven.compiler.parameters>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <main.class>dev.canhdominich.spring.mvc.ServerMain</main.class>
        <spring.version>7.0.9</spring.version>
        <tomcat.version>11.0.27</tomcat.version>
        <jstl.api.version>3.0.2</jstl.api.version>
        <jstl.impl.version>3.0.1</jstl.impl.version>
        <junit.version>6.0.3</junit.version>
        <assertj.version>3.27.7</assertj.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-core</artifactId>
            <version>${tomcat.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <version>${tomcat.version}</version>
        </dependency>
        <dependency>
            <groupId>jakarta.servlet.jsp.jstl</groupId>
            <artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
            <version>${jstl.api.version}</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.web</groupId>
            <artifactId>jakarta.servlet.jsp.jstl</artifactId>
            <version>${jstl.impl.version}</version>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.assertj</groupId>
            <artifactId>assertj-core</artifactId>
            <version>${assertj.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>3.5.6</version>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.6.3</version>
                <configuration>
                    <executable>java</executable>
                    <arguments>
                        <argument>-classpath</argument>
                        <classpath/>
                        <argument>${main.class}</argument>
                    </arguments>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

package dev.canhdominich.spring.mvc;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public final class Trace {

    private static final List<String> EVENTS = Collections.synchronizedList(new ArrayList<>());

    private Trace() {
    }

    public static void record(String event) {
        EVENTS.add(event);
    }

    public static void clear() {
        EVENTS.clear();
    }

    public static List<String> all() {
        synchronized (EVENTS) {
            return new ArrayList<>(EVENTS);
        }
    }
}

package dev.canhdominich.spring.mvc;

import jakarta.servlet.Filter;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import java.io.IOException;

public class TraceFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        Trace.record("filter: before the servlet");
        try {
            chain.doFilter(request, response);
        } finally {
            Trace.record("filter: after the servlet");
        }
    }
}

package dev.canhdominich.spring.mvc;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

public class TraceInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        String target = handler instanceof HandlerMethod method ? method.getMethod().getName() : handler.getClass().getSimpleName();
        Trace.record("interceptor: preHandle for " + target);
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        Trace.record("interceptor: postHandle, view = " + (modelAndView == null ? "none" : modelAndView.getViewName()));
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        Trace.record("interceptor: afterCompletion, exception = " + (ex == null ? "none" : ex.getClass().getSimpleName()));
    }
}

package dev.canhdominich.spring.mvc;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HelloController {

    @GetMapping("/hello")
    public String hello(Model model) {
        Trace.record("controller: hello()");
        model.addAttribute("message", "Xin chao Spring MVC");
        return "hello";
    }

    @GetMapping("/boom")
    public String boom() {
        Trace.record("controller: boom()");
        throw new IllegalStateException("something broke inside the controller");
    }
}

package dev.canhdominich.spring.mvc;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ViewResolverRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
@EnableWebMvc
@ComponentScan(basePackageClasses = WebConfig.class)
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TraceInterceptor());
    }

    @Override
    public void configureViewResolvers(ViewResolverRegistry registry) {
        registry.jsp("/WEB-INF/views/", ".jsp");
    }
}

<%@ page contentType="text/html;charset=UTF-8" %>
<% dev.canhdominich.spring.mvc.Trace.record("view: hello.jsp rendered"); %>
<html><body><h1>${message}</h1></body></html>

package dev.canhdominich.spring.mvc;

import jakarta.servlet.DispatcherType;
import java.io.File;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.catalina.Context;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.Wrapper;
import org.apache.catalina.connector.Connector;
import org.apache.catalina.startup.Tomcat;
import org.apache.tomcat.util.descriptor.web.FilterDef;
import org.apache.tomcat.util.descriptor.web.FilterMap;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;

public final class EmbeddedServer implements AutoCloseable {

    private final Tomcat tomcat;
    private final AnnotationConfigWebApplicationContext springContext;

    private EmbeddedServer(Tomcat tomcat, AnnotationConfigWebApplicationContext springContext) {
        this.tomcat = tomcat;
        this.springContext = springContext;
    }

    public static EmbeddedServer start(int port, Class<?>... configurations) throws LifecycleException {
        Logger root = Logger.getLogger("");
        root.setLevel(Level.WARNING);
        for (Handler handler : root.getHandlers()) {
            handler.setLevel(Level.WARNING);
        }
        Tomcat tomcat = new Tomcat();
        tomcat.setBaseDir(new File("target/tomcat").getAbsolutePath());
        tomcat.setPort(port);
        Connector connector = tomcat.getConnector();
        connector.setProperty("address", "127.0.0.1");
        Context context = tomcat.addContext("", new File("src/main/webapp").getAbsolutePath());
        if (context instanceof org.apache.catalina.core.StandardContext standard) {
            standard.setClearReferencesRmiTargets(false);
            standard.setClearReferencesThreadLocals(false);
        }
        context.addLifecycleListener(new Tomcat.FixContextListener());
        context.addServletContainerInitializer(new org.apache.jasper.servlet.JasperInitializer(), null);
        Wrapper jsp = Tomcat.addServlet(context, "jsp", "org.apache.jasper.servlet.JspServlet");
        jsp.setLoadOnStartup(3);
        context.addServletMappingDecoded("*.jsp", "jsp");

        AnnotationConfigWebApplicationContext springContext = new AnnotationConfigWebApplicationContext();
        springContext.register(configurations);
        Wrapper dispatcher = Tomcat.addServlet(context, "dispatcher", new DispatcherServlet(springContext));
        dispatcher.setLoadOnStartup(1);
        context.addServletMappingDecoded("/", "dispatcher");

        FilterDef def = new FilterDef();
        def.setFilterName("trace");
        def.setFilter(new TraceFilter());
        context.addFilterDef(def);
        FilterMap map = new FilterMap();
        map.setFilterName("trace");
        map.addURLPattern("/*");
        map.setDispatcher(DispatcherType.REQUEST.name());
        context.addFilterMap(map);

        tomcat.start();
        return new EmbeddedServer(tomcat, springContext);
    }

    public int port() {
        return tomcat.getConnector().getLocalPort();
    }

    public AnnotationConfigWebApplicationContext springContext() {
        return springContext;
    }

    @Override
    public void close() throws LifecycleException {
        tomcat.stop();
        tomcat.destroy();
    }
}

package dev.canhdominich.spring.mvc;

public class ServerMain {

    public static void main(String[] args) throws Exception {
        int port = Integer.parseInt(System.getenv().getOrDefault("PORT", "8080"));
        EmbeddedServer server = EmbeddedServer.start(port, WebConfig.class);
        System.out.println("listening on http://127.0.0.1:" + server.port() + "/hello");
        Thread.currentThread().join();
    }
}

package dev.canhdominich.spring.mvc;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.HandlerAdapter;
import org.springframework.web.servlet.HandlerMapping;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

public class DispatcherDemo {

    public static void main(String[] args) throws Exception {
        run();
    }

    public static List<String> run() throws Exception {
        List<String> lines = new ArrayList<>();
        try (EmbeddedServer server = EmbeddedServer.start(0, WebConfig.class)) {
            AnnotationConfigWebApplicationContext context = server.springContext();
            lines.add("handler mappings: " + new TreeSet<>(context.getBeansOfType(HandlerMapping.class).keySet()));
            lines.add("handler adapters: " + new TreeSet<>(context.getBeansOfType(HandlerAdapter.class).keySet()));
            lines.add("view resolvers: " + new TreeSet<>(context.getBeansOfType(ViewResolver.class).keySet()));
            RequestMappingHandlerMapping mapping = context.getBean(RequestMappingHandlerMapping.class);
            mapping.getHandlerMethods().forEach((info, method) -> lines.add("mapped: " + info + " -> " + method.getMethod().getName()));
            lines.forEach(System.out::println);
            lines.add(call(server, "GET", "/hello"));
            lines.add(call(server, "GET", "/nope"));
            lines.add(call(server, "POST", "/hello"));
            lines.add(call(server, "GET", "/boom"));
            lines.add(call(server, "GET", "/WEB-INF/views/hello.jsp"));
        }
        return lines;
    }

    private static String call(EmbeddedServer server, String method, String path) throws Exception {
        Trace.clear();
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder(URI.create("http://127.0.0.1:" + server.port() + path))
                .method(method, HttpRequest.BodyPublishers.noBody())
                .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        StringBuilder out = new StringBuilder(method + " " + path + " -> " + response.statusCode());
        response.headers().firstValue("Allow").ifPresent(allow -> out.append(", Allow: ").append(allow));
        if (method.equals("GET") && path.equals("/hello")) {
            out.append(", body: ").append(response.body().replaceAll("\\s+", " ").trim());
        }
        for (String event : Trace.all()) {
            out.append("\n    ").append(event);
        }
        System.out.println(out);
        return out.toString();
    }
}

handler mappings: [beanNameHandlerMapping, requestMappingHandlerMapping, routerFunctionMapping]
handler adapters: [handlerFunctionAdapter, httpRequestHandlerAdapter, requestMappingHandlerAdapter, simpleControllerHandlerAdapter]
view resolvers: [mvcViewResolver]
mapped: {GET [/boom]} -> boom
mapped: {GET [/hello]} -> hello
GET /hello -> 200, body: <html><body><h1>Xin chao Spring MVC</h1></body></html>
    filter: before the servlet
    interceptor: preHandle for hello
    controller: hello()
    interceptor: postHandle, view = hello
    view: hello.jsp rendered
    interceptor: afterCompletion, exception = none
    filter: after the servlet
GET /nope -> 404
    filter: before the servlet
    filter: after the servlet
POST /hello -> 405, Allow: GET
    filter: before the servlet
    filter: after the servlet
GET /boom -> 500
    filter: before the servlet
    interceptor: preHandle for boom
    controller: boom()
    interceptor: afterCompletion, exception = IllegalStateException
    filter: after the servlet
GET /WEB-INF/views/hello.jsp -> 404