SpringMVC处理流程非常详细的讲解

1 请求入口

public class DispatcherServlet extends FrameworkServlet {
   protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
     HandlerExecutionChain mappedHandler = null;
     try {
       ModelAndView mv = null;
       Exception dispatchException = null;
       try {
         // 2.1.通过HandlerMapping获取请求处理链，该对象由处理程序（Controller，一般HandlerMethod对象）及拦截器（Interceptor）组成
         mappedHandler = getHandler(processedRequest);
         if (mappedHandler == null) {
           noHandlerFound(processedRequest, response);
           return;
         }
         // 2.2.根据2.1获取的处理程序（HandlerMethod）对象确定能够处理该处理程序的HandlerAdapter对象
         HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
         // ...
         // 2.3.执行处理程序之前，执行拦截器preHandle方法，如果返回了false，本次请求将被终止
         if (!mappedHandler.applyPreHandle(processedRequest, response)) {
           return;
         }
 
         // 2.4.真正的执行处理程序
         mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
         // ...
         // 2.5.执行处理程序之后，执行拦截器postHandle方法
         mappedHandler.applyPostHandle(processedRequest, response, mv);
       } catch (Exception ex) {
         dispatchException = ex;
       } catch (Throwable err) {
         dispatchException = new NestedServletException("Handler dispatch failed", err);
       }
       // 2.6.处理结果，根据处理程序是否发生异常，是否返回有ModelAndView对象进行结果的处理
       processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
     }
     // ...
   }
 }

2 处理请求

2.1 获取请求处理链

该步骤通过HandlerMapping获取HandlerExecutionChain处理器执行链。

public class DispatcherServlet {
   protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
     if (this.handlerMappings != null) {
       // 遍历当前容器中注册的所有HandlerMapping对象
       for (HandlerMapping mapping : this.handlerMappings) {
         // 针对Controller接口，使用的是RequestMappingHandlerMapping对象
         HandlerExecutionChain handler = mapping.getHandler(request);
         if (handler != null) {
           return handler;
         }
       }
     }
     return null;
   }
 }

这里以RequestMappingHandlerMapping为例

mapping.getHandler(request)方法调用流程如下：

public abstract class AbstractHandlerMapping {
   public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
     // 调用子类实现的getHandlerInternal方法
     Object handler = getHandlerInternal(request);
     // ...
     // 根据查找到的处理程序封装到处理程序执行链
     // 这里会将拦截器也添加其中
     HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
     // ...这里是跨域相关的配置
     return executionChain;
   }
   protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
     HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
         (HandlerExecutionChain) handler : new HandlerExecutionChain(handler));
     for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
       if (interceptor instanceof MappedInterceptor) {
         MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
         if (mappedInterceptor.matches(request)) {
           chain.addInterceptor(mappedInterceptor.getInterceptor());
         }
       } else {
         chain.addInterceptor(interceptor);
       }
     }
     return chain;
   }
 }

调用子类RequestMappingInfoHandlerMapping#getHandlerInternal实现。

public abstract class RequestMappingInfoHandlerMapping extends AbstractHandlerMethodMapping {
   protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
     request.removeAttribute(PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);
     try {
       // 又调父类的实现 (⊙o⊙)…
       return super.getHandlerInternal(request);
     }
   }
}

调用父类AbstractHandlerMethodMapping#getHandlerInternal方法

