（二）Spring MVC 实现原理之 DispatcherServlet 的处理请求过程

最新推荐文章于 2024-10-31 20:40:31 发布
原创 最新推荐文章于 2024-10-31 20:40:31 发布 · 1.5k 阅读 · 21 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #springmvc #dispatcher #HandlerMapping #HandlerAdapter #ModelAndView #View

目录

一. 前言

二. DispatcherServlet 处理请求的过程

2.1. 回顾整体处理流程

2.2. doGet() 入口

2.3. 请求分发

2.4. 映射和适配器处理

2.5. 视图渲染

一. 前言

    在上一篇《（一）Spring MVC 实现原理之 DispatcherServlet 的初始化过程》中，我们详细介绍了 DispatcherServlet 的初始化过程。有了前文的铺垫，接下来我们就通过源码来解析理解下DispatcherServlet 处理请求的过程。

二. DispatcherServlet 处理请求的过程

2.1. 回顾整体处理流程

首先让我们整体看一下 Spring Web MVC 处理请求的流程：

核心架构的具体流程步骤如下：

  1. 首先用户发送请求 ==> DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行 处理，作为统一访问点，进行全局的流程控制；
  2. DispatcherServlet ==> HandlerMapping， HandlerMapping 将会把请求映射为 HandlerExecutionChain 对象（包含一个 Handler 处理器（页面控制器）对象、多个HandlerInterceptor 拦截器）对象，通过这种策略模式，很容易添加新的映射策略；
  3. DispatcherServlet ==> HandlerAdapter，HandlerAdapter 将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；
  4. HandlerAdapter ==> ​​​​​​​处理器功能处理方法的调用，HandlerAdapter 将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个 ModelAndView  对象（包含模型数据、逻辑视图名）；
  5. ModelAndView 的逻辑视图名 ==> ​​​​​​​ViewResolver，ViewResolver 将把逻辑视图名解析为具体的 View，通过这种策略模式，很容易更换其他视图技术；
  6. View ==> ​​​​​​​渲染，View 会根据传进来的 Model 模型数据进行渲染，此处的 Model 实际是一个Map 数据结构，因此很容易支持其他视图技术；
  7. 返回控制权给 DispatcherServlet，由 DispatcherServlet 返回响应给用户，到此一个流程结束。

2.2. doGet() 入口

    我们以《经典怀旧 —— 通过一个代码案例讲解 Spring MVC 的请求流程》中示例的 GET 请求为例，请求 URL 是：http://localhost:8080/lm_springmvc/user。

    我们知道 Servlet 处理 GET 请求是 doGet() 方法，所以我们去找 DispatcherServlet 类结构中的doGet() 方法：

@Override
protected final void doGet(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, IOException {

  processRequest(request, response);
}

processRequest() 处理请求的方法如下：

/**
 * Process this request, publishing an event regardless of the outcome.
 * <p>The actual event handling is performed by the abstract
 * {@link #doService} template method.
 */
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());

  // 初始化context
  initContextHolders(request, localeContext, requestAttributes);

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

  finally {
    // 重置context
    resetContextHolders(request, previousLocaleContext, previousAttributes);
    if (requestAttributes != null) {
      requestAttributes.requestCompleted();
    }
    logResult(request, response, failureCause, asyncManager);
    publishRequestHandledEvent(request, response, startTime, failureCause);
  }
}

本质上就是调用 doService() 方法，由 DispatchServlet 类实现：

/**
 * Exposes the DispatcherServlet-specific request attributes and delegates to {@link #doDispatch}
 * for the actual dispatching.
 */
