SpringMVC源码 3.3 DispatchServlet逻辑处理

最新推荐文章于 2024-08-05 17:30:25 发布
最新推荐文章于 2024-08-05 17:30:25 发布
阅读量302 收藏
点赞数
分类专栏： SpringMVC 文章标签： spring mvc 源码 spring DispatchServlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/mdq11111/article/details/79050171
版权
SpringMVC源码 3.3 DispatchServlet逻辑处理


FramewServlet请求引导
我们知道在HttpServlet中提供了相应的服务方法，他们是doDelete、doGet、doPost、doPut、doOption、doTrace，他们根据请求的不同形式引导至相应的函数进行处理。我们最常用的无非是doGet和doPost两个方法。
在FrameworkServlet对HttpServlet的各个do方法进行了重写。一下是doGet和doPost在FrameworkServlet中的实现。
在不同的方法中，Spring并没有做特殊处理，而是将程序再次统一引导至processRequest(request, response);方法
FrameworkServlet.doGet/doPost（）
@Override
protected final void doGet(HttpServletRequest request, HttpServletResponse response)
           throws ServletException, IOException {
      processRequest(request, response);
}
@Override
protected final void doPost(HttpServletRequest request, HttpServletResponse response)
           throws ServletException, IOException {
     processRequest(request, response);
}

FramewServlet和DispatchServlet对请求准备工作
在processRequest方法中，开始对请求做了一些处理，主要是一些准备工作，具体的细节继续封装到可doService函数中。主要做了以下的一些准备工作。
（1）为了保证当前的线程中的LocaleContext和RequestAttribute这两个属性在当前请求之后还能够被恢复，所以先提取这两个属性保存起来
（2）根据当前Request创建对应的LocaleContext和RequestAttribute，并绑定到当前线程
（3）将请求委托给doService函数，继续进行处理
（4）请求处理结束后，恢复线程到原始状态
（5）请求处理结束后无论成功与否都发布事件通知。
FrameworkServlet.processRequest（）
protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
           throws ServletException, IOException {

     long startTime = System.currentTimeMillis();
     Throwable failureCause = null;

     LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
     LocaleContext localeContext = buildLocaleContext(request);

     RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
     ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);

     WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
     asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());

     initContextHolders(request, localeContext, requestAttributes);

     try {
            doService(request, response);
     }catch (ServletException ex) {
           failureCause = ex;
           throw ex;
     }catch (IOException ex) {
           failureCause = ex;
           throw ex;
     }catch (Throwable ex) {
           failureCause = ex;
           throw new NestedServletException("Request processing failed", ex);
     }

     finally {
           resetContextHolders(request, previousLocaleContext, previousAttributes);
           if (requestAttributes != null) {
                requestAttributes.requestCompleted();
           }
           if (logger.isDebugEnabled()) {
                if (failureCause != null) {
                     this.logger.debug("Could not complete request", failureCause);
                }else {
                     if (asyncManager.isConcurrentHandlingStarted()) {
                           logger.debug("Leaving response open for concurrent processing");
                     }else {
                           this.logger.debug("Successfully completed request");
                     }
                }
           }

           publishRequestHandledEvent(request, response, startTime, failureCause);
     }
}

在DispatchServlet.doService（）中，仍然没有对Handler之类的处理。依旧是一些准备工作。
（1）将DispatchServlet初始化中创建的组件，添加到Request属性中，这些属性在接下来对Request的处理中使用。
（2）进入doDispatch函数，也就是真正的请求处理逻辑

DispatchServlet.doService（）
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
     if (logger.isDebugEnabled()) {
           .....
     }

     .......

      // Make framework objects available to handlers and view objects.
     request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
     request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
     request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
     request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
     FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
     if (inputFlashMap != null) {
           request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
     }
     request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
     request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);

     try {
            doDispatch(request, response);
     } finally {
           if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
                // Restore the original attribute snapshot, in case of an include.
                if (attributesSnapshot != null) {
                     restoreAttributesAfterInclude(request, attributesSnapshot);
                }
           }
     }
}