public abstract class AbstractHandlerMethodMapping extends AbstractHandlerMapping implements InitializingBean {
   private final MappingRegistry mappingRegistry = new MappingRegistry();
   protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
     // 根据当前的请求获取请求的uri
     String lookupPath = initLookupPath(request);
     this.mappingRegistry.acquireReadLock();
     try {
       HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
       return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
     }
   }
   protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
     List matches = new ArrayList<>();
     // 系统启动时初始化RequestMappingHandlerMapping解析了整个系统中所有的Controller然后注册到MappingRegistry中
     // 根据当前的请求uri，对应List对象,相同的uri可能对应不同的request method，所以这里返回的是List集合
     List directPathMatches = this.mappingRegistry.getMappingsByDirectPath(lookupPath);
     if (directPathMatches != null) {
       // 该方法内部会根据找到的RequestMappingInfo进行遍历，根据请求信息逐个的判断对应@RequestMapping配置的属性是否匹配
       addMatchingMappings(directPathMatches, matches, request);
     }
     if (matches.isEmpty()) {
       addMatchingMappings(this.mappingRegistry.getRegistrations().keySet(), matches, request);
     }
     // 下面if的逻辑就是判断如果找到了匹配并且存在多个会找出最合适的
     if (!matches.isEmpty()) {
       Match bestMatch = matches.get(0);
       if (matches.size() > 1) {
         Comparator comparator = new MatchComparator(getMappingComparator(request));
         matches.sort(comparator);
         bestMatch = matches.get(0);
         if (CorsUtils.isPreFlightRequest(request)) {
           for (Match match : matches) {
             if (match.hasCorsConfig()) {
               return PREFLIGHT_AMBIGUOUS_MATCH;
             }
           }
         } else {
           Match secondBestMatch = matches.get(1);
           if (comparator.compare(bestMatch, secondBestMatch) == 0) {
             Method m1 = bestMatch.getHandlerMethod().getMethod();
             Method m2 = secondBestMatch.getHandlerMethod().getMethod();
             String uri = request.getRequestURI();
             throw new IllegalStateException(
                 "Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}");
           }
         }
       }
       request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.getHandlerMethod());
       // 将当前请求uri保存到request对象中setAttribute
       handleMatch(bestMatch.mapping, lookupPath, request);
       // 返回当前uri对应的HandlerMethod对象
       return bestMatch.getHandlerMethod();
     }
   }
   protected void handleMatch(T mapping, String lookupPath, HttpServletRequest request) {
     request.setAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, lookupPath);
   }
 }

2.2 获取HandlerAdapter

在上一步中通过HandlerMapping找到了相应的HandlerMethod对象，最后封装到了HandlerExecutionChain中，接下来就是根据HandlerMethod查找合适的HandlerAdapter处理程序。

public class DispatcherServlet {
   protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
     if (this.handlerAdapters != null) {
       // 这里的参数handler一般都是HandlerMethod对象
       for (HandlerAdapter adapter : this.handlerAdapters) {
         // 这个根据handler判断哪个HandlerAdapter支持，一般都是RequestMappingHandlerAdapter
         if (adapter.supports(handler)) {
           return adapter;
         }
       }
     }
     throw new ServletException("No adapter for handler [" + handler +
         "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
   }
 }

RequestMappingHandlerAdapter 这调用的是父类方法

public abstract class AbstractHandlerMethodAdapter {
  public final boolean supports(Object handler) {
    return (handler instanceof HandlerMethod && supportsInternal((HandlerMethod) handler));
  }
}
public class RequestMappingHandlerAdapter {
  protected boolean supportsInternal(HandlerMethod handlerMethod) {
    return true;
  }
}

2.3 执行拦截器preHandle方法

在真正调用处理程序前，执行拦截器preHandle方法

public class HandlerExecutionChain {
   boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
     for (int i = 0; i < this.interceptorList.size(); i++) {
       HandlerInterceptor interceptor = this.interceptorList.get(i);
       // 如果任何一个拦截器返回了false，本次请求都会被终止
       if (!interceptor.preHandle(request, response, this.handler)) {
         // 该拦截器的完成回调会被执行
         triggerAfterCompletion(request, response, null);
         return false;
       }
       this.interceptorIndex = i;
     }
     return true;
   }
 }

2.4 实际请求处理

public class DispatcherServlet {
   protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
     mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
   }
 }

AbstractHandlerMethodAdapter

public abstract class AbstractHandlerMethodAdapter {
   public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
       throws Exception {
     // 子类重写了该方法
     return handleInternal(request, response, (HandlerMethod) handler);
   }
 }

RequestMappingHandlerAdapter

public class RequestMappingHandlerAdapter {
   protected ModelAndView handleInternal(HttpServletRequest request, 
       HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
     ModelAndView mav;
     if (this.synchronizeOnSession) {
       // ...
     } else {
       // No synchronization on session demanded at all...
       // 执行HandlerMethod调用
       mav = invokeHandlerMethod(request, response, handlerMethod);
     }
     // ...
     return mav;
   }
   protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
       HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
 
