SpringMVC执行流程

最新推荐文章于 2024-05-11 23:15:03 发布

elk-zhang

最新推荐文章于 2024-05-11 23:15:03 发布

阅读量2.4k

点赞数

分类专栏： SpringMVC JAVA 文章标签：前端 java spring servlet mvc

本文链接：https://blog.csdn.net/m0_52982868/article/details/126414287

版权

JAVA 同时被 2 个专栏收录

133 篇文章 2 订阅

订阅专栏

SpringMVC

15 篇文章 1 订阅

订阅专栏

二、DispatcherServlet初始化过程

⚪FrameworkServlet 中的initServletBean方法（源码）

initServletBean中initWebApplicationContext 源码（创建IOC容器）

initWebApplicationContext中的onRefresh方法（源码）

DispatcherServlet中重写的 onRefresh方法（源码）

DispatcherServlet的初始化策略initStrategies （源码）

三、DispatcherServlet调用组件处理请求

⚪HttpServlet中对service方法进行了重写&重载编辑

⚪FrameWorkServlet中的service

四、SpringMVC的执行流程

一、SpringMVC常用组件

1.DispatcherServlet

前端控制器，不需要工程师开发，由框架提供

作用：统一处理请求和响应，整个流程控制的中心，由它调用其它组件处理用户的请求

2.HandlerMapping

处理器映射器，不需要工程师开发，由框架提供

作用：根据请求的url、method等信息查找Handler，即控制器方法

3.Handler

处理器，需要工程师开发

作用：在DispatcherServlet的控制下Handler对具体的用户请求进行处理

4.HandlerAdapter

处理器适配器，不需要工程师开发，由框架提供

作用：通过HandlerAdapter对处理器（控制器方法）进行执行

5.ViewResolver

视图解析器，不需要工程师开发，由框架提供

作用：进行视图解析，得到相应的视图，例如：ThymeleafView、InternalResourceView、 RedirectView

6.View

视图

作用：将模型数据通过页面展示给用户

二、DispatcherServlet初始化过程

DispatcherServlet 本质上是一个 Servlet，所以天然的遵循 Servlet 的生命周期。

因此宏观上是 Servlet 生命周期来进行调度。

public final void init() throws ServletException {
    PropertyValues pvs = new HttpServletBean.ServletConfigPropertyValues(this.getServletConfig(), this.requiredProperties);
    if (!pvs.isEmpty()) {
        try {
            BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
            ResourceLoader resourceLoader = new ServletContextResourceLoader(this.getServletContext());
            bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, this.getEnvironment()));
            this.initBeanWrapper(bw);
            bw.setPropertyValues(pvs, true);
        } catch (BeansException var4) {
            if (this.logger.isErrorEnabled()) {
                this.logger.error("Failed to set bean properties on servlet '" + this.getServletName() + "'", var4);
            }
            throw var4;
        }
    }
    this.initServletBean();
}

protected void initServletBean() throws ServletException {
}

⚪FrameworkServlet 中的initServletBean方法（源码）

protected final void initServletBean() throws ServletException {
    this.getServletContext().log("Initializing Spring " + 
    this.getClass().getSimpleName() + 
    " '" + 
    this.getServletName() + 
    "'");
    if (this.logger.isInfoEnabled()) {
        this.logger.info("Initializing Servlet '" + 
        this.getServletName() + "'");
    }
    long startTime = System.currentTimeMillis();
    try {
        //初始化SpringMVC的IOC容器
        this.webApplicationContext = this.initWebApplicationContext();
        this.initFrameworkServlet();
    } catch (RuntimeException | ServletException var4) {
        this.logger.error("Context initialization failed", var4);
        throw var4;
    }
    if (this.logger.isDebugEnabled()) {
        String value = this.enableLoggingRequestDetails ? 
        "shown which may lead to unsafe logging of potentially sensitive data" : 
        "masked to prevent unsafe logging of potentially sensitive data";
        this.logger.debug("enableLoggingRequestDetails='" + 
        this.enableLoggingRequestDetails + 
        "': request parameters and headers will be " + 
        value);
    }
    if (this.logger.isInfoEnabled()) {
        this.logger.info("Completed initialization in " + 
        (System.currentTimeMillis() - startTime) + " ms");
    }
}

initServletBean中initWebApplicationContext 源码（创建IOC容器）

protected WebApplicationContext initWebApplicationContext() {
    WebApplicationContext rootContext = WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());
    WebApplicationContext wac = null;
    if (this.webApplicationContext != null) {
        wac = this.webApplicationContext;
        if (wac instanceof ConfigurableWebApplicationContext) {
            ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext)wac;
            if (!cwac.isActive()) {
                if (cwac.getParent() == null) {
                   //设置当前SpringMVC的IOC容器的父容器
                    cwac.setParent(rootContext);
                }
                this.configureAndRefreshWebApplicationContext(cwac);
            }
        }
    }
    if (wac == null) {
        wac = this.findWebApplicationContext();
    }
    if (wac == null) {
        //创建IOC容器
        wac = this.createWebApplicationContext(rootContext);
    }
    if (!this.refreshEventReceived) {
        synchronized(this.onRefreshMonitor) {
            //刷新容器
            this.onRefresh(wac);
        }
    }
    if (this.publishContext) {
        String attrName = this.getServletContextAttributeName();
        //把SpringMVC容器共享到最大的域对象中
        this.getServletContext().setAttribute(attrName, wac);
    }
    return wac;
}

initWebApplicationContext中的onRefresh方法（源码）

protected void onRefresh(ApplicationContext context) {
}