DispatchServlet真正的逻辑处理 doDispatch（）
在doDispatch函数中开始了真正处理请求的逻辑。主要分成以下几个步骤：
（1）检查是否存在MultipartResolver组件、是否为Multipart类型的Request。如果是的话返回MultipartHttpServletRequest
（2）通过request信息寻找可用的Handler
（3）已经获得了Handler的情况下，根据Handler匹配对应的HandlerAdapter
（4）调用Handler，返回视图
（5）对于视图的处理
DispatchServlet.doDispatch（）
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
     HttpServletRequest processedRequest = request;
     HandlerExecutionChain mappedHandler = null;
     boolean multipartRequestParsed = false;

     WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
     try {
           ModelAndView mv = null;
           Exception dispatchException = null;

           try {
               //判断是否存在MultipartResolver组件、判断是否为Multipart类型的Request，如果通过返回MultipartHttpServletRequest，不通过返回原来的request。
                 processedRequest = checkMultipart(request);
                multipartRequestParsed = (processedRequest != request);

                // Determine handler for the current request.
                // 根据request信息寻找可用的Handler。
                 mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                     //如果没有可以匹配的Handler则通过response返回错误信息
                     noHandlerFound(processedRequest, response);
                     return;
                }

                // Determine handler adapter for the current request.
                //根据当前可用的Handler寻找对应的HandlerAdapter
                 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                // Process last-modified header, if supported by the handler.
                String method = request.getMethod();
                boolean isGet = "GET".equals(method);
                if (isGet || "HEAD".equals(method)) {
                     long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                     if (logger.isDebugEnabled()) {
                           logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                     }
                     if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                           return;
                     }
                }

                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                     return;
                }

                // Actually invoke the handler.
                // 真正调用handler，并返回视图
                 mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                if (asyncManager.isConcurrentHandlingStarted()) {
                     return;
                }
                applyDefaultViewName(request, mv);
                mappedHandler.applyPostHandle(processedRequest, response, mv);
           } catch (Exception ex) {
                dispatchException = ex;
           }
           processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
     } catch (Exception ex) {
           triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
     } catch (Error err) {
           triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);
     } finally {
           if (asyncManager.isConcurrentHandlingStarted()) {
                // Instead of postHandle and afterCompletion
                if (mappedHandler != null) {
                     mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
           } else {
                // Clean up any resources used by a multipart request.
                if (multipartRequestParsed) {
                     cleanupMultipart(processedRequest);
                }
           }
     }
}



遍历HandlerMapping获取匹配Request的Handler
在getHandler函数中，遍历了DispatchServlet中初始化的HandlerMappings数组，顺序如下： RequestMappingHandlerMapping ，BeanNameUrlHandlerMapping， SimpleUrlHandlerMapping。
调用hm.getHandler,看是否能返回匹配的HandlerExecutionChain。hm.getHandler是定义在AbstractHandlerMapping中的。

其实在匹配过程中并不需要匹配HandlerMapping，只需要遍历HandlerMapping，然后去用这个HandlerMapping根据Request匹配出Handler，能匹配出Handler就可以了，然后通过HandlerExecutionChain返回
DispatchServlet.getHandler（）
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
     for (HandlerMapping hm : this.handlerMappings) {
           if (logger.isTraceEnabled()) {
                logger.trace("Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
           }
           HandlerExecutionChain handler = hm.getHandler(request);
           if (handler != null) {  return handler;  }
     }
     return null;
}


函数首先或调用getHandlerInternal函数，根据request获取对应的Handler.如果没有找到对应的Handler则会去匹配默认的Handler，还是没有找到默认的handler就会返回null。要是找到的Handler是String类型的时候，那就意味着返回的是配置的bean的名称，需要更具bean的名称在容器中找到对应的bean。最后通过getHandlerExecutionChain方法对Handler进行封装。
AbstractHandlerMapping .getHandler（）
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
      Object handler = getHandlerInternal(request);
     if (handler == null) {
           handler = getDefaultHandler();
     }
     if (handler == null) {
           return null;
     }
     // Bean name or resolved handler?
     if (handler instanceof String) {
           String handlerName = (String) handler;
           handler = getApplicationContext().getBean(handlerName);
     }
     return getHandlerExecutionChain(handler, request);
}