@Override
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
  logRequest(request);

  // 保存下请求之前的参数.
  Map<String, Object> attributesSnapshot = null;
  if (WebUtils.isIncludeRequest(request)) {
    attributesSnapshot = new HashMap<>();
    Enumeration<?> attrNames = request.getAttributeNames();
    while (attrNames.hasMoreElements()) {
      String attrName = (String) attrNames.nextElement();
      if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
        attributesSnapshot.put(attrName, request.getAttribute(attrName));
      }
    }
  }

  // 方便后续 handlers 和 view 要使用它们.
  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());

  if (this.flashMapManager != null) {
    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);
  }

  RequestPath previousRequestPath = null;
  if (this.parseRequestPath) {
    previousRequestPath = (RequestPath) request.getAttribute(ServletRequestPathUtils.PATH_ATTRIBUTE);
    ServletRequestPathUtils.parseAndCache(request);
  }

  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);
      }
    }
    if (this.parseRequestPath) {
      ServletRequestPathUtils.setParsedRequestPath(previousRequestPath, request);
    }
  }
}

2.3. 请求分发

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 {
      // 判断是不是文件上传类型的request
      processedRequest = checkMultipart(request);
      multipartRequestParsed = (processedRequest != request);

      // 根据request获取匹配的handler.
      mappedHandler = getHandler(processedRequest);
      if (mappedHandler == null) {
        noHandlerFound(processedRequest, response);
        return;
      }

      // 根据handler获取匹配的handlerAdapter
      HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

      // 如果handler支持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;
        }
      }

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

      // 真正handle处理，并返回modelAndView
      mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

      if (asyncManager.isConcurrentHandlingStarted()) {
        return;
      }

      // 通过视图的prefix和postfix获取完整的视图名
      applyDefaultViewName(processedRequest, mv);

      // 应用后置的拦截器
      mappedHandler.applyPostHandle(processedRequest, response, mv);
    }
    catch (Exception ex) {
      dispatchException = ex;
    }
    catch (Throwable err) {
      // As of 4.3, we're processing Errors thrown from handler methods as well,
      // making them available for @ExceptionHandler methods and other scenarios.
      dispatchException = new NestedServletException("Handler dispatch failed", err);
    }

    // 处理handler处理的结果，显然就是对ModelAndView 或者 出现的Excpetion处理
    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()) {
      // 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);
      }
    }
  }
}

2.4. 映射和适配器处理

对于真正的 handle() 方法，我们看下其处理流程：

/**
 * This implementation expects the handler to be an {@link HandlerMethod}.
 */
@Override
@Nullable
public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
    throws Exception {

  return handleInternal(request, response, (HandlerMethod) handler);
}

    交给 handleInternal() 方法处理，以 RequestMappingHandlerAdapter 这个 HandlerAdapter 中的处理方法为例：

@Override
protected ModelAndView handleInternal(HttpServletRequest request,
    HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

  ModelAndView mav;
  checkRequest(request);

  // Execute invokeHandlerMethod in synchronized block if required.
  if (this.synchronizeOnSession) {
    HttpSession session = request.getSession(false);
    if (session != null) {
      Object mutex = WebUtils.getSessionMutex(session);
      synchronized (mutex) {
        mav = invokeHandlerMethod(request, response, handlerMethod);
      }
    }
    else {
      // No HttpSession available -> no mutex necessary
      mav = invokeHandlerMethod(request, response, handlerMethod);
    }
  }
  else {
    // No synchronization on session demanded at all...
    mav = invokeHandlerMethod(request, response, handlerMethod);
  }

  if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
    if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
      applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
    }
    else {
      prepareResponse(response);
    }
  }

  return mav;
}

    然后执行 invokeHandlerMethod() 这个方法，用来对 RequestMapping（UserController 中的 list方法）进行处理：

/**
 * Invoke the {@link RequestMapping} handler method preparing a {@link ModelAndView}
 * if view resolution is required.
 * @since 4.2
 * @see #createInvocableHandlerMethod(HandlerMethod)
 */