     ServletWebRequest webRequest = new ServletWebRequest(request, response);
     try {
       // 创建数据绑定工厂，主要作用就是将请求的参数信息与Controller方法的参数进行绑定（数据类型的转换）及参数校验
       WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
       // 处理@ModelAttribute和@SessionAttribute注解，它将做两件事：
       // 1.将@SessionAttribute注解的方法的相关数据合并到下面的ModelAndViewContainer中
       // 2.将@ModelAttribute注解的方法返回值添加到ModelAndViewContainer中
       ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
       // 实际HandlerMethod调用对象
       ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
       if (this.argumentResolvers != null) {
         // 设置参数解析器
         invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
       }
       if (this.returnValueHandlers != null) {
         // 设置Controller方法返回值的处理器
         invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
       }
       invocableMethod.setDataBinderFactory(binderFactory);
       invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
 
       ModelAndViewContainer mavContainer = new ModelAndViewContainer();
       mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
       // 执行上面说的两个步骤
       modelFactory.initModel(webRequest, mavContainer, invocableMethod);
       mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
       // ...
       // 执行调用HandlerMethod
       // 在这个过程中会应用到参数解析器和返回值处理器，这里就不展开说了
       invocableMethod.invokeAndHandle(webRequest, mavContainer);
       if (asyncManager.isConcurrentHandlingStarted()) {
         return null;
       }
       // 这里会返回ModelAndView对象，这个根据情况，如果你是RestController，那么在通过返回值处理器就已经将结果进行了输出如使用@ResponseBody注解的方法
       // 如果是RestController，请求结果就提前输出了，同时会将ModelAndViewContainer的requestHandled属性设置为true。
       return getModelAndView(mavContainer, modelFactory, webRequest);
     } finally {
       webRequest.requestCompleted();
     }
   }
   private ModelAndView getModelAndView(ModelAndViewContainer mavContainer,
       ModelFactory modelFactory, NativeWebRequest webRequest) throws Exception {
 
     modelFactory.updateModel(webRequest, mavContainer);
     // 如果是@ResponseBody注解的方法，那么直接返回null
     if (mavContainer.isRequestHandled()) {
       return null;
     }
     ModelMap model = mavContainer.getModel();
     ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, mavContainer.getStatus());
     if (!mavContainer.isViewReference()) {
       mav.setView((View) mavContainer.getView());
     }
     // ...
     return mav;
   }
 }

2.5 执行拦截器postHandle方法

public class HandlerExecutionChain {
   void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
       throws Exception {
     for (int i = this.interceptorList.size() - 1; i >= 0; i--) {
       HandlerInterceptor interceptor = this.interceptorList.get(i);
       interceptor.postHandle(request, response, this.handler, mv);
     }
   }
}

2.6 处理结果

public class DispatcherServlet {
   protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
     processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
   }
   private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
       @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
       @Nullable Exception exception) throws Exception {
 
     boolean errorView = false;
 
     // 在处理过程中如果出现了异常会进入这里进行异常处理
     if (exception != null) {
       if (exception instanceof ModelAndViewDefiningException) {
         logger.debug("ModelAndViewDefiningException encountered", exception);
         mv = ((ModelAndViewDefiningException) exception).getModelAndView();
       }
       else {
         Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
         mv = processHandlerException(request, response, handler, exception);
         errorView = (mv != null);
       }
     }
 
     // 如果Controller方法返回有ModelAndView
     if (mv != null && !mv.wasCleared()) {
       // 进行视图的渲染输出到客户端
       render(mv, request, response);
       if (errorView) {
         WebUtils.clearErrorRequestAttributes(request);
       }
     }
 
     if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
       // Concurrent handling started during a forward
       return;
     }
 
     // 如果是RestController接口，那么上面的代码都不会执行
     if (mappedHandler != null) {
       // 执行拦截器的afterCompletion回调方法
       mappedHandler.triggerAfterCompletion(request, response, null);
     }
   }
 }

当前名称：SpringMVC处理流程非常详细的讲解
分享地址：http://www.csdahua.cn/qtweb/news24/337974.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

解决方案知识

行业网站建设

盐亭网站设计　　 　瑞杰企业管理　　 　宜宾网站建设　　 　彭州做网站　　 　德阳东方电机技改服务有限公司　　 　成都楼顶广告牌　　 　成都微信公众号开发　　 　腾讯云免备案主机　　 　水泥基自流平　　 　营销网站建设　　 　成都微信二次开发公司　　 　网站空间　　 　西部信息机房　　 　柴油发电机租赁　　 　雅安主机托管　　 　成都网站建设推广　　 　内江服务器托管　　 　宜宾做网站　　 　云服务器　　 　成都小程序