DispatcherServlet中重写的 onRefresh方法（源码）

protected void onRefresh(ApplicationContext context) {
    //初始化策略
    this.initStrategies(context);
}

DispatcherServlet的初始化策略initStrategies （源码）

protected void initStrategies(ApplicationContext context) {
    this.initMultipartResolver(context);//初始化文件上传解析器
    this.initLocaleResolver(context);  //初始化本地解析器
    this.initThemeResolver(context);
    this.initHandlerMappings(context); //初始化处理器映射器，处理请求映射
    this.initHandlerAdapters(context); //初始化处理适配器，调用控制器方法
    this.initHandlerExceptionResolvers(context);  //初始化异常解析器
    this.initRequestToViewNameTranslator(context);
    this.initViewResolvers(context);  //初始化视图解析器
    this.initFlashMapManager(context);
}

三、DispatcherServlet调用组件处理请求

⚪HttpServlet中对service方法进行了重写&重载

重写的service

根据请求方式的不用调用不同的方法

protected void doTrace(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    String CRLF = "\r\n";
    StringBuilder buffer = (new StringBuilder("TRACE ")).append(req.getRequestURI()).append(" ").append(req.getProtocol())
    Enumeration reqHeaderEnum = req.getHeaderNames();
    while(reqHeaderEnum.hasMoreElements()) {
        String headerName = (String)reqHeaderEnum.nextElement();
        buffer.append(CRLF).append(headerName).append(": ").append(req.getHeader(headerName));
    }
    buffer.append(CRLF);
    int responseLength = buffer.length();
    resp.setContentType("message/http");
    resp.setContentLength(responseLength);
    ServletOutputStream out = resp.getOutputStream();
    out.print(buffer.toString());
}
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    String method = req.getMethod();
    long lastModified;
    if (method.equals("GET")) {
        lastModified = this.getLastModified(req);
        if (lastModified == -1L) {
            this.doGet(req, resp);
        } else {
            long ifModifiedSince = req.getDateHeader("If-Modified-Since");
            if (ifModifiedSince < lastModified) {
                this.maybeSetLastModified(resp, lastModified);
                this.doGet(req, resp);
            } else {
                resp.setStatus(304);
            }
        }
    } else if (method.equals("HEAD")) {
        lastModified = this.getLastModified(req);
        this.maybeSetLastModified(resp, lastModified);
        this.doHead(req, resp);
    } else if (method.equals("POST")) {
        this.doPost(req, resp);
    } else if (method.equals("PUT")) {
        this.doPut(req, resp);
    } else if (method.equals("DELETE")) {
        this.doDelete(req, resp);
    } else if (method.equals("OPTIONS")) {
        this.doOptions(req, resp);
    } else if (method.equals("TRACE")) {
        this.doTrace(req, resp);
    } else {
        String errMsg = lStrings.getString("http.method_not_implemented");
        Object[] errArgs = new Object[]{method};
        errMsg = MessageFormat.format(errMsg, errArgs);
        resp.sendError(501, errMsg);
    }
}

重载的service

public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
    if (req instanceof HttpServletRequest && res instanceof HttpServletResponse) {
        HttpServletRequest request = (HttpServletRequest)req;
        HttpServletResponse response = (HttpServletResponse)res;
        this.service(request, response);
    } else {
        throw new ServletException("non-HTTP request or response");
    }
}

⚪FrameWorkServlet中的service

protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
    if (httpMethod != HttpMethod.PATCH && httpMethod != null) {
        super.service(request, response);//调用HttpServlet中的方法
    } else {
        this.processRequest(request, response);
    }
}

FrameWorkServlet将以下方法都进行了重写

protected final void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    this.processRequest(request, response);
}
protected final void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    this.processRequest(request, response);
}
protected final void doPut(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    this.processRequest(request, response);
}
protected final void doDelete(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    this.processRequest(request, response);
}
protected void doOptions(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    if (this.dispatchOptionsRequest || CorsUtils.isPreFlightRequest(request)) {
        this.processRequest(request, response);
        if (response.containsHeader("Allow")) {
            return;
        }
    }
    super.doOptions(request, new HttpServletResponseWrapper(response) {
        public void setHeader(String name, String value) {
            if ("Allow".equals(name)) {
                value = (StringUtils.hasLength(value) ? value + ", " : "") + HttpMethod.PATCH.name();
            }
            super.setHeader(name, value);
        }
    });
}
protected void doTrace(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    if (this.dispatchTraceRequest) {
        this.processRequest(request, response);
        if ("message/http".equals(response.getContentType())) {
            return;
        }
    }
    super.doTrace(request, response);
}
protected final void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    long startTime = System.currentTimeMillis();
    Throwable failureCause = null;
    LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
    LocaleContext localeContext = this.buildLocaleContext(request);
    RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
    ServletRequestAttributes requestAttributes = this.buildRequestAttributes(request, response, previousAttributes);
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new FrameworkServlet.RequestBindingInterceptor());
    this.initContextHolders(request, localeContext, requestAttributes);
    try {
        this.doService(request, response);
    } catch (IOException | ServletException var16) {
        failureCause = var16;
        throw var16;
    } catch (Throwable var17) {
        failureCause = var17;
        throw new NestedServletException("Request processing failed", var17);
    } finally {
        this.resetContextHolders(request, previousLocaleContext, previousAttributes);
        if (requestAttributes != null) {
            requestAttributes.requestCompleted();
        }
        this.logResult(request, response, (Throwable)failureCause, asyncManager);
        this.publishRequestHandledEvent(request, response, startTime, (Throwable)failureCause);
    }
}