Springmvc请求处理流程

最新推荐文章于 2022-07-31 19:40:28 发布
最新推荐文章于 2022-07-31 19:40:28 发布
阅读量77 收藏
点赞数
文章标签： java web.xml python
原文链接：https://my.oschina.net/u/1245414/blog/1546348
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

HttpServletBean

httpServletBean中Environment使用的是StandardServletEnvironment

StandardServletEnvironment

其中propertySources属性封装了如下信息：

  • servletContext 和 servletConfig
  • jndiProperty
  • 系统环境变量
  • 系统属性
//frameworkServlet中初始化
@Override
public void initPropertySources(ServletContext servletContext, ServletConfig servletConfig) {
  WebApplicationContextUtils.initServletPropertySources(
    this.getPropertySources(), servletContext, servletConfig);//servletContext 和 servletConfig
}

//AbstractEnvironment 构造方法中调用，构造StandardServletEnvironment对象时就有了。
@Override
protected void customizePropertySources(MutablePropertySources propertySources) {
   propertySources.addLast(new StubPropertySource(SERVLET_CONFIG_PROPERTY_SOURCE_NAME));
   propertySources.addLast(new StubPropertySource(SERVLET_CONTEXT_PROPERTY_SOURCE_NAME));
   if (JndiLocatorDelegate.isDefaultJndiEnvironmentAvailable()) {
      propertySources.addLast(new JndiPropertySource(JNDI_PROPERTY_SOURCE_NAME));//jndiProperty
   }
   super.customizePropertySources(propertySources);
}

@Override
protected void customizePropertySources(MutablePropertySources propertySources) {
   propertySources.addLast(new MapPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));//系统属性
   propertySources.addLast(new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));//系统环境变量
}

init()

@Override
public final void init() throws ServletException {
   if (logger.isDebugEnabled()) {
      logger.debug("Initializing servlet '" + getServletName() + "'");
   }

   // Set bean properties from init parameters.
   try {
      PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
      BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);//this就是之后的DispatcherServlet
      ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
      bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));//注册Editor，复合resource类的，就用ResourceEditor来编辑
      initBeanWrapper(bw);
      bw.setPropertyValues(pvs, true);//将ServletConfig设置到dispatcherServlet
   }
   catch (BeansException ex) {
      logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
      throw ex;
   }

   // Let subclasses do whatever initialization they like.
   initServletBean();//模版方法

   if (logger.isDebugEnabled()) {
      logger.debug("Servlet '" + getServletName() + "' configured successfully");
   }
}

HttpServletBean主要作用

  • 定义Environment
  • 设置ServletConfig

FrameworkServlet

implements ApplicationContextAware

从spring中获取WebApplicationContext

initServletBean()

@Override
protected final void initServletBean() throws ServletException {
...
   try {
      this.webApplicationContext = initWebApplicationContext();
      initFrameworkServlet();
   }
   catch (ServletException ex) {
      this.logger.error("Context initialization failed", ex);
      throw ex;
   }
...
}

