Spring源码分析---springMVC

最新推荐文章于 2020-12-13 18:08:46 发布
最新推荐文章于 2020-12-13 18:08:46 发布
阅读量197 收藏
点赞数
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38682952/article/details/104680801
版权

六、SpringMVC源码分析

1、DispatchServlet

前端控制器，请求处理逻辑的实现

2、HandlerMapping

处理器映射，为mvc中url路径与Controller对象的映射，DispatcherServlet就是基于此组件来寻找对应的Control。                          目前主流的三种mapping：                                                                                                                        BeanNameUrlHandlerMapping，基于ioc中beanName以 "/" 开头的Bean的映射
SimpleUrlHandlerMapping，基于手动配置 url 与controller映射
RequestMappingHandlerMapping，基于@RequestMapping注解配置对应的映射

annotation-driven默认添加的三种handler

3、HandlerAdapter

Springmvc 采用适配器模式来适配调用指定Handler，根据Handler的不同种类采用不同的。

Controller对应适配器SimpleControllerHandlerAdapter，标准控制器，返回ModelAndView
HttpRequestHandler对应适配器HttpRequestHandlerAdapter，业务自行处理 请求，不需要通过modelAndView转到视图
Servlet对应适配器SimpleServletHandlerAdapter，基于标准的servlet处理
HandlerMethod对应适配器RequestMappingHandlerAdapter，基于@RequestMapping对应方法处理

4、HandlerExecutionChain

处理器执行链

5、ViewResolver

视图解析器，找到应的Adapter 之后就会基于适配器调用业务处理，处理完之后业务方会返回一个 ModelAndView ，在去查找对应的视图进行处理。

6、View

具体解析视图， 获取对应View来解析生成Html并返回 

7、HandlerExceptionResolver

处理器异常解析器，用于指示当出现异常时 Spring mvc 该如何处理

8、HandlerInterceptor

处理器拦截器

 

web服务器启动tomcat首先会去加载web.xml配置文件

<servlet>  
<servlet-name>dispatcherServlet</servlet-name>  
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servletclass>  
<init-param>    
<param-name>contextConfigLocation</param-name>    
<param-value>classpath:spring-mvc.xml</param-value>  
</init-param>  
<load-on-startup>1</load-on-startup>
</servlet>

首先就实例化DispatcherServlet，在这里还配置了监听tomcat容器启动来初始化spring容器，ContextLoaderListener是spring框架中对ServletContextListener的一个实现，ServletContextListener依赖于sevlet容器，那么在tomcat启动的时候会调用contextInitialized方法来初始化。

另外如果没有配置ContextLoaderListener，在DispatcherServlet的父类FrameworkServlet会去初始化spring容器。

if (wac == null) {
// No context instance is defined for this servlet -> create a local one
//如果没有配置ContextLoaderListener加载容器，那么servlet也会加载容器
wac = createWebApplicationContext(rootContext);
}

在createWebApplicationContext会调用configureAndRefreshWebApplicationContext初始化容器，后面就是调用spring容器初始化代码。

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
		if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
			// The application context id is still set to its original default value
			// -> assign a more useful id based on available information
			if (this.contextId != null) {
				wac.setId(this.contextId);
			}
			else {
				// Generate default id...
				wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
						ObjectUtils.getDisplayString(getServletContext().getContextPath()) + '/' + getServletName());
			}
		}

		wac.setServletContext(getServletContext());
		wac.setServletConfig(getServletConfig());
		wac.setNamespace(getNamespace());
		wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));

		// The wac environment's #initPropertySources will be called in any case when the context
		// is refreshed; do it eagerly here to ensure servlet property sources are in place for
		// use in any post-processing or initialization that occurs below prior to #refresh
		ConfigurableEnvironment env = wac.getEnvironment();
		if (env instanceof ConfigurableWebEnvironment) {
			((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());
		}

		postProcessWebApplicationContext(wac);
		applyInitializers(wac);
		//初始化容器
		wac.refresh();
	}

spring容器启动就会去加载相应的配置文件，创建bean。

<context:component-scan base-package="xxx" />
 <!-- 注解驱动 --> 
<!--自动向ioc注册了RequestMappingHandlerMapping与BeanNameUrlHandlerAdapter-->
<mvc:annotation-driven/>

component-scan在这里不在讲，我们现在主要看<mvc:annotation-driven/>，以前提过会有相应的命名空间解析类来解析。

public class MvcNamespaceHandler extends NamespaceHandlerSupport {

