SpringMVC 启动原理

于 2025-04-22 11:07:22 发布
阅读量721 收藏 10
点赞数 12
分类专栏： # Spring 生态 文章标签： mvc spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ougaii_/article/details/147168947
版权

文章目录

前言


springmvc 有两个版本，一个是直接使用 springmvc，一个是通过 springboot 使用 springmvc。两者的启动流程是不一样的，主要是 Bean 的创建时机不同，直接使用 springpvc 时是通过 DispatcherServlet 带动 Spring 容器的启动，进而创建各种 Bean，而 springboot 的版本是先启动了 Spring 容器创建各种 Bean。

本文中记录的启动流程是 单独使用 springmvc 的版本。

springmvc 启动流程 - 大白话描述


整理的 springmvc 启动流程图：

springmvc启动流程图

图中步骤详解：

  1. Tomcat 是入口，所以先 Tomcat 启动。
  2. Tomcat 启动后，会加载项目中的 web.xml 文件。
  3. 在 web.xml 文件中，定义了 springmvc 的核心类 DispatcherServlet，所以 DispatcherServlet 最终会被加载
  4. 因为 DispatcherServlet 属于 Servlet，所以 Tomcat 会回调 DispatcherServlet 的 init 方法
  5. 在 init 方法中，会创建 WebApplicationContext 对象，这个对象其实就是 Spring 容器。
  6. 向 WebApplicationContext 对象中添加 refresh 的监听，这个监听很重要，后面会用它初始化核心组件。
  7. 调用 WebApplicationContext 的 refresh 方法。refresh 方法是 Spring 容器的核心方法，既启动容器。
  8. Srping 容器启动完毕后，会触发 第六步 添加的 refresh 监听。
  9. 在 refresh 监听中，会初始化 springmvc 的核心组件
  10. 调用 initHandlerMappings 方法，查找并添加 HandlerMapping，spingmvc 默认会从 DispatcherServlet.properties 中加载多个 HandlerMapping 为 Bean，HandlerMapping 的作用是在 Spring 容器中找到 Handler，并保存 Handler 和 请求路径 的映射关系。Handler 是自己定义的处理请求的逻辑，Handler 有多种写法，不同的写法会由对应的 HandlerMapping 处理。常见的 @RequestMapping 声明的 Handler 就是由 RequestMappingHandlerMapping 处理。RequestMappingHandlerMapping 也是重点研究对象。
    因为 RequestMappingHandlerMapping 实现了 InitializingBean 接口，当 RequestMappingHandlerMapping 被创建为 Bean 后，会回调 InitializingBean 接口的 afterPropertiesSet 方法。在 afterPropertiesSet 方法内，RequestMappingHandlerMapping 会找到所有满足条件的 Handler 并保存 Handler 和 请求处理 的映射关系。
  11. 调用 initHandlerAdapters 方法，查找并添加 HandlerAdapter，spingmvc 默认会从 DispatcherServlet.properties 中加载多个 HandlerAdapter 为 Bean。因为 Handler 保存在 HandlerMapping 中，而每个 HandlerMapping 又是不同类型，HandlerAdapter 的作用就是在操作 Handler 时保证统一接口调用，这里使用了适配器模式。每种类型的 HandlerMapping 都会对应一个 HandlerAdapter。RequestMappingHandlerMapping 对应的就是 RequestMappingHandlerAdapter，RequestMappingHandlerAdapter 也是重点研究对象。
    因为 RequestMappingHandlerAdapter 实现了 InitializingBean 接口，当 RequestMappingHandlerAdapter 被创建为 Bean 后，会回调 InitializingBean 接口的 afterPropertiesSet 方法。在 afterPropertiesSet 方法内 RequestMappingHandlerAdapter 会加载各种 方法参数处理器（MethodArgumentResolver） 和 方法返回值处理器 （MethodReturnValueHandler）。
    @RequestMapping 声明的 Handler 有多种传参方式，如：@RequestParam、@RequestBody 等，每种传参方式都对应一个 方法参数处理器，
    @RequestMapping 声明的 Handler 有多种返回方式，如：@ResponseBody、ModelAndView 等，每种返回方式都对应一个 方法返回值处理器
  12. 调用 initViewResolvers 方法，查找并添加 ViewResolver，springmvc 默认会从 DispatcherServlet.properties 中加载。常见的 InternalResourceViewResolver 就是 JSP 文件对应的视图解析器

springmvc 启动流程 - 关键源码


看完前面的启动流程，就基本掌握了核心原理，下面对关键源码进行列举。

1. 对应流程图中紫色部分


public abstract class HttpServletBean {
	// Tomcat 回调 这个方法
	public final void init() throws ServletException {
			initServletBean();
		}
}
public abstract class FrameworkServlet {
	// 给 DispatcherServlet 添加 spring 容器
	protected final void initServletBean() throws ServletException {
		this.webApplicationContext = initWebApplicationContext();
	}
	