protected WebApplicationContext initWebApplicationContext() {
  //获取spring的容器，从ServletContext#getAttribute(WebApplicationContext.class.getName() + ".ROOT")
   WebApplicationContext rootContext =
         WebApplicationContextUtils.getWebApplicationContext(getServletContext());
   WebApplicationContext wac = null;

   if (this.webApplicationContext != null) {
      // A context instance was injected at construction time -> use it
      wac = this.webApplicationContext;
      if (wac instanceof ConfigurableWebApplicationContext) {
         ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
         if (!cwac.isActive()) {
            // The context has not yet been refreshed -> provide services such as
            // setting the parent context, setting the application context id, etc
            if (cwac.getParent() == null) {
               // The context instance was injected without an explicit parent -> set
               // the root application context (if any; may be null) as the parent
              //将spring容器设置为springmvc容器的父容器
               cwac.setParent(rootContext);
            }
            configureAndRefreshWebApplicationContext(cwac);
         }
      }
   }
  //this.webApplicationContext = null & wac = null 是什么情况？
   if (wac == null) {
      // No context instance was injected at construction time -> see if one
      // has been registered in the servlet context. If one exists, it is assumed
      // that the parent context (if any) has already been set and that the
      // user has performed any initialization such as setting the context id
     //通过配置servlet中的contextAttribute参数，从ServletContext中获取指定名字的webApplicationContext
      wac = findWebApplicationContext();
   }
   if (wac == null) {
      // No context instance is defined for this servlet -> create a local one
      wac = createWebApplicationContext(rootContext);
   }

   if (!this.refreshEventReceived) {
      // Either the context is not a ConfigurableApplicationContext with refresh
      // support or the context injected at construction time had already been
      // refreshed -> trigger initial onRefresh manually here.
     // 留给dispatcherServlet
      onRefresh(wac);
   }

   if (this.publishContext) {
      // Publish the context as a servlet context attribute.
      // FrameworkServlet.class.getName() + ".CONTEXT." + getServletName();
      String attrName = getServletContextAttributeName();
      getServletContext().setAttribute(attrName, wac);
      if (this.logger.isDebugEnabled()) {
         this.logger.debug("Published WebApplicationContext of servlet '" + getServletName() +
               "' as ServletContext attribute with name [" + attrName + "]");
      }
   }

   return wac;
}

作用：

  • 初始化WebApplicationContext 从ServletContext中获取
  • initFrameworkServlet模版方法

servlet的webApplicationContext

  1. 已经构造好了webApplicationContext，在servlet构造方法中传入现有的对象。（主要用于servlet3.0以后，ServletContext.addServlet）
  2. webApplication已经在ServletContext中了。可以通过配置来从servletContext中根据contextAttribute获取现有webApplicationContext
<servlet>
  <servlet-name>spring</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <init-param>
    <!--配置contextAttribute，从servletContext中找hehe的webApplicationContext-->
    <param-name>contextAttribute</param-name> 
    <param-value>hehe</param-value>
  </init-param>
  <init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring-mvc.xml</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
  <async-supported>true</async-supported>
</servlet>
  1. 自己创建（正常情况）

webApplicationContext 中的内容

  • environment
  • parent
  • contextConfigLocation ：web.xml中配置，默认WEB-INFO/[servletname]-Servlet.xml
  • servletContext
  • servletConfig
  • namespace
  • applicationListener : ContextRefreshedEvent监听器，收到event后调用onRefresh() 方法
  • postProcessWebApplicationContext() 后置处理

重写doGet doPost.....

将doXXX方法全部交由processRequest() 方法。doOptions 和 doTrace 根据参数判断自己处理还是交给父类

processRequest

  • 对LocaleContext和RequestAttributes设置和恢复
  • doService()
  • 处理完后发布publishRequestHandledEvent

ServletRequestAttributes封装了request，可以从request和session中取值。

requestAttributes.requestCompleted();执行后，不能再对requestAttributes进行操作。

LocaleContextHolder/RequestContextHolder

//根据request设置LocaleContextHolder/RequestContextHolder,可提供locale和request，在service层。
initContextHolders(request, localeContext, requestAttributes);

localeContextHolder、inheritableLocaleContextHolder可以被子线程继承？？？

没搞懂localeContextHolder inheritableLocaleContextHolder两个ThreadLocal变量的作用，希望大神帮忙解答。

resetContextHolders(request, previousLocaleContext, previousAttributes); //为什么要恢复？怕影响Servlet外面的filter工作，可能有什么修改需要恢复？

publishRequestHandledEvent

配置：web.xml中配置springmvc servlet时配置，默认true。

用法：可以用来记录日志。

输入图片说明

DispatcherServlet

初始化各种组件init()

  • MutipartResolver
  • LocaleResolver
  • ThemeResolver
  • HandlerMappings
  • HandlerAdapters
  • HandlerExceptionResolvers
  • RequestToViewNameTranslator
  • ViewResolvers
  • FlashMapManager

doService()