	@Override
	public void init() {
		registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
		registerBeanDefinitionParser("default-servlet-handler", new DefaultServletHandlerBeanDefinitionParser());
		registerBeanDefinitionParser("interceptors", new InterceptorsBeanDefinitionParser());
		registerBeanDefinitionParser("resources", new ResourcesBeanDefinitionParser());
		registerBeanDefinitionParser("view-controller", new ViewControllerBeanDefinitionParser());
		registerBeanDefinitionParser("redirect-view-controller", new ViewControllerBeanDefinitionParser());
		registerBeanDefinitionParser("status-controller", new ViewControllerBeanDefinitionParser());
		registerBeanDefinitionParser("view-resolvers", new ViewResolversBeanDefinitionParser());
		registerBeanDefinitionParser("tiles-configurer", new TilesConfigurerBeanDefinitionParser());
		registerBeanDefinitionParser("freemarker-configurer", new FreeMarkerConfigurerBeanDefinitionParser());
		registerBeanDefinitionParser("groovy-configurer", new GroovyMarkupConfigurerBeanDefinitionParser());
		registerBeanDefinitionParser("script-template-configurer", new ScriptTemplateConfigurerBeanDefinitionParser());
		registerBeanDefinitionParser("cors", new CorsBeanDefinitionParser());
	}

}

我们来看AnnotationDrivenBeanDefinitionParser类的parse方法，在这里面会注册很多相应的spring自带的bean，比如RequestMappingHandlerMapping。

RootBeanDefinition handlerMappingDef = new RootBeanDefinition(RequestMappingHandlerMapping.class);

........

MvcNamespaceUtils.registerDefaultComponents(context, source);

可以看到已经把RequestMappingHandlerMapping注册到容器了，还有一些默认的组件

public static void registerDefaultComponents(ParserContext parserContext, @Nullable Object source) {
		registerBeanNameUrlHandlerMapping(parserContext, source);
		registerHttpRequestHandlerAdapter(parserContext, source);
		registerSimpleControllerHandlerAdapter(parserContext, source);
		registerHandlerMappingIntrospector(parserContext, source);
	}

RequestMappingHandlerMapping是实现了InitialzingBean接口的，而这个类的父类AbstractHandlerMethodMapping的afterPropertiesSet方法是整个映射关系建立的入口

public void afterPropertiesSet() {
                 //建立映射关系
		initHandlerMethods();
		int total = this.getHandlerMethods().size();
		if ((logger.isTraceEnabled() && total == 0) || (logger.isDebugEnabled() && total > 0) ) {
			logger.debug(total + " mappings in " + formatMappingName());
		}
	}

而initHandlerMethods是主要实现映射关系的方法

protected void initHandlerMethods() {
		String[] beanNames = obtainApplicationContext().getBeanNamesForType(Object.class);

		for (String beanName : beanNames) {
			if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
				Class<?> beanType = null;
				try {
					beanType = obtainApplicationContext().getType(beanName);
				}
				catch (Throwable ex) {
					// An unresolvable bean type, probably from a lazy bean - let's ignore it.
					if (logger.isTraceEnabled()) {
						logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
					}
				}
				if (beanType != null && isHandler(beanType)) {
					detectHandlerMethods(beanName);
				}
			}
		}
		handlerMethodsInitialized(getHandlerMethods());
	}
 

查找Controller下所有带有@RequestMapping注解的方法，最后注册HandlerMethod 

protected void detectHandlerMethods(final Object handler) {
		Class<?> handlerType = (handler instanceof String ?
				obtainApplicationContext().getType((String) handler) : handler.getClass());

		if (handlerType != null) {
			final Class<?> userType = ClassUtils.getUserClass(handlerType);
			Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
					(MethodIntrospector.MetadataLookup<T>) method -> getMappingForMethod(method, userType));
			if (logger.isTraceEnabled()) {
				logger.trace(formatMappings(userType, methods));
			}
			methods.forEach((key, mapping) -> {
				Method invocableMethod = AopUtils.selectInvocableMethod(key, userType);
				registerHandlerMethod(handler, invocableMethod, mapping);
			});
		}
	}

查找所有带@RequestMapping的方法，并存放到Map<Method,RequestMappingInfo>中，RequestMappingInfo中的patternsCondition属性就是我们解析注解中的url

我们知道当一个请求来是，会执行servlet的doService方法，doService()中的核心逻辑由doDispatch()实现

doDispatch(request, response);

