SpringMVC之DispatcherServlet组件

零、总结

SpringMVC的核心处理流程：

请求到达 DispatcherServlet

DispatcherServlet 接收到请求后，通过 HandlerMapping 将 请求 映射 到对应的处理器（Controller）上

处理器方法 执行具体业务逻辑，并返回 Model And View

DispatcherServlet 使用 视图解析器 将 逻辑视图名 解析为具体的视图对象，并生成响应内容（例如 HTML 页面

DispatcherServlet 将生成的响应内容返回给客户端

DispatcherServlet ：负责请求的分发、处理器的调用、视图的解析和呈现，以及拦截器的调用等任务，是整个 Spring MVC 框架的核心组件之一

核心请求分发方法 doDispatch()

一、SpringMVC的核心处理流程

1. 请求到达 DispatcherServlet
   
   
2. DispatcherServlet 的请求处理：

• DispatcherServlet 接收到请求后，会通过 HandlerMapping 找到处理该请求的 Controller。
  
  

3. 处理器映射（Handler Mapping）：

• HandlerMapping 将请求映射到对应的处理器（Controller）上。
  
  

4. 处理器执行：

• DispatcherServlet 调用处理器（Controller）的适当方法来处理请求。这个方法执行业务逻辑，并返回 Model 对象和逻辑视图名。
  
  

5. 视图解析器解析逻辑视图名：

• DispatcherServlet 使用视图解析器（ViewResolver）将逻辑视图名解析为具体的视图对象。
  
  

6. 视图渲染：

• DispatcherServlet 将 Model 对象传递给视图，视图使用 Model 中的数据生成响应内容（例如 HTML 页面）。
  
  

7. 响应返回客户端：

• DispatcherServlet 将生成的响应内容返回给客户端。
  
  

二、DispatcherServlet

SpringMVC提供了 DispatcherServlet ，可以负责请求的分发、处理器的调用、视图的解析和呈现，以及拦截器的调用等任务，是整个 Spring MVC 框架的核心组件之一

1、init()方法

处理了 WebApplicationContext 的创建和初始化，还有设置和配置 Servlet 环境，注册和初始化 Servlet 的内部组件以及其他自定义的初始化操作等


WebApplicationContext 是 Spring 框架中用于管理 Web 应用程序配置信息的上下文接口。它扩展了普通的 Spring 应用上下文 ApplicationContext，并添加了一些特定于 Web 应用的功能和特性。（WebApplicationContext 是 ApplicationContext 接口的一个子接口）

2、doDispatch()方法

DispatcherServlet 中的 doDispatch() 方法是核心的请求分发方法，用于将请求分发给适当的处理器（Handler）进行处理。在请求处理过程中，还会涉及参数绑定、数据验证、视图解析等其他操作。

// 简化版
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    // 获取请求处理器（通过 HandlerMapping 建立请求URL和Handler方法之间的映射关系）
    // 遍历所有的处理器映射器，尝试从中找到适合当前请求的处理器，并返回执行链（HandlerExecutionChain）
    HandlerExecutionChain handler = getHandler(request);
    if (handler == null) {
        // 如果没有合适的处理器，返回 404 错误
        response.sendError(HttpServletResponse.SC_NOT_FOUND);
        return;
    }

	// 应用请求预处理器
    if (!applyPreHandle(request, response, executionChain.getInterceptors())) {
        return;
    }

    // 找多Handler对应的请求处理器
    HandlerAdapter handlerAdapter = getHandlerAdapter(handler.getHandler());
    // 执行Handler方法
    handlerAdapter.handle(request, response, handler.getHandler());
 
 	// 应用请求后处理器
    applyPostHandle(request, response, executionChain.getInterceptors(), executionChain.getHandler());

	// 触发请求完成后的处理
    triggerAfterCompletion(request, response, null);


	protected boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response, HandlerInterceptor[] interceptors) throws Exception {
	    if (interceptors != null) {
	        // 遍历所有的请求预处理器（拦截器）
	        for (int i = 0; i < interceptors.length; i++) {
	            HandlerInterceptor interceptor = interceptors[i];
	            // 调用请求预处理器的preHandle()方法
	            if (!interceptor.preHandle(request, response, handler)) {
	                // 如果某个预处理器返回false，表示拦截请求，直接返回false
	                triggerAfterCompletion(request, response, null, new Exception("Interceptor[" + interceptor + "] preHandle return false"));
	                return false;
	            }
	        }
	    }
	    // 所有的预处理器都通过，返回true
	    return true;
    }


	protected void applyPostHandle(HttpServletRequest request, HttpServletResponse response, HandlerInterceptor[] interceptors, Object handler) throws Exception {
	    if (interceptors != null) {
	        // 逆序遍历所有的请求后处理器（拦截器）
	        for (int i = interceptors.length - 1; i >= 0; i--) {
	            HandlerInterceptor interceptor = interceptors[i];
	            // 调用请求后处理器的postHandle()方法
	            interceptor.postHandle(request, response, handler, null);
	        }
	    }
	}
}

3、AbstractAnnotationConfigDispatcherServletInitializer类

是 WebApplicationInitializer 接口的一个抽象实现，
可以通过继承 AbstractAnnotationConfigDispatcherServletInitializer 类，并重写其中的方法，来实现自定义的初始化配置，不需要传统的 web.xml 文件
Spring Boot 提供了自动配置机制，会自动配置 Spring MVC 环境，包括注册 DispatcherServlet、处理器映射器、处理器适配器、视图解析器等，无需手动配置。

// 简化版
public abstract class AbstractAnnotationConfigDispatcherServletInitializer
        implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        // 创建根上下文
        AnnotationConfigWebApplicationContext rootContext = new AnnotationConfigWebApplicationContext();
        Class<?>[] rootConfigClasses = getRootConfigClasses();
        if (rootConfigClasses != null && rootConfigClasses.length > 0) {
            rootContext.register(rootConfigClasses);
        }

        // 创建 DispatcherServlet 上下文
        AnnotationConfigWebApplicationContext servletContext = new AnnotationConfigWebApplicationContext();
        Class<?>[] servletConfigClasses = getServletConfigClasses();
        if (servletConfigClasses != null && servletConfigClasses.length > 0) {
            servletContext.register(servletConfigClasses);
        }

        // 注册 DispatcherServlet
        DispatcherServlet dispatcherServlet = new DispatcherServlet(servletContext);
        ServletRegistration.Dynamic dispatcher = servletContext.addServlet("dispatcher", dispatcherServlet);
        dispatcher.addMapping(getServletMappings());

        // 添加额外的配置
        customizeRegistration(dispatcher);
    }

	// 用于配置 Spring 根上下文（即应用程序上下文）的配置类
    protected abstract Class<?>[] getRootConfigClasses();
    
	// 用于配置 DispatcherServlet 的上下文（即 Web 上下文）的配置类
    protected abstract Class<?>[] getServletConfigClasses();

	// 用于配置 DispatcherServlet 的映射
    protected abstract String[] getServletMappings();

    protected void customizeRegistration(ServletRegistration.Dynamic registration) {
    }
}

public class MyWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class[] { RootConfig.class };
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class[] { ServletConfig.class };
    }

    @Override
    protected String[] getServletMappings() {
        return new String[] { "/" };
    }
}