@Override
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
   if (logger.isDebugEnabled()) {
      String requestUri = urlPathHelper.getRequestUri(request);
      String resumed = WebAsyncUtils.getAsyncManager(request).hasConcurrentResult() ? " resumed" : "";
      logger.debug("DispatcherServlet with name '" + getServletName() + "'" + resumed +
            " processing " + request.getMethod() + " request for [" + requestUri + "]");
   }

   // Keep a snapshot of the request attributes in case of an include,
   // to be able to restore the original attributes after the include.
  //判断是否是include请求，如果是则对request做快照备份，结束后还原
   Map<String, Object> attributesSnapshot = null;
   if (WebUtils.isIncludeRequest(request)) {
      logger.debug("Taking snapshot of request attributes before include");
      attributesSnapshot = new HashMap<String, Object>();
      Enumeration<?> attrNames = request.getAttributeNames();
      while (attrNames.hasMoreElements()) {
         String attrName = (String) attrNames.nextElement();
         if (this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) {
            attributesSnapshot.put(attrName, request.getAttribute(attrName));
         }
      }
   }

   // 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());

  //后面3个和flashMap有关。用于redirect传递参数。
   FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
   if (inputFlashMap != null) {
     //先取出flashmap放入INPUT_FLASH_MAP_ATTRIBUTE，再放入model中。在Controller中可以使用。
     //RedirectAttributes.addFlashAttribute() 将参数添加到session中
     //RedirectAttributes.addAttribute() 将参数拼接到url后。
      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()) {
         return;
      }
      // Restore the original attribute snapshot, in case of an include.
      if (attributesSnapshot != null) {
         restoreAttributesAfterInclude(request, attributesSnapshot);
      }
   }
}
  • 设置request一些属性
  • 处理include请求快照
  • doDispatch()

doDispatch()

  • 根据request找handler
  • 根据handler找HandlerAdapter
  • 用Adapter处理handler
  • processDispathResult() 处理结果，包括找到view并渲染。
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 {
        //判断是否是Multipart 请求,用到MultipartResolver
         processedRequest = checkMultipart(request);
         multipartRequestParsed = processedRequest != request;

         // Determine handler for the current request.
        //根据request获取handler，用到handlerMapping
         mappedHandler = getHandler(processedRequest);
         if (mappedHandler == null || mappedHandler.getHandler() == null) {
            noHandlerFound(processedRequest, response);
            return;
         }

         // Determine handler adapter for the current request.
        //获取adatper
         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()) {
               String requestUri = urlPathHelper.getRequestUri(request);
               logger.debug("Last-Modified value for [" + requestUri + "] is: " + lastModified);
            }
            if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
               return;
            }
         }
		
        //interceptor#perHandler
         if (!mappedHandler.applyPreHandle(processedRequest, response)) {
            return;
         }

         try {
            // Actually invoke the handler.
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
         }
         finally {
           //异步处理，则直接返回
            if (asyncManager.isConcurrentHandlingStarted()) {
               return;
            }
         }

         applyDefaultViewName(request, mv);
        //interceptor#postHandler
         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
         mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
         return;
      }
      // Clean up any resources used by a multipart request.
      if (multipartRequestParsed) {
         cleanupMultipart(processedRequest);
      }
   }
}

processDispatchResult()

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
      HandlerExecutionChain mappedHandler, ModelAndView mv, 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);
        //用到HanlderExceptionResolver
         mv = processHandlerException(request, response, handler, exception);
         errorView = (mv != null);
      }
   }

   // Did the handler return a view to render?
   if (mv != null && !mv.wasCleared()) {
     //渲染页面，用到themeResolver
      render(mv, request, response);
      if (errorView) {
         WebUtils.clearErrorRequestAttributes(request);
      }
   }
   else {
      if (logger.isDebugEnabled()) {
         logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +
               "': assuming HandlerAdapter completed request handling");
      }
   }

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

   if (mappedHandler != null) {
     //触发Interceptor#afterCompletion()
      mappedHandler.triggerAfterCompletion(request, response, null);
   }
}

输入图片说明

转载于:https://my.oschina.net/u/1245414/blog/1546348