主要看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 {
				// 判断是否是文件上传
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);

				// Determine handler for the current request.
				// 返回 HandlerExecutionChain  执行链 （Handler HandlerInterceptors ）
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null) {
					noHandlerFound(processedRequest, response);
					return;
				}

				// Determine handler adapter for the current request.
				// 返回handler对应的适配器
				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)) {
					// 实现LastModified接口的getLastModified方法，返回一个时间戳，请求中会增加If-Modified-Since参数
					// 通过checkNotModified比较两次请求时间戳，如果一致，就直接返回 http响应头,
					// 静态资源取浏览器缓存，status code 变为304
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}
				// 拦截器前置方法
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				// Actually invoke the handler.
				// 调用业务逻辑
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

				//用于管理异步请求处理的中心类，主要用作SPI，通常不直接由应用程序类使用。
				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}

				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);
			}
			// 将modelAndView交给视图解析器处理
			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);
				}
			}
		}
	}

在方法内mappedHandler = this.getHandler(processedRequest)就是根据当前的请求去拿一个Handler，这个Handler就是我们写的控制器(controller)，也就是去HandlerMapping集合遍历寻找。

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		if (this.handlerMappings != null) {
			for (HandlerMapping mapping : this.handlerMappings) {
				HandlerExecutionChain handler = mapping.getHandler(request);
				if (handler != null) {
					return handler;
				}
			}
		}
		return null;
	}

接下来我们通过HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler())就是去拿相应的适配器类，前面有对照过。拿到控制器适配器中执行控制器。

接下来就是执行拦截器的逻辑了

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

				// Actually invoke the handler.
				// 调用业务逻辑
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

				//用于管理异步请求处理的中心类，主要用作SPI，通常不直接由应用程序类使用。
				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}

				applyDefaultViewName(processedRequest, mv);

				//拦截器后置方法
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}

如果你有ModelAndView，就返回一个ModelAndView.然后返回给试图对象，然后把视图对象交给视图解析器，去渲染，最后响应给用户。

将modelAndView交给视图解析器处理

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);
				//异常处理机制，处理完成之后返回errorView 跳转到异常视图
				mv = processHandlerException(request, response, handler, exception);
				errorView = (mv != null);
			}
		}

		// Did the handler return a view to render?
		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;
		}
		// 调用拦截器 afterCompletion 方法
		if (mappedHandler != null) {
			mappedHandler.triggerAfterCompletion(request, response, null);
		}
	}

 