	protected WebApplicationContext initWebApplicationContext() {
		if (wac == null) {
		 	// 创建 spring 容器
			wac = createWebApplicationContext(rootContext);
		}
		return wac;
	}
	protected WebApplicationContext createWebApplicationContext(@Nullable WebApplicationContext parent) {
		// 创建 spring 容器
		return createWebApplicationContext((ApplicationContext) parent);
	}
	protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
		// 创建 spring 容器
		configureAndRefreshWebApplicationContext(wac);
		return wac;
	}
	protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
		// 给 spring 容器 添加 refresh 监听
		wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));
		// 启动 spring 容器
		wac.refresh();
	}
}

2. 对应流程图中浅蓝色部分


public class DispatcherServlet {
	// spring 容器启动完成后，回调 refresh 监听
	protected void onRefresh(ApplicationContext context) {
		initStrategies(context);
	}
	// 加载核心组件
	protected void initStrategies(ApplicationContext context) {
		// 查找 HandlerMapping
		initHandlerMappings(context);
		// 查找 HandlerAdapter
		initHandlerAdapters(context);
		// 查找 ViewResolver
		initViewResolvers(context);
	}
}

3. 对应流程图绿色部分


DispatcherServlet.properties

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,\
	org.springframework.web.servlet.function.support.RouterFunctionMapping


public class DispatcherServlet {
	private void initHandlerMappings(ApplicationContext context) {
		if (this.handlerMappings == null) {
			// 从 DispatcherServlet.properties 中查找 HandlerMapping
			this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
		}
	}
	protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
		// 从 DispatcherServlet.properties 中查找 HandlerMapping
		ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
		// 将找到的 HandlerMapping 创建为 Bean
		Object strategy = createDefaultStrategy(context, clazz);
}

public class RequestMappingHandlerMapping {
	// 创建 RequestMappingHandlerMapping 为 Bean 后的回调
	public void afterPropertiesSet() {
		// 查找使用了 @RequestMapping 注解的 Bean，并注册为 Handler
		super.afterPropertiesSet();
	}
	// afterPropertiesSet 最终会调到这里，查找使用了 @RequestMapping 注解的 Bean，并注册为 Handler
	private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
		List<AnnotationDescriptor> requestMappings = descriptors.stream()
				.filter(desc -> desc.annotation instanceof RequestMapping).toList();
		requestMappingInfo = createRequestMappingInfo((RequestMapping) requestMappings.get(0).annotation, customCondition);
	}
}

4. 对应流程图中浅黄色部分


org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
	org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter,\
	org.springframework.web.servlet.function.support.HandlerFunctionAdapter


public class DispatcherServlet {
	private void initHandlerAdapters(ApplicationContext context) {
		if (this.handlerAdapters == null) {
			// 从 DispatcherServlet.properties 中查找 HandlerAdapter
			this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
		}
	}
	protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
		// 从 DispatcherServlet.properties 中查找 HandlerAdapter
		ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
		// 将找到的 HandlerAdapter 创建为 Bean
		Object strategy = createDefaultStrategy(context, clazz);
}