weixin_33884611
关注
Spring、SpringMVC及web容器的Context上下文
cathar的专栏
02-05 5570
Spring 功能与结构 基于Java Beans的配置管理，采用IOC的原理，特别是对依赖注入技术的使用。这些都用来减少各组件间对实施细则的相互依赖性。 一个核心的，全局适用的Bean工厂。 一个一般抽象化的层面来管理数据库间的数据处理。 建立在框架内的，对Java数据处理API和单独的JDBC数据源的一般性策略。因此，在数据处理支持上对Java企业版本环境的依赖性得以消除。 和一些可持续性的
SpringMVC-请求的处理流程
不瘦十斤不换名字
03-04 2006
前文讲过，在SpringMVC中，对于请求的处理涉及到三个Servlet：HttpServletBean、FrameworkServlet和DispatcherServlet。一、HttpServletBean在SpringMVC的初始化过程中，HttpServletBean负责获取Servlet的配置参数，并放入SpringMVC的环境中，但在请求的处理上，HttpServletBean并没有做任
SpringMVC之DispatcherServlet（一）
业精于勤荒于嬉 行成于思毁于随
02-18 1万+
上一篇介绍了ContextLoaderListener，作用就是容器启动时创建WebApplicationContext存储在ServletContext中。本文将介绍SpringMVC核心DispatcherServlet，它是Servlet接口的实现类 Servlet是一个Java编写的程序，基于Http协议，在服务端运行，主要处理客户端的请求并将结果发送给客户端。其生命周期由Servlet...
springMVC源码解析
一只小菜鸡
11-07 388
前沿：       我们需要知道什么是springMVC，简单的来说，他是一个web框架，实现了视图（view）-模型（model）-控制器（controller）的解耦，但是怎么解耦的呢，今天我们就一边debug，一边从源码来解析springMVC的运行过程； 1、我们都知道，springMVC的核心是DispatcherServlet，它是springMVC的核心控制器，也就是MVC中的C...
SpringMVC获得ApplicationContext对象
蒋固金（jianggujin）的专栏
01-23 3535
在使用SpringMVC的时候我们可能会需要直接获得ApplicationContext对象，这里总结了两种方式供大家参考，同时也作为自己的笔记记录一下。
SpringMVC3-启动-源码跟踪
dark
08-02 545
环境搭建 目前搭建一个标准的maven-webapp工程，结构如下： 依赖包 SpringMvc的环境搭建，用maven构建，只需要引入如下maven依赖，spring版本3.1.0.RELEASE(公司老项目，很多都是3.x版本 orz) &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;dependency&amp;amp;amp;amp;amp;amp;amp;amp;a
SpringMVC对请求的处理流程
shisannnn的博客
08-30 710
SpringMVC内部请求的处理流程:也就是SpringMVC接收请求到处理完成的过程 1.用户发起some.do请求 2.DispatcherServlet中央调度器接收请求some.do，把请求转交给处理器映射器  处理器映射器:SpringMVC框架中的一种对象，框架实现了HandlerMapping接口的类都叫映射器（多个）  处理器映射器的作用:根据请求，从SpringMVC容器对象中获取处理器对象（相当于 ApplicationContext ac=new ClassPathXmlApplic
springmvc请求处理流程.md
最新发布
04-28
springmvc请求处理流程
SpringMVC请求处理流程（图解）及九大组件
程序员资料站
06-15 2473
SpringMVC请求处理流程 流程说明 第⼀步：⽤户发送请求⾄前端控制器DispatcherServlet 第⼆步： DispatcherServlet收到请求调⽤HandlerMapping处理器映射器 第三步：处理器映射器根据请求Url找到具体的Handler（后端控制器），⽣成处理器对象及处理器拦截器(如果 有则⽣成)⼀并返回DispatcherServlet 第四步： DispatcherServlet调⽤HandlerAdapter处理器适配器去调⽤Handler 第五步：处理器适配器执⾏Ha
一文读懂 spring MVC 请求处理流程
澎湖Java架构师的博客
07-29 2782
主要了解请求处理的流程，在DispatcherServlet中，先通过请求从handlerMappings中获取对应的handler,然后通过handler找到对应的handlerAdapter然后通过handlerAdapter的handle()方法真正执行我么controller层的业务逻辑。并返回一个ModeAndView然后通过ViewResolver解析成view并渲染到界面上。httpshttpshttpshttpshttpshttpshttps。...
一文搞懂SpringMVC请求流程（源码角度）
qq_45321888的博客
12-11 812
从源码角度解析SpringMVC的请求流程
Spring MVC之处理请求的过程
m0_67322837的博客
07-31 3089
springMVC是遵循MVC架构思想，基于SpringContainerCore和AOP等技术，实现的轻量级web框架，用于简化我们日常Web开发。
SpringBoot之浅析配置项解析（一）
398701344努力加油！
01-07 3468
在我们的开发工作总是离不了配置项相关的配置工作，SpringBoot也为我们提供了@ConfigurationProperties注解来进行配置项信息的配置工作，同时也提供了几个配置文件的默认加载位置，如：classpath:application.properties、classpath:application.yml、classpath:application.yaml、classpath:/
【Spring实战】----springMVC配置文件*-servlet.xml的解析
honghailiang的专栏
11-24 9762
一、背景知识 1）在文章Spring实战篇系列----Spring配置文件的解析 中已经对spring配置文件的解析进行了说明，在web中的使用是基于org.springframework.web.context.ContextLoaderListener的，例如： contextConfigLocation classpath*:applicationContext-*.xm
13-SpringMVC请求流程
lizc_lizc的博客
03-28 259
SpringMVC版本为5.1.14 Servlet生命周期 SpringMVC的请求流程都会经过DispatcherServlet，它就是一个普通的Servlet，所有的请求都会被转发到这里。 Servlet 生命周期可被定义为从创建直到毁灭的整个过程。以下是 Servlet 遵循的过程： Servlet 通过调用 init () 方法进行初始化。 Servlet 调用 service() 方...
SpringMVC源码解析
热门推荐
qq_24101357的博客
09-26 2万+
SpringMVC源码解析 Spring Web MVC是基于Servlet API构建的原始Web框架，从一开始就包含在Spring框架中。 其正式名称“Spring Web MVC”来自它的源模块(Spring -webmvc)的名称，但它更常见的名称是“Spring MVC”。 本节介绍Spring Web MVC。 （1）servlet3.0新特性 通过上图可以知道，servl...
springboot源码分析7-环境属性构造过程（上）
分享牛
11-30 4031
使用springboot的目的就是在项目开发中，快速出东西，因此springboot对于配置文件的格式支持是非常丰富的，最常见的配置文件后缀有如下四种：properties、xml、yml、yaml，比如我们在springboot项目根目录中配置了一个application.properties文件，则springboot项目启动的时候就会自动将该文件的内容解析并设置到环境中，这样后续需要使用该文
java源码 - Spring5.x（7）之 SpringMVC
littlewhitevg的博客
08-19 203
文章目录1. SpringMVC1.1 ContextLoaderListener1.2 initWebApplicationContext 1. SpringMVC SpringMVC 系列 请求debug 1.1 ContextLoaderListener 这里主要是为了搞清楚SpringMVC的IOC启动过程 ContextLoaderListener可以指定在Web应用程序启动时载入Ioc容器，正是通过ContextLoader来实现的，可以说是Ioc容器的初始化工作。 如果要使用Context
SpringMVC源码分析--容器初始化（四）FrameworkServlet
u012507301的博客
01-26 285
转载：https://blog.csdn.net/qq924862077/article/details/52809521 在上一篇博客HttpServletBean我们介绍了HttpServletBean的init函数，其主要作用是初始化了一下SpringMVC配置文件的地址contextConfigLocation的配置属性，然后其调用的子类FrameworkServlet的initServ...
深入解析SpringMVC请求处理流程
以下是对SpringMVC请求处理流程的源码分析和工程配置的详细说明： 1. SpringMVC工程创建 - 创建一个基于Maven的Java项目。 - 在项目结构中设置`java`和`resources`目录。 - 添加Spring Web MVC依赖到`pom.xml`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值