在AbstractHandlerMethodMapping和AbstractURLHandlerMapping中对getHandlerInternal(request)有具体的实现。也是从HandlerMapping中匹配出Handler具体逻辑。
AbstractHandlerMapping
----AbstractHandlerMethodMapping<T>
--------RequestMappingInfoHandlerMapping extends AbstractHandlerMethodMapping<RequestMappingInfo>
------------RequestMappingHandlerMapping （代替了原来的DefaultAnnotationHandlerMapping）
----AbstractURLHandlerMapping
--------BeanNameUrlHandlerMapping
--------SimpleUrlHandlerMapping
--------DefaultAnnotationHandlerMapping（废弃）


（1）首先根据request信息获取对应的request路径lookupPath
（2）通过lookupPath在RequestMappingInfoHandlerMapping.urlMap中匹配出对应的RequestMappingInfo。
MultiValueMap<String, > urlMap = new LinkedMultiValueMap<String, RequestMappingInfo >();
（3）已经获取了requestUri对应的RequestMappingInfo，然后根据RequestMappingInfo从RequestMappingInfoHandlerMapping.handlerMethods中获取HandlerMethod
Map<RequestMappingInfo , HandlerMethod> handlerMethods = new LinkedHashMap<RequestMappingInfo , HandlerMethod>();
（4）将HandlerMethod封装为HandlerExecutionXChain

额外：
urlMap， handlerMethods这两个RequestMappingHandlerMapping中的属性，是在初始化的时候加载的。加载了@Controller和@RequestMapping注解的类和函数
afterPropertiesSet() -> initHandlerMethods() -> detectHandlerMethods(String beanName); 中查看源代码。
（1）在ApplicationContext中获取所有的bean的name。String[] beanNames = getApplicationContext().getBeanNamesForType(Object.class)
（2）遍历beanNames，判断是不是RequestMappingHandlerMapping需要的Handler。
protected boolean isHandler(Class<?> beanType) {
      return ((AnnotationUtils.findAnnotation(beanType, Controller.class) != null) ||
            (AnnotationUtils.findAnnotation(beanType, RequestMapping.class) != null));
}
（3）根据匹配出来的bean，然后从中@RequestMapping定义的uri和对应的方法MethodHandler组成对应

AbstractHandlerMethodMapping.gethandlerInternal（）
AbstractHandlerMethodMapping.lookupHandlerMethod（）
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
     //根据request获取对应的路径，  请求路径为/captchaService/v1/getCaptcha，lookupPath为/v1/getCaptcha，去掉了ContentPath，留下了RequestUri
     String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
     if (logger.isDebugEnabled()) {
           logger.debug("Looking up handler method for path " + lookupPath);
     }
     //匹配需要的Handler
      HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
     if (logger.isDebugEnabled()) {
           ........
     }
     return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
}
protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
     List<Match> matches = new ArrayList<Match>();
      List< RequestMappingInfo > directPathMatches = this.urlMap.get(lookupPath);
     if (directPathMatches != null) {
            addMatchingMappings(directPathMatches, matches, request);
     }
     if (matches.isEmpty()) {
           // No choice but to go through all mappings...
           addMatchingMappings(this.handlerMethods.keySet(), matches, request);
     }

     if (!matches.isEmpty()) {
           Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
           Collections.sort(matches, comparator);
           if (logger.isTraceEnabled()) {
                logger.trace("Found " + matches.size() + " matching mapping(s) for [" + lookupPath + "] : " + matches);
           }
           Match bestMatch = matches.get(0);
           if (matches.size() > 1) {
                Match secondBestMatch = matches.get(1);
                if (comparator.compare(bestMatch, secondBestMatch) == 0) {
                     Method m1 = bestMatch.handlerMethod.getMethod();
                     Method m2 = secondBestMatch.handlerMethod.getMethod();
                     throw new IllegalStateException(
                                "Ambiguous handler methods mapped for HTTP path '" + request.getRequestURL() + "': {" +
                                m1 + ", " + m2 + "}");
                }
           }
           handleMatch(bestMatch.mapping, lookupPath, request);
            return bestMatch.handlerMethod;
     }
     else {
           return handleNoMatch(handlerMethods.keySet(), lookupPath, request);
     }
}
private void addMatchingMappings(Collection<RequestMappingInfo> mappings, List<Match> matches, HttpServletRequest request) {
     for (RequestMappingInfo mapping : mappings) {
           RequestMappingInfo match = getMatchingMapping(mapping, request);
           if (match != null) {
                 matches.add(new Match(match, this.handlerMethods.get(mapping)));
           }
     }
}