public class RequestMappingHandlerAdapter {
	// 创建 RequestMappingHandlerAdapter 为 Bean 后的回调
	public void afterPropertiesSet() {
	 	// 查找 方法参数解析器
		if (this.argumentResolvers == null) {
			List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
			this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
		}
		// 查找 方法返回解析器
		if (this.returnValueHandlers == null) {
			List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
			this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
		}
	}
	// 默认的参数解析器
	private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
		List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(30);
		resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
		resolvers.add(new RequestParamMapMethodArgumentResolver());
		resolvers.add(new PathVariableMethodArgumentResolver());
		resolvers.add(new PathVariableMapMethodArgumentResolver());
		resolvers.add(new MatrixVariableMethodArgumentResolver());
		resolvers.add(new MatrixVariableMapMethodArgumentResolver());
		resolvers.add(new ServletModelAttributeMethodProcessor(false));
		resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
		resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters(), this.requestResponseBodyAdvice));
		resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));
		resolvers.add(new RequestHeaderMapMethodArgumentResolver());
		resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));
		resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
		resolvers.add(new SessionAttributeMethodArgumentResolver());
		resolvers.add(new RequestAttributeMethodArgumentResolver());
		resolvers.add(new ServletRequestMethodArgumentResolver());
		resolvers.add(new ServletResponseMethodArgumentResolver());
		resolvers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
		resolvers.add(new RedirectAttributesMethodArgumentResolver());
		resolvers.add(new ModelMethodProcessor());
		resolvers.add(new MapMethodProcessor());
		resolvers.add(new ErrorsMethodArgumentResolver());
		resolvers.add(new SessionStatusMethodArgumentResolver());
		resolvers.add(new UriComponentsBuilderMethodArgumentResolver());
		if (KotlinDetector.isKotlinPresent()) {
			resolvers.add(new ContinuationHandlerMethodArgumentResolver());
		}
		if (getCustomArgumentResolvers() != null) {
			resolvers.addAll(getCustomArgumentResolvers());
		}
		resolvers.add(new PrincipalMethodArgumentResolver());
		resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
		resolvers.add(new ServletModelAttributeMethodProcessor(true));

		return resolvers;
	}
	
	// 默认的方法返回解析器
	private List<HandlerMethodReturnValueHandler> getDefaultReturnValueHandlers() {
		List<HandlerMethodReturnValueHandler> handlers = new ArrayList<>(20);
		handlers.add(new ModelAndViewMethodReturnValueHandler());
		handlers.add(new ModelMethodProcessor());
		handlers.add(new ViewMethodReturnValueHandler());
		handlers.add(new ResponseBodyEmitterReturnValueHandler(getMessageConverters(),
				this.reactiveAdapterRegistry, this.taskExecutor, this.contentNegotiationManager,
				initViewResolvers(), initLocaleResolver()));
		handlers.add(new StreamingResponseBodyReturnValueHandler());
		handlers.add(new HttpEntityMethodProcessor(getMessageConverters(),
				this.contentNegotiationManager, this.requestResponseBodyAdvice, this.errorResponseInterceptors));
		handlers.add(new HttpHeadersReturnValueHandler());
		handlers.add(new CallableMethodReturnValueHandler());
		handlers.add(new DeferredResultMethodReturnValueHandler());
		handlers.add(new AsyncTaskMethodReturnValueHandler(this.beanFactory));
		handlers.add(new ServletModelAttributeMethodProcessor(false));
		handlers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(),
				this.contentNegotiationManager, this.requestResponseBodyAdvice, this.errorResponseInterceptors));
		handlers.add(new ViewNameMethodReturnValueHandler());
		handlers.add(new MapMethodProcessor());
		if (getCustomReturnValueHandlers() != null) {
			handlers.addAll(getCustomReturnValueHandlers());
		}
		if (!CollectionUtils.isEmpty(getModelAndViewResolvers())) {
			handlers.add(new ModelAndViewResolverMethodReturnValueHandler(getModelAndViewResolvers()));
		}
		else {
			handlers.add(new ServletModelAttributeMethodProcessor(true));
		}
		return handlers;
	}
}

5. 对应流程图中的橙黄色部分


org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver


public class DispatcherServlet {
	private void initViewResolvers(ApplicationContext context) {
		if (this.viewResolvers == null) {
			// 从 DispatcherServlet.properties 中查找 ViewResolver
			this.viewResolvers = getDefaultStrategies(context, ViewResolver.class);
		}
	}
	protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
		// 从 DispatcherServlet.properties 中查找 ViewResolver
		ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
		// 将找到的 ViewResolver 创建为 Bean
		Object strategy = createDefaultStrategy(context, clazz);
	}

}
面试官：说一下Spring MVC的启动流程呗！
小识的博客
03-25 1291
基于XML配置的容器启动过程 我们常用的Spring MVC是基于Servlet规范实现的，所以我们先来回顾一下Servlet相关的内容。 如果我们直接用Servlet来开发web应用，只需要继承HttpServlet，实现service方法即可，HttpServlet继承自Servlet，Servlet中常用的方法如下 public interface Servlet { // 初始化，只会被调用一次，在service方法调用之前完成 void init(ServletConfig con.
Spring MVC的启动过程
weixin_30898109的博客
11-22 204
一、概述 下面一个基本的运用springMVC的的web.xml的配置，这里要注意两个地方，一个是ContextLoadListener，一个是DispatcherServlet。web容器正是通过这两个配置才和Spring关联起来。这两个配置与web容器的ServletContext关联，为Spring的Ioc容器提供了一个宿主，在建立起Ioc容器体系之后，把DispatcherServlet...
SpringMVC启动流程
qq_44027353的博客
06-28 1967
SpringMVC启动流程如下。
Spring MVC项目的启动
热门推荐
似曾相识燕归来的博客
07-28 2万+
Spring MVC项目启动过程 注：如无特别说明，本系列文章使用的Spring框架版本均为5.0.4.RELEASE 在以前的web项目中，通常会有一个web.xml文件，部署在WEB-INF目录下，诸如Tomcat之类的Servlet容器会通过读取web.xml文件来启动项目，从而初始化配置在web.xml中的一些类，如Spring MVC中的DispatcherServlet类。但是...
springmvc项目如何启动呢？
最新发布
gb4215287的博客
11-29 990
springmvc项目如何启动呢？
SpringMVC工作原理实例详解
08-24
SpringMVC 工作原理实例详解 SpringMVC 是 Spring Framework 中的一部分，当我们需要使用 Spring 框架创建 web 应用程序时，就需要引入 SpringWebMVC。SpringMVC 工作原理实例详解中，通过示例代码介绍了非常详细，...
这一次搞懂SpringMVC原理说明
09-07
在Spring应用启动时，DispatcherServlet作为SpringMVC的核心组件被初始化。DispatcherServlet是一个实现了Servlet接口的类，它负责调度请求到相应的处理器。 DispatcherServlet的`service`方法是请求处理的入口。在...
Spring整合SpringMVC的原理与实现
弱水三千、先干为敬
09-13 1277
1、整合原理 在SpringMVC配置文件中配置MVC注解解析器、静态资源页面放行、视图解析器、拦截器 在web.xml中配置SpringMVC的前端控制器、MVC的编码过滤器 在SpringMVC配置文件中引入Spring的配置文件 Spring配置文件照常配置 2、整合实现 2.1 SpringMVC配置文件(springmvc.xml) <?xml version="1.0" en...
SpringMVC底层实现原理
weixin_45723046的博客
02-15 583
1：什么是SpringMVC 1.1：概述 Spring MVC是Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架。 查看官方文档： https://docs.spring.io/spring/docs/5.2.0.RELEASE/spring-framework-reference/web.html#spring-web 我们为什么要学习SpringMVC呢? Spring MVC的特点： 1：轻量级，简单易学 2：高效：基本请求相应的MVC框架 3：与Spring兼容
tomcat spring springmvc mybatis启动原理
09-01
SpringMVC是基于Spring框架的MVC（Model-View-Controller）Web应用程序开发框架，它的启动原理也是跟Spring类似。在SpringMVC的启动过程中，首先会读取配置文件，加载配置文件中定义的Controller、View Resolver等...
一个简单的可运行springMVC项目
08-21
包含了所有需要的jar包，不需要下载。Eclipse JavaEE IDE+Tomcat7+Jdk1.7就可运行
SpringMVC之启动流程
2302_77659577的博客
08-23 413
以上便是SpringMVC启动的大致流程了,后面我们再来详细探究它处理请求的流程.
Spring MVC启动
hustzw07的博客
06-06 1260
Spring MVCJava Web项目一般都是基于Spring MVC 的。而Spring MVC是建立在IoC容器基础上的。我们知道，Spring MVC和Spring IoC 都是独立的模块，因此web下需要将IoC容器启动与Web容器的启动过程集成在一起。下边看下是怎么做到的。Servlet规范这里我们先看下 Servlet 规范，即Java Servlet Specification。也...
springMVC启动！
m0_65612234的博客
10-19 307
Override// 是否支持某个参数= null;@Override// 解析参数用来判断参数是否带有@Token注解（自定义）,然后从请求头中获取并且返回@Overridereturn yml!= null;@Override // 返回值// 1. 转换返回结果为 yaml 字符串// 2. 将 yaml 字符串写入响应// 3. 设置请求已经处理完毕用来判断方法上是否添加有@Token注解，有就负责其返回值的处理。注意,光定义还不行，需要在配置中指点添加。
Spring MVC启动流程
qq_39158331的博客
11-16 1219
DispatcherServlet——>HandlerAdapter，HandlerAdapter 将会把处理器包装为适配器，从而支持多种类型的处理器， 即适配器设计模式的应用，从而很容易支持很多类型的处理器；首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行 处理，作为统一访问点，进行全局的流程控制；返回控制权给DispatcherServlet，由DispatcherServlet 返回响应给用户，到此一个流程结束。
SpringMVC系列-1 使用方式和启动流程
shengyu
06-18 6111
当Tomcat被部署到服务器或者通过本地IDEA将项目war包通过local tomcat部署到Tomcat上后，可以通过startup.sh或者startup.bat触发Bootstrap的main方法，从而开启Tomcat容器组件的初始化和启动过程。从宏观上看，启动过程中对应着Listener-> Filter -> Servlet组件的触发流程。本文涉及的组件包括Listener和Servlet：Tomcat在构造Context实例后会触发ServletContextEvent事件
SpringMvc之启动流程
猎户星座
05-26 731
当一个Web应用部署到容器内时(eg.tomcat)，在Web应用开始响应执行用户请求前，以下步骤会被依次执行: 部署描述文件中(eg.tomcat的web.xml)由<listener>元素标记的事件监听器会被创建和初始化 对于所有事件监听器，如果实现了ServletContextListener接口，将会执行其实现的contextInitialized()方法 部署描述文件中由<filter>元素标记的过滤器会被创建和初始化，并调用其init()方法 部署描述文件中由&l
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值