springmvc源码核心代码段

ゝ一纸荒年。 2023-10-14 18:37 24阅读 0赞

#### 一、DispatcherServlet ####

客户端http请求，首先到达

doService，然后由doService调用如下分发方法进行处理。

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;  // 处理后的请求对象，初始值为传入的请求对象
        HandlerExecutionChain mappedHandler = null;  // 处理请求的处理器链，初始值为空
    
        boolean multipartRequestParsed = false;  // 是否解析了多部分请求标志，默认为 false
    
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);  // 获取异步请求管理器
    
        try {
            ModelAndView mv = null;  // 视图与模型对象，用于处理请求结果
            Exception dispatchException = null;  // 分发过程中可能出现的异常
    
            try {
                processedRequest = checkMultipart(request);  // 检查是否是多部分请求，可能会更新 processedRequest
                multipartRequestParsed = (processedRequest != request);  // 如果更新了 processedRequest，则标志为 true
    
                // 确定当前请求的处理器
                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null) {
                    noHandlerFound(processedRequest, response);  // 如果没有找到合适的处理器，处理 404 错误
                    return;
                }
    
                // 确定当前请求的处理器适配器
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    
                // 处理 Last-Modified 头部，如果处理器支持
                String method = request.getMethod();
                boolean isGet = HttpMethod.GET.matches(method);
                if (isGet || HttpMethod.HEAD.matches(method)) {
                    long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                    if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                        return;  // 如果请求未修改且为 GET 请求，则直接返回
                    }
                }
    
                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;  // 如果前置处理返回 false，直接返回
                }
    
                // 实际调用处理器方法
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    
                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;  // 如果是异步处理，直接返回
                }
    
                applyDefaultViewName(processedRequest, mv);  // 应用默认视图名
                mappedHandler.applyPostHandle(processedRequest, response, mv);  // 应用后置处理
            } catch (Exception ex) {
                dispatchException = ex;  // 捕获处理过程中的异常
            } catch (Throwable err) {
                // 从 4.3 版本开始，也处理处理器方法中抛出的错误，
                // 以便让 @ExceptionHandler 方法和其他场景可以捕获处理
                dispatchException = new NestedServletException("Handler dispatch failed", err);
            }
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);  // 处理分发结果
        } catch (Exception ex) {
            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);  // 处理分发过程中的异常
        } catch (Throwable err) {
            triggerAfterCompletion(processedRequest, response, mappedHandler,
                    new NestedServletException("Handler processing failed", err));  // 处理分发过程中的错误
        } finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                // 如果是并发处理，执行并发处理开始后的操作
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            } else {
                // 清理多部分请求使用的资源
                if (multipartRequestParsed) {
                    cleanupMultipart(processedRequest);
                }
            }
        }
    }