@Nullable
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
    HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

  ServletWebRequest webRequest = new ServletWebRequest(request, response);
  try {
    
    WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
    ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

    // 重要：设置handler(controller#list)方法上的参数，返回值处理，绑定databinder等
    ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
    if (this.argumentResolvers != null) {
      invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
    }
    if (this.returnValueHandlers != null) {
      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);

    
    AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
    asyncWebRequest.setTimeout(this.asyncRequestTimeout);

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    asyncManager.setTaskExecutor(this.taskExecutor);
    asyncManager.setAsyncWebRequest(asyncWebRequest);
    asyncManager.registerCallableInterceptors(this.callableInterceptors);
    asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);

    if (asyncManager.hasConcurrentResult()) {
      Object result = asyncManager.getConcurrentResult();
      mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];
      asyncManager.clearConcurrentResult();
      LogFormatUtils.traceDebug(logger, traceOn -> {
        String formatted = LogFormatUtils.formatValue(result, !traceOn);
        return "Resume with async result [" + formatted + "]";
      });
      invocableMethod = invocableMethod.wrapConcurrentResult(result);
    }

    // 执行controller中方法
    invocableMethod.invokeAndHandle(webRequest, mavContainer);
    if (asyncManager.isConcurrentHandlingStarted()) {
      return null;
    }

    return getModelAndView(mavContainer, modelFactory, webRequest);
  }
  finally {
    webRequest.requestCompleted();
  }
}

invokeAndHandle() 交给 UserController 中具体执行 list 方法执行：

后续 invoke() 执行的方法，直接看整个请求流程的调用链即可：

执行后获得视图和 Model：

2.5. 视图渲染

    接下来继续执行 processDispatchResult() 方法，对视图和 Model（如果有异常则对异常处理）进行处理，这就是渲染页面了。

/**
 * Handle the result of handler selection and handler invocation, which is
 * either a ModelAndView or an Exception to be resolved to a ModelAndView.
 */
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);
    }
  }

  // 是否需要渲染视图
  if (mv != null && !mv.wasCleared()) {
    render(mv, request, response); // 渲染视图
    if (errorView) {
      WebUtils.clearErrorRequestAttributes(request);
    }
  }
  else {
    if (logger.isTraceEnabled()) {
      logger.trace("No view rendering, null ModelAndView returned.");
    }
  }

  if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
    // Concurrent handling started during a forward
    return;
  }

  if (mappedHandler != null) {
    // Exception (if any) is already handled..
    mappedHandler.triggerAfterCompletion(request, response, null);
  }
}

    接下来就是渲染视图了，Spring 在 initStrategies() 方法中初始化的组件（LocaleResovler 等）就派上用场了：

/**
 * Render the given ModelAndView.
 * <p>This is the last stage in handling a request. It may involve resolving the view by name.
 * @param mv the ModelAndView to render
 * @param request current HTTP servlet request
 * @param response current HTTP servlet response
 * @throws ServletException if view is missing or cannot be resolved
 * @throws Exception if there's a problem rendering the view
 */
protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
  // Determine locale for request and apply it to the response.
  Locale locale =
      (this.localeResolver != null ? this.localeResolver.resolveLocale(request) : request.getLocale());
  response.setLocale(locale);

  View view;
  String viewName = mv.getViewName();
  if (viewName != null) {
    // We need to resolve the view name.
    view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
    if (view == null) {
      throw new ServletException("Could not resolve view with name '" + mv.getViewName() +
          "' in servlet with name '" + getServletName() + "'");
    }
  }
  else {
    // No need to lookup: the ModelAndView object contains the actual View object.
    view = mv.getView();
    if (view == null) {
      throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +
          "View object in servlet with name '" + getServletName() + "'");
    }
  }

  // Delegate to the View object for rendering.
  if (logger.isTraceEnabled()) {
    logger.trace("Rendering view [" + view + "] ");
  }
  try {
    if (mv.getStatus() != null) {
      response.setStatus(mv.getStatus().value());
    }
    view.render(mv.getModelInternal(), request, response);
  }
  catch (Exception ex) {
    if (logger.isDebugEnabled()) {
      logger.debug("Error rendering view [" + view + "]", ex);
    }
    throw ex;
  }
}

    后续就是通过 viewResolver 进行解析了，这里就不再继续看代码了，上述流程基本上够帮助你构建相关的认知了。最后无非是返回控制权给 DispatcherServlet，由 DispatcherServlet 返回响应给用户。

最后的最后我们看下请求的日志：