根据获取到Handler匹配合适的HandlerAdapter

遍历HandlerAdapter，然后匹配当前hanler是否满足要求，如果满足则返回这个HandlerAdapter
protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
     for (HandlerAdapter ha : this.handlerAdapters) {
           if (logger.isTraceEnabled()) {
                logger.trace("Testing handler adapter [" + ha + "]");
           }
           if ( ha.supports(handler) ) {
                return ha;
           }
     }
     throw new ServletException("No adapter for handler [" + handler +
                "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

HttpRequestHandlerAdapter
public boolean supports(Object handler) {
     return (handler instanceof HttpRequestHandler);
}
SimpleControllerHandlerAdapter
public boolean supports(Object handler) {
     return (handler instanceof Controller);
}
AbstractHandlerMethodAdapter
public final boolean supports(Object handler) {
     return (handler instanceof HandlerMethod && true);
}


使用HandlerAdapter处理Handler,获取请求结果















DispatcherServlet浅析
q1472750149的博客
02-07 6129
介绍 ​ DispatcherServlet是一个Servlet，在springmvc中被称为前端控制器，根据请求的路径、类型等进行请求的分发。 分析 DispatcherServlet类图 ​ 上图中的红色部分为Servlet接口，在Springmvc中实现并扩展了该Servlet接口。在我最早学javaweb开发时，并不是上来就使用各种MVC框架，而是从编写简单的Servlet开始，就是继承HttpServlet后，重写它的service方法。而Springmvc的设计同理，它也继承...
Spring启动流程（原理）详解--结合web.xml加载配置分析
骏马逸动，心随你动的博客
08-06 5127
注：文章内容有点多，可以先总体大概浏览一遍，心中有个整体类目关系构图，再详细看，不至于迷失在细节中，最好本地也使用开发工具打开源码对着看。 引言： Spring框架已经成为目前JavaEE企业应用的主流框架，它提供了一个全面的编程和配置模型，适用于任何类型的部署平台。 Spring的一个关键元素是应用程序级别的基础设施支持：Spring专注于企业应用程序的“管道”，这样我们开发人员就可以...
SpringMVC核心分发器DispatcherServlet分析[附带源码分析]
weixin_33730836的博客
06-22 260
目录 前言 DispatcherServlet初始化过程 DispatcherServlet处理请求过程 总结 参考资料 前言 SpringMVC是目前主流的Web MVC框架之一。 如果有同学对它不熟悉，那么请参考它的入门blog：http://www.cnblogs.com/fangjian0423/p/springMVC-introduction.html 本文将...
dispatchservlet
Liuqz2009的专栏
02-25 257
1、SpringBoot配置DispatcherServlet 2、SpringBoot 整合SpringMvc 原理探究（DispatchServlet添加流程）
DispatchServlet
开心的哈士奇
12-01 5751
介绍 dispatchServlet 俗称前端控制器，springmvc处理一切前端请求的入口所在，包括两个部分 Servlet WebApplicationContext和Root WebApplicationContext 官方图片如下： DispatchServlet注解式配置 在servlet2.5 时，原有的配置是在web.xml中定义的，定义如下： &amp;amp;lt;web-app&amp;amp;gt; ...
DispatchServlet---Spring MVC
最新发布
我爱JAVA
08-05 1993
DispatcherServlet 是 Spring MVC 框架的核心组件之一，它负责处理所有的 HTTP 请求，并将请求分发给相应的控制器进行处理。
SpringBoot（尚硅谷）
Xgg0210的博客
06-29 1181
一、Spring与SpringBoot 1、Spring能做什么 1.1、Spring的能力 . 1.2、Spring的生态 web开发 数据访问 安全控制 分布式 消息服务 移动开发 批处理 … . 1.3、Spring5重大升级 a>响应式编程 b>内部源码设计 基于Java8的一些新特性，如：接口默认实现。重新设计源码架构 . . 2、为什么用SpringBoot Spring Boot makes it easy to create stand-alone, product
Spring之DispatchServlet
newbaby2012的专栏
01-17 586
先谈谈HttpServletRequest 里面有个coreRequest，其实这个是Tomcat通过门面模式封装的一个Request coyoteRequest里面有个headers，从Mime就能知道，这个是浏览器头，因为我们从浏览器发出的请求 === MimeHeaders === host = localhost:8080 connection = keep-alive cache-control = max-age=0 sec-ch-ua = " Not;A Brand";v=..
Spring dispatchServlet
hjxllxw的博客
03-07 250
Spring Web MVC：DispatcherServlet
听海边涛声
03-18 1165
Spring Web MVC：DispatcherServlet
手写SpringMVC简易DispatchServlet
村里的原振侠的博客
11-18 351
手写SpringMVC简易DispatchServlet SpringMVC中的DispatchServlet使用了适配器模式，来适配Controller类。当需要新增Controller类的时候，可以在不修改原有框架代码的基础上，添加HandlerAdapter类即可正常工作。 Controller类 public interface Controller { } class AnnotationController implements Controller { public void do
DispatcherServlet概述
z_ssyy的博客
01-01 1034
前言：本文首先简单介绍下DispatcherServlet及其特殊的Bean，然后学习如何通 过注解的方式实现页面控制器。 本篇文章重点关注以下问题： 简述DispatcherServlet 注解式控制器详解 1. DispatcherServlet概述 DispatcherServlet是前端控制器设计模式的实现，提供Spring Web MVC的 集中访问点，而且负责职责的分派，而且与Spri...
DispatchServlet的分析
weixin_34233856的博客
04-29 143
2019独角兽企业重金招聘Python工程师标准>>> ...
DispatcherServlet详解
热门推荐
weixin_44399827的博客
08-01 1万+
在介绍DispatcherServlet的时候，我们得先了解 ，servlet。那什么时候servlet勒。 servlet是基于http协议的，在服务端(如Tomcate)运行的，是按照servlet规范编写的一个Java类。做Java Web开发的应该都了解它。主要用于处理客户端的请求并将其结果发送至客户端。servlet的生命周期可分三个阶段：初始化、运行和销毁。 1.初始化阶段 (1) servlet容器加载servlet类，把servlet类的.class文件中的数据读至内存中。 (2) se
DispatcherServlet、拦截器、处理器详解(通俗易懂)
zxyhj的博客
08-02 1014
​ 想象一下你去一个大型办公楼寻找特定的办公室。你到达大厅，遇到一个接待员（DispatcherServlet）。你告诉接待员你要找的办公室（请求的URL），接待员会根据你提供的信息来帮助你找到正确的房间。​ 在这个过程中，接待员并不直接提供你所需的服务（处理请求）。相反，他会根据你的需求（请求）帮你指引到合适的地方。可能他会告诉你去某个楼层（Controller）找某个部门（处理请求的方法），然后你在那个部门里会得到你想要的服务（处理请求的结果）。
DispatchServlet流程 - 1
Super_Me_Jason的博客
04-12 726
DispatchServlet执行请求之前，需要执行一系列方法，主要用于初始化组件：HttpServletBean的init()核心代码：    public final void init() throws ServletException {  // Set bean properties from init parameters.                // Servlet初始化参...
DispatcherServlet详细分析
w727655308的博客
10-18 839
DispatcherServlet DispatcherServlet分析 DispatcherServlet处理流程 DispatcherServlet初始化DispatcherServlet工作流程
SpringFramework之DispatcherServlet的getHandler简析
weixin_33805557的博客
06-09 276
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring进阶 - SpringMVC实现原理之DispatcherServlet处理请求的过程
珍惜当下
12-05 1134
前文我们有了IOC的源码基础以及SpringMVC的基础，我们便可以进一步深入理解SpringMVC主要实现原理，包含DispatcherServlet的初始化过程和DispatcherServlet处理请求的过程的源码解析。本文是第二篇：DispatcherServlet处理请求的过程的源码解析。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值