逗逗大魔王
关注
专栏目录
spring-mvc-test-sample-master.zip_spring mvc_springmvc－test
09-19
在"spring-mvc-test-sample-master.zip"这个压缩包中，我们很可能是得到了一个Spring MVC测试项目的源码示例，旨在帮助开发者更好地理解和应用Spring MVC。 首先，让我们深入理解Spring MVC的核心概念： 1. **...
SpringMVC源码情操陶冶-ResourcesBeanDefinitionParser静态资源解析器
weixin_30314793的博客
06-26 154
解析mvc:resources节点，控制对静态资源的映射访问 查看官方注释 /** * {@link org.springframework.beans.factory.xml.BeanDefinitionParser} that parses a * {@code resources} element to register a {@link ResourceHttpRequestHan...
【源码系列之springMVC】（一、servlet入口：DispatcherServlet统筹全局之初始化web上下文）
CoderOu
07-09 341
今天来说说深入一下SpringMVC，在学习SpringMVC源码之前，必须得了解javaEE原生的Servlet的工作流程，以tomcat为例子：在web.xml中配置servlet，指定servlet-class以及servlet-mapping。然后请求过来根据mapping映射到servlet的类，执行其中的doGet、doPost等方法。具体这里就不细说了。 一、从我们的web.xml入手2.1 从init参数设置bean属性：ServletConfigPropertyValues方法2.2 如果
SpringMVC5源码AnnotationDrivenBeanDefinitionParser注解解析器
u013089490的博客
11-28 325
    mvc:annotation-driven节点的解析器，是springmvc的核心解析器。AnnotationDrivenBeanDefinitionParser类包路径是org.springframework.web.servlet.config，继承于BeanDefinitionParser接口。 1、说明          通过AnnotationDrivenBeanDefini...
SpringMVC之分析AnnotationDrivenBeanDefinitionParser(三)
398701344努力加油！
11-03 711
我们在之前的文章中对这篇文章中AnnotationDrivenBeanDefinitionParser的parse方法进行了一些分析，我们在这篇文章中接着分析AnnotationDrivenBeanDefinitionParser的parse方法的内容。 ManagedList messageConverters = getMessageConverters(element, source, p
Spring技术内幕4——springmvc组件的初始化以及http请求映射(一)
weixin_33963594的博客
07-21 124
为什么80%的码农都做不了架构师？>>> ...
基于Spring-SpringmVC-mybatis的网上聊天室源码.rar
最新发布
11-07
《构建基于Spring-SpringMVC-MyBatis的网上聊天室》 在现代Web开发中，构建一个功能完善的网上聊天室是一项挑战，它要求开发者具备扎实的后端技术和良好的用户体验设计。本项目采用Spring、SpringMVC和MyBatis这三...
java开发oa办公系统源码--Spring-SpringMVC-Mybatis-:基于Spring+SpringMVC+Mybatis分布式
06-05
　基于Spring+SpringMVC+Mybatis分布式敏捷开发系统架构，提供整套公共微服务服务模块：内容管理、支付中心、用户管理（包括第三方）、微信平台、存储系统、配置中心、日志分析、任务和通知等，支持服务治理、监控和...
spring-springmvc:弹簧
03-14
通过分析提供的压缩包文件名 "spring-springmvc-master"，我们可以推测这可能是一个包含 Spring MVC 示例项目的源码仓库。这个项目可能包含了配置文件、Controller 类、Service 类、DAO 类以及视图模板等，用于演示...
springmvc源码分析
12-29
在这个源码分析中，我们将深入探讨Spring MVC的核心组件和工作流程。 1. **DispatcherServlet**：Spring MVC的入口点，它是所有请求的前端控制器。当一个HTTP请求到达服务器时，DispatcherServlet负责拦截请求，并...
SpringMVC源码总结（二）mvc:annotation
阿猫爱吃鱼
03-14 174
SpringMVC源码总结（二）mvc:annotation                         上一篇文章让我们了解HandlerMapping和HandlerAdapter以及默认采取的策略，这篇文章就要讲述mvc:annotation-driven对默认策...
SpringMVC之浅析上下文初始化(二)
398701344努力加油！
07-01 1885
在上一篇文章中(点这里查看)我们说了ContextLoaderListener初始化Web上下文的过程，这篇文章中我们说一下DispatcherServlet初始化上下文的过程。
【转】Spring MVC 解读——<mvc:annotation-driven/>
weixin_30820077的博客
09-01 93
转载自：http://my.oschina.net/HeliosFly/blog/205343 一、AnnotationDrivenBeanDefinitionParser 通常如果我们希望通过注解的方式来进行Spring MVC开发，我们都会在***-servlet.xml中加入<mvc:annotation-driven/>标签来告诉Spring我们的目的。但是...
Spring原码解析之SpringMVC容器如何获取配置文件的bean
wonderfulwork
02-18 374
上一次，我们在  Spring原码解析之SpringMVC(DispatcherServlet)初始化流程 中留下了一个方法还没有探究，如图： 这一次我们将会探究一下 configureAndRefreshWebApplicationContext() 这个方法！ FrameworkServlet.java protected void configureAndRefreshWe...
SpringMVC 源码之 DispatcherServlet 启动初始化解析
nandao158的博客
07-05 557
上篇我们详解了ContextLoaderListener启动过程，这次我们详解DispatcherServlet,先看web.xml 中的相关配置 <!-- 加载springMVC配置文件 --> <servlet> <servlet-name>springmvc</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</.
springmvc启动加载和处理请求过程
海贼懒懒
12-13 575
启动过程： 1 先加载ContextLoaderListener(负责容器的启动和销毁操作)，默认加载/WEB-INF/applicationContext.xml这个文件（如果没有需要加载的文件可以不写Listener） <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> &lt
Python学习笔记—— 面向对象1. 面向对象基础
weixin_44275448的博客
09-16 397
Python学习笔记—— 面向对象1. 面向对象基础 1. 定义只包含方法的类 在Python中要定义一个只包含方法的类，语法格式如下： class 类名： def 方法1（self,参数列表）： pass def 方法2（self,参数列表）： pass 方法的定义和一般的函数一样，区别在于第一个参数必须是self 2. 创建对象 当一个类定义完成之后，要使用这个类创建对象，语法格式如下: 对象变量 = 类名（） ...
SpringMVC配置文件解析（五）
BryantLmm的博客
01-07 509
前言我们接着讲解SpringMVC处理静态资源的方法，这一篇要讲解的是<mvc:default-servlet-handler/>配置处理静态资源的原理\的解析不多说废话了，直接来到DefaultServletHandlerBeanDefinitionParser的parse方法@Override public BeanDefinition parse(Element element, Pa
springMVC系列源码之配置文件深入——11
Oscar Chen
02-24 2468
摘要：上文中结合源码对springMVC初始化过程有了一定的了解、其中也涉及到了springMVC配置文件的加载、本文深入、具体的分析一下关于springMVC配置文件的一些东西。
Java实现的Spring-SpringMVC-Mybatis企业进销存系统
该系统基于SSM框架（Spring、SpringMVC、MyBatis）开发，使用JDK 8和Eclipse IDE，数据库环境为MySQL。通过提供的百度云链接，可以下载到完整的源代码并进行运行。" 本项目是一个典型的Java企业级应用，采用三层...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值