21:45:53.390 [http-nio-8080-exec-6] DEBUG org.springframework.web.servlet.DispatcherServlet - GET "/lm_springmvc/user", parameters={}
21:45:53.400 [http-nio-8080-exec-6] DEBUG org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping - Mapped to com.lm.it.springframework.springmvc.controller.UserController#list(HttpServletRequest, HttpServletResponse)
22:51:14.504 [http-nio-8080-exec-6] DEBUG org.springframework.web.servlet.view.JstlView - View name 'userList', model {dateTime=Fri Apr 22 21:45:53 CST 2022, userList=[com.lm.it.springframework.springmvc.entity.User@7b8c8dc]}
22:51:14.550 [http-nio-8080-exec-6] DEBUG org.springframework.web.servlet.view.JstlView - Forwarding to [/WEB-INF/views/userList.jsp]
22:51:44.395 [http-nio-8080-exec-6] DEBUG org.springframework.web.servlet.DispatcherServlet - Completed 200 OK
Spring进阶 - SpringMVC实现原理之DispatcherServlet处理请求的过程
m0_67698950的博客
07-19 825
前文我们有了IOC的源码基础以及SpringMVC的基础，我们便可以进一步深入理解SpringMVC主要实现原理，包含DispatcherServlet的初始化过程和DispatcherServlet处理请求的过程的源码解析。本文是第二篇DispatcherServlet处理请求的过程的源码解析。@pdai。...
深入解析Spring MVC的核心：DispatcherServlet
xycxycooo的博客
08-14 1706
DispatcherServlet是Spring MVC框架的核心，它通过统一管理和协调Web请求的处理流程，提供了清晰的分层结构和强大的功能支持。在Spring MVC框架中，DispatcherServlet扮演着核心角色，它是前端控制器（Front Controller）模式的实现，负责协调和管理Web请求的处理流程。DispatcherServlet是Spring MVC的入口点，它接收所有的HTTP请求，并将请求分发到相应的处理器（Controller）。
【Spring MVC】DispatcherServlet 请求处理流程
ajsbxi的博客
10-31 2109
Spring MVC 是 Spring 框架的一部分，用于构建 Web 应用程序。它遵循 MVC（Model-View-Controller）设计模式，将应用程序分为模型（Model）、视图（View）和控制器（Controller）三个部分。
DispatcherServlet请求处理流程
程序员小潘
01-04 1913
DispatcherServlet 是 Spring MVC 的核心类，它本质是一个 Servlet，负责接管 HTTP 请求并把它分发给对应的处理器处理，最后处理响应结果渲染页面。DispatcherServlet 本身并不复杂，它提供了一个模板方法来处理请求，把请求处理的细节交给了依赖的其它组件。本文先分析 DispatcherServlet 的初始化流程，再分析请求的整体处理流程，至于请求处理中涉及到的其它组件，会另起篇幅。
DispatcherServlet的请求处理流程
qq_35219329的博客
05-30 1582
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 上一篇文章中分析了tomcat的请求处理流程，在springmvc项目中，tomcat接收到请求后，最终会将请求发送到dispatcherServlet中，dispatcherServlet可以看成是tomcat中的一个普通servlet，本文就dispatcherServlet的处理过程进行分析。 一、se..
SpringMvc源码篇#DispatcherServlet处理请求过程
qq_36311757的博客
03-24 571
SpringMVC接受http请求时，DispatcherServlet是怎么处理的呢
Spring MVC学习之DispatcherServlet请求处理详析
08-26
在Spring MVC框架中，DispatcherServlet扮演着至关重要的角色，它是整个Spring MVC的前端控制器，负责接收客户端发送的HTTP请求，并将其转发给适当的处理器进行处理。接下来我们将深入探讨DispatcherServlet的请求...
从源码角度看spring mvc的请求处理过程
08-25
从源码角度深入理解Spring MVC的请求处理过程有助于我们更好地掌握其工作原理。以下将详细阐述这个过程。 1. **前端控制器DispatcherServlet的角色** DispatcherServlet是Spring MVC的核心组件，扮演着前端控制器...
Spring MVC 请求处理流程全解析（从 DispatcherServlet 到 Controller）
最新发布
05-07
Spring MVC作为Java Web开发中广泛使用的一个框架，其核心组件和请求处理流程是众多开发者必须掌握的知识点。Spring MVC中的`DispatcherServlet`扮演着至关重要的角色，是整个框架的协调者和入口。从接收客户端请求...
Spring MVC之DispatcherServlet_动力节点Java学院整理
10-19
总的来说，DispatcherServlet是Spring MVC的核心组件，负责请求分发和控制流程。理解其配置和工作原理对于有效利用Spring MVC开发Web应用至关重要。通过合理的配置，我们可以实现灵活的请求处理策略，以满足复杂的...
spring mvc DispatcherServlet之前端控制器架构详解
08-27
主要为大家详细介绍了spring mvc DispatcherServlet之前端控制器架构，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Spring源码解读之DispatcherServlet处理请求流程
ccccc202的博客
08-31 345
这里主要讲下java原生的servlet和Spring下DispatcherServlet对http请求的处理流程做一个梳理! 原生Servlet 我们先看下Servlet的实现关系图解 DispatcherServlet
DispatcherServlet 处理流程
fannyoona的博客
03-28 1026
在整个 Spring MVC 框架中，DispatcherServlet 处于核心位置，它负责协调和组织不同组件完成请求处理并返回响应工作。DispatcherServlet 是 SpringMVC统一的入口，所有的请求都通过它。DispatcherServlet 是前端控制器，配置在web.xml文件中，Servlet依自已定义的具体规则拦截匹配的请求，分发到目标Controller来处理。 初始化 DispatcherServlet时，该框架在web应用程序WEB-INF目录中寻找一个名为[servle
SpringMvc-Dispatcher
张三的博客
09-14 1954
虽然知道springMvc处理请求的大致过程，但是具体实现在脑子里比较模糊，因此简单看下源码，只求看懂工作原理，并做下笔记。 几个关键类或接口的说明： HandlerMapping： 这是一个接口，该接口表示实现了这个接口的类是完成url和处理bean映射逻辑的。当SpringMvc启动就会根据选择的实现类去把Controller类型的bean和url绑定如果我们不在配置文件配置
SpringMVC的Dispatcher
weixin_45066790的博客
02-01 888
1.Spring的web框架围绕DispatcherServlet设计。 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。 借用B站狂神的流程图（其中实现全部是框架给我们做的，我们只需要补充虚线的流程就好。） SpringMVC是Spring中的模块，它实现了mvc设计模式的web框架，首先用户发出请求，请求到达SpringMVC的前端控制器（DispatcherServlet）,
Spring 原理之 DispatchServlet 原理
weixin_42272869的博客
04-13 2176
Spring MVC 的DispatchServlet解析 Spring MVC 时序图 DispatchServlet 的父类是 FrameworkServlet ，FrameworkServlet的父类是HttpServletBean 核心流程： 寻找DispatchServlet的init()方法，定位到其父类的父类HttpServletBean的init()方法 定位配置文件位置，加载配置信息 initServletBean调用 DispatchServlet的父类FrameworkS
DispatcherServlet的工作流程
qq_15654285的博客
07-11 1703
DispatcherServlet的工作流程
SpringMVC的DispatcherServlet处理请求的流程
吃一口瓜 的博客
07-04 678
内容参考https://my.oschina.net/lichhao/blog/104943 SpringMVC请求的大致处理流程图 1、请求的入口 1.1、HttpServlet与FrameworkServlet 从设计上看，SpringMVC是依托Servlet容器来设计的。在SpringMVC初始化之后，同样通过service()方法来接受、处理、返回。 DispatcherServlet的service()方法是他的父类FrameworkServlet实现的。 prote.
Spring MVC 之 DispatcherServlet流程
爱老婆爱生活~
04-04 901
DispatcherServle 负责接收客户端请求，然后将请求分派到相应的控制器进行处理，并返回响应结果，我们将深入了解 DispatcherServlet 的处理流程和源码解析
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

流华追梦

你的鼓励将是我创作最大的动力。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值