经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Spring » 查看文章
java?spring?mvc处理器映射器介绍
来源：jb51　　时间：2022/3/29 16:18:08　　对本文有异议

前言：

  • 本文源码基于spring-framework-5.3.10。
  • mvc是spring源码中的一个子模块！

一、RequestMappingHandlerMapping解析映射简单介绍

  • @RequestMapping通过RequestMappingHandlerMapping进行解析！
  • HandlerMapping是一个根据URL映射到Handler的方法。
  • RequestMappingHandlerMapping是HandlerMapping的一个子类！
  • RequestMappingHandlerMapping他的父类有InitializingBean，所有在spring启动实例化的时候会调用afterPropertiesSet()方法。解析逻辑就在这里。
  • RequestMappingHandlerMapping有俩个过程：解析、映射

二、@RequestMapping解析源码流程

  • 容器加载，调用RequestMappingHandlerMapping的afterPropertiesSet()。
  • 调用父类的afterPropertiesSet()方法。
  • 调用initHandlerMethods()方法。
  • 循环每一个Bean，看方法上有@RequestMapping或者@Controller的Bean。
  • 解析HandlerMethods，进行封装RequestMappingInfo。
  • 将封装好的RequestMappingInfo存起来：key为路径，值为mapping（RequestMappingInfo）

三、@RequestMapping映射源码流程

  • 请求进来，调用getHandler方法。
  • 获取当前请求对应的HandlerMethod。
  • 通过UrlPathHelper对象，用于来解析从们的request中解析出请求映射路径。
  • 更具路径去pathLookup中找。
  • 上面没找到，从所有的里面找有通配符的。
  • 找到多个进行排序，优先级：? > * > {} >** 。
  • 不为空拿到第一个返回。
  • 如果为空获取默认的。默认还是空的，直接返回null。
  • 封装拦截器，返回。

四、@RequestMapping解析源码

  1. /**
  2.  * 解析的开始位置。
  3.  * 由于实现了InitializingBean，初始化Bean的时候调用这个方法。
  4.  * 源码位置：org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping.afterPropertiesSet()
  5.  */
  6. public void afterPropertiesSet() {
  7.  
  8. 	this.config = new RequestMappingInfo.BuilderConfiguration();
  9. 	this.config.setTrailingSlashMatch(useTrailingSlashMatch()); // 尾部斜杠
  10. 	this.config.setContentNegotiationManager(getContentNegotiationManager());
  11.  
  12. 	if (getPatternParser() != null) {
  13. 		this.config.setPatternParser(getPatternParser());
  14. 		Assert.isTrue(!this.useSuffixPatternMatch && !this.useRegisteredSuffixPatternMatch,
  15. 				"Suffix pattern matching not supported with PathPatternParser.");
  16. 	}
  17. 	else {
  18. 		this.config.setSuffixPatternMatch(useSuffixPatternMatch());
  19. 		this.config.setRegisteredSuffixPatternMatch(useRegisteredSuffixPatternMatch());
  20. 		this.config.setPathMatcher(getPathMatcher());
  21. 	}
  22. 	
  23. 	// 调用父类的afterPropertiesSet方法
  24. 	super.afterPropertiesSet();
  25. }
  26.  
  27. /**
  28.  * 父类的afterPropertiesSet方法。
  29.  * 源码位置：org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.afterPropertiesSet()
  30.  */
  31. public void afterPropertiesSet() {
  32. 	initHandlerMethods();
  33. }
  34.  
  35. /**
  36.  * 解析@RequestMapping方法
  37.  * 源码位置：org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.initHandlerMethods()
  38.  */
  39. protected void initHandlerMethods() {
  40. 	// 获得所有候选beanName—— 当前容器所有的beanName
  41. 	for (String beanName : getCandidateBeanNames()) {
  42. 		// BeanName不是scopedTarget.开头的
  43. 		if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
  44. 			// *处理候选bean——即解析@RequestMapping和映射路径
  45. 			processCandidateBean(beanName);
  46. 		}
  47. 	}
  48. 	// 解析完所有@RequestMapping的时候调用
  49. 	handlerMethodsInitialized(getHandlerMethods());
  50. }
  51.  
  52. /**
  53.  * 处理候选bean——即解析@RequestMapping和映射路径
  54.  * 源码位置：org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.processCandidateBean(String)
  55.  */
  56. protected void processCandidateBean(String beanName) {
  57. 	Class<?> beanType = null;
  58. 	try {
  59. 		// 得到当前BeanName得到这个Bean的类型
  60. 		beanType = obtainApplicationContext().getType(beanName);
  61. 	}
  62. 	catch (Throwable ex) {
  63. 		// An unresolvable bean type, probably from a lazy bean - let's ignore it.
  64. 		if (logger.isTraceEnabled()) {
  65. 			logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
  66. 		}
  67. 	}
  68. 	// 这一步判断是关键：是否有Controller 或 RequestMapping注解
  69. 	if (beanType != null && isHandler(beanType)) {
  70. 		// 解析HandlerMethods
  71. 		detectHandlerMethods(beanName);
  72. 	}
  73. }
  74.  
  75. /**
  76.  * 解析HandlerMethods
  77.  * 源码位置：org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.detectHandlerMethods(Object)
  78.  */
  79. protected void detectHandlerMethods(Object handler) {
  80. 	Class<?> handlerType = (handler instanceof String ?
  81. 			obtainApplicationContext().getType((String) handler) : handler.getClass());
  82.  
  83. 	if (handlerType != null) {
  84. 		Class<?> userType = ClassUtils.getUserClass(handlerType);
  85. 		// 循环所有方法
  86. 		Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
  87. 				(MethodIntrospector.MetadataLookup<T>) method -> {
  88. 					try {
  89. 						// 根据Method得到Mapping映射
  90. 						return getMappingForMethod(method, userType);
  91. 					}
  92. 					catch (Throwable ex) {
  93. 						throw new IllegalStateException("Invalid mapping on handler class [" +
  94. 								userType.getName() + "]: " + method, ex);
  95. 					}
  96. 		});
  97. 		if (logger.isTraceEnabled()) {
  98. 			logger.trace(formatMappings(userType, methods));
  99. 		}
  100. 		else if (mappingsLogger.isDebugEnabled()) {
  101. 			mappingsLogger.debug(formatMappings(userType, methods));
  102. 		}
  103. 		// 遍历每一个方法，这里是所有Bean的所有方法
  104. 		methods.forEach((method, mapping) -> {
  105. 			Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
  106. 			// pathLookup放入：key为路径，值为mapping（RequestMappingInfo）
  107. 			registerHandlerMethod(handler, invocableMethod, mapping);
  108. 		});
  109. 	}
  110. }
  111.  
  112. /**
  113.  * 根据Method得到Mapping映射
  114.  * 源码位置：org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping.getMappingForMethod(Method, Class<?>)
  115.  */
  116. protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
  117. 	// 如果方法上面有@RequestMapping：解析出RequestMappingInfo
  118. 	// RequestMappingInfo 是用来在请求的时候做匹对的
  119. 	RequestMappingInfo info = createRequestMappingInfo(method);
  120. 	if (info != null) {
  121. 		// 如果方法上面有@RequestMapping，看看类上面是不是有@RequestMapping
  122. 		RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
  123. 		// 类上面也有@RequestMapping  那就合并
  124. 		// 比如 类：/user  方法：/info 合并为 /user/info
  125. 		if (typeInfo != null) {
  126. 			info = typeInfo.combine(info);
  127. 		}
  128.  
  129. 		// 合并前缀   5.1新增  默认null
  130. 		// 可通过 WebMvcConfigurer#configurePathMatch 进行定制
  131. 		String prefix = getPathPrefix(handlerType);
  132. 		if (prefix != null) {
  133. 			info = RequestMappingInfo.paths(prefix).options(this.config).build().combine(info);
  134. 		}
  135. 	}
  136. 	return info;
  137. }
  138.  
  139. /**
  140.  * 创建请求映射信息的外部逻辑
  141.  * 源码位置：org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping.createRequestMappingInfo(AnnotatedElement)
  142.  */
  143. private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
  144. 	// 获取RequestMapping注解信息
  145. 	RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(element, RequestMapping.class);
  146. 	// 获取请求调解：[可扩展]， 如果有：该条件会在请求时匹对
  147. 	RequestCondition<?> condition = (element instanceof Class ?
  148. 			getCustomTypeCondition((Class<?>) element) : getCustomMethodCondition((Method) element));
  149. 	// 如果有RequestMapping注解，封装成RequestMappingInfo
  150. 	return (requestMapping != null ? createRequestMappingInfo(requestMapping, condition) : null);
  151. }
  152.  
  153. /**
  154.  * 创建请求映射信息的内部逻辑
  155.  * 源码位置：org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping.createRequestMappingInfo(RequestMapping, RequestCondition<?>)
  156.  */
  157. protected RequestMappingInfo createRequestMappingInfo(
  158. 		RequestMapping requestMapping, @Nullable RequestCondition<?> customCondition) {
  159. 	// 将@RequestMapping注解属性的值构建成一个 RequestMappingInfo
  160. 	RequestMappingInfo.Builder builder = RequestMappingInfo
  161. 			//构建路径
  162. 			.paths(resolveEmbeddedValuesInPatterns(requestMapping.path()))
  163. 			//构建方法(get还是post等)
  164. 			.methods(requestMapping.method())
  165. 			//参数 对应http request parameter
  166. 			.params(requestMapping.params())
  167. 			//头部
  168. 			.headers(requestMapping.headers())
  169. 			//request的提交内容类型content type,如application/json, text/html
  170. 			.consumes(requestMapping.consumes())
  171. 			//指定返回的内容类型的content type，仅当request请求头中的(Accept)类型中包含该指定类型才返回
  172. 			.produces(requestMapping.produces())
  173. 			.mappingName(requestMapping.name());
  174. 	if (customCondition != null) {
  175. 		builder.customCondition(customCondition);
  176. 	}
  177. 	// 构造RequestMappingInfo：将上面的属性构建成一个个的RequestCondition对象方便在请求的时候组合匹对
  178. 	return builder.options(this.config).build();
  179. }
  180.  
  181. /**
  182.  * 得到所有的方法
  183.  * 源码位置：org.springframework.core.MethodIntrospector.selectMethods(Class<?>, MetadataLookup<T>)
  184.  */
  185. public static <T> Map<Method, T> selectMethods(Class<?> targetType, final MetadataLookup<T> metadataLookup) {
  186. 	final Map<Method, T> methodMap = new LinkedHashMap<>();
  187. 	Set<Class<?>> handlerTypes = new LinkedHashSet<>();
  188. 	Class<?> specificHandlerType = null;
  189. 	//获取原始的class对象
  190. 	if (!Proxy.isProxyClass(targetType)) {
  191. 		specificHandlerType = ClassUtils.getUserClass(targetType);
  192. 		handlerTypes.add(specificHandlerType);
  193. 	}
  194. 	//获取class的接口
  195. 	handlerTypes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetType));
  196. 	//循环我们的class集合
  197. 	for (Class<?> currentHandlerType : handlerTypes) {
  198. 		final Class<?> targetClass = (specificHandlerType != null ? specificHandlerType : currentHandlerType);
  199.  
  200. 		ReflectionUtils.doWithMethods(currentHandlerType, method -> {
  201. 			//获取具体的方法对象
  202. 			Method specificMethod = ClassUtils.getMostSpecificMethod(method, targetClass);
  203. 			 /**回调 即解析@RequestMapping 返回RequestMappingInfo
  204. 			  * @see org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping#getMappingForMethod(java.lang.reflect.Method, java.lang.Class)*/
  205. 			T result = metadataLookup.inspect(specificMethod);
  206. 			if (result != null) {
  207. 				// 看看有没有桥接方法：泛型实现类jvm会自动生成桥接类
  208. 				Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
  209. 				if (bridgedMethod == specificMethod || metadataLookup.inspect(bridgedMethod) == null) {
  210. 					//把方法对象作为key,RequestMappingInfo对象作为value保存到map中
  211. 					methodMap.put(specificMethod, result);
  212. 				}
  213. 			}
  214. 		}, ReflectionUtils.USER_DECLARED_METHODS);
  215. 	}
  216.  
  217. 	return methodMap;
  218. }

五、@RequestMapping映射源码

  1. /**
  2.  * 获取@RequestMapping映射
  3.  * 源码位置：org.springframework.web.servlet.handler.AbstractHandlerMapping.getHandler(HttpServletRequest)
  4.  */
  5. public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
  6. 	// 获取当前请求对应的HandlerMethod
  7. 	Object handler = getHandlerInternal(request);
  8. 	
  9. 	// 获取默认的handler
  10. 	if (handler == null) {
  11. 		handler = getDefaultHandler();
  12. 	}
  13. 	
  14. 	// 还是没有handler的时候返回null，404了
  15. 	if (handler == null) {
  16. 		return null;
  17. 	}
  18. 	// Bean name or resolved handler?
  19. 	// String类型？获取Bean
  20. 	if (handler instanceof String) {
  21. 		String handlerName = (String) handler;
  22. 		handler = obtainApplicationContext().getBean(handlerName);
  23. 	}
  24.  
  25. 	// Ensure presence of cached lookupPath for interceptors and others
  26. 	if (!ServletRequestPathUtils.hasCachedPath(request)) {
  27. 		initLookupPath(request);
  28. 	}
  29.  
  30. 	// 获取拦截器相关的调用链
  31. 	HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
  32.  
  33. 	if (logger.isTraceEnabled()) {
  34. 		logger.trace("Mapped to " + handler);
  35. 	}
  36. 	else if (logger.isDebugEnabled() && !DispatcherType.ASYNC.equals(request.getDispatcherType())) {
  37. 		logger.debug("Mapped to " + executionChain.getHandler());
  38. 	}
  39.  
  40. 	if (hasCorsConfigurationSource(handler) || CorsUtils.isPreFlightRequest(request)) {
  41. 		CorsConfiguration config = getCorsConfiguration(handler, request);
  42. 		if (getCorsConfigurationSource() != null) {
  43. 			CorsConfiguration globalConfig = getCorsConfigurationSource().getCorsConfiguration(request);
  44. 			config = (globalConfig != null ? globalConfig.combine(config) : config);
  45. 		}
  46. 		if (config != null) {
  47. 			config.validateAllowCredentials();
  48. 		}
  49. 		executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
  50. 	}
  51.  
  52. 	return executionChain;
  53. }
  54.  
  55. /**
  56.  * 获取当前请求对应的HandlerMethod
  57.  * 源码位置：org.springframework.web.servlet.mvc.method.RequestMappingInfoHandlerMapping.getHandlerInternal(HttpServletRequest)
  58.  */
  59. protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
  60. 	request.removeAttribute(PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);
  61. 	try {
  62. 		// 直接调用父类的getHandlerInternal方法
  63. 		return super.getHandlerInternal(request);
  64. 	}
  65. 	finally {
  66. 		ProducesRequestCondition.clearMediaTypesAttribute(request);
  67. 	}
  68. }
  69. /**
  70.  * 获取当前请求对应的HandlerMethod---父类的
  71.  * 源码位置：org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.getHandlerInternal(HttpServletRequest)
  72.  */
  73. protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
  74. 	// 通过UrlPathHelper对象，用于来解析从们的request中解析出请求映射路径
  75. 	String lookupPath = initLookupPath(request);
  76. 	this.mappingRegistry.acquireReadLock();
  77. 	try {
  78. 		// 通过lookupPath解析最终的handler——HandlerMethod对象
  79. 		HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
  80. 		return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
  81. 	}
  82. 	finally {
  83. 		this.mappingRegistry.releaseReadLock();
  84. 	}
  85. }
  86.  
  87. /**
  88.  * 通过lookupPath解析最终的handler
  89.  * 源码位置：org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.lookupHandlerMethod(String, HttpServletRequest)
  90.  */
  91. protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
  92. 	List<Match> matches = new ArrayList<>();
  93. 	// 根据uri从mappingRegistry.pathLookup获取 RequestMappingInfo
  94. 	// pathLookup<path,RequestMappingInfo>会在初始化阶段解析好
  95. 	List<T> directPathMatches = this.mappingRegistry.getMappingsByDirectPath(lookupPath);
  96. 	if (directPathMatches != null) {
  97. 		// 如果根据path能直接匹配的RequestMappingInfo 则用该mapping进行匹配其他条件(method、header等）
  98. 		addMatchingMappings(directPathMatches, matches, request);
  99. 	}
  100. 	if (matches.isEmpty()) {
  101. 		// 如果无path匹配，用所有的RequestMappingInfo  通过AntPathMatcher匹配
  102. 		addMatchingMappings(this.mappingRegistry.getRegistrations().keySet(), matches, request);
  103. 	}
  104. 	if (!matches.isEmpty()) {
  105. 		// 选择第一个为最匹配的
  106. 		Match bestMatch = matches.get(0);
  107. 		/**
  108. 		 * 如果匹配到多个
  109. 		 @RequestMapping(value="/mappin?")
  110. 		 @RequestMapping(value="/mappin*")
  111. 		 @RequestMapping(value="/{xxxx}")
  112. 		 @RequestMapping(value="/**")
  113. 		 */
  114. 		if (matches.size() > 1) {
  115. 			//创建MatchComparator的匹配器对象
  116. 			Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
  117.  
  118. 			/** 根据精准度排序  大概是这样的： ? > * > {} >**   具体可以去看：
  119. 			 * @see org.springframework.util.AntPathMatcher.AntPatternComparator#compare(java.lang.String, java.lang.String)*/
  120. 			matches.sort(comparator);
  121.  
  122. 			// 排完序后拿到优先级最高的
  123. 			bestMatch = matches.get(0);
  124. 			if (logger.isTraceEnabled()) {
  125. 				logger.trace(matches.size() + " matching mappings: " + matches);
  126. 			}
  127. 			// 是否配置CORS并且匹配
  128. 			if (CorsUtils.isPreFlightRequest(request)) {
  129. 				for (Match match : matches) {
  130. 					if (match.hasCorsConfig()) {
  131. 						return PREFLIGHT_AMBIGUOUS_MATCH;
  132. 					}
  133. 				}
  134. 			}
  135. 			else {
  136. 				//获取第二最匹配的
  137. 				Match secondBestMatch = matches.get(1);
  138. 				//若第一个和第二个是一样的 抛出异常
  139. 				if (comparator.compare(bestMatch, secondBestMatch) == 0) {
  140. 					Method m1 = bestMatch.getHandlerMethod().getMethod();
  141. 					Method m2 = secondBestMatch.getHandlerMethod().getMethod();
  142. 					String uri = request.getRequestURI();
  143. 					throw new IllegalStateException(
  144. 							"Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}");
  145. 				}
  146. 			}
  147. 		}
  148. 		//把最匹配的设置到request中
  149. 		request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.getHandlerMethod());
  150. 		handleMatch(bestMatch.mapping, lookupPath, request);
  151. 		//返回最匹配的
  152. 		return bestMatch.getHandlerMethod();
  153. 	}
  154. 	else { // return null
  155. 		return handleNoMatch(this.mappingRegistry.getRegistrations().keySet(), lookupPath, request);
  156. 	}
  157. }

到此这篇关于java spring mvc处理器映射器介绍的文章就介绍到这了,更多相关spring mvc处理器映射器内容请搜索w3xue以前的文章或继续浏览下面的相关文章希望大家以后多多支持w3xue！

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Spring热门文章

  • 解决springboot+activemq启动报注解错误的问题
  • Springboot整合Rabbitmq之Confirm和Return机制
  • SpringBoot SpringEL表达式的使用
  • SpringBoot自动配置原理,你真的懂吗?(简单易懂)
  • Spring源码：Bean生命周期（终章）
  • Springboot-Management的项目实践
  • 解决springboot 启动找不到主类的问题
  • Spring5路径匹配器PathPattern解析
  • SpringAOP如何获取方法参数上的注解
  • java与es8实战之五：SpringBoot应用中操作es8(带安全检查：https、账号密码、API Key)

    • Spring推荐文章

  • SpringBoot Session共享，配置不生效问题排查 → 你竟然在代码里下毒！
  • 【Spring源码分析】Spring Scope功能中的动态代理 - Scoped Proxy
  • Spring AOP概念及原理
  • SpringBoot2.7还是任性的，就是不支持Logback1.3，你能奈他何
  • SpringBoot+ Sharding Sphere 轻松实现数据库字段加解密
  • Spring MVC 中视图的实现原理，在Spring MVC 中实现重定向和转发，以及访问静态资源 - Rainbow-Sea
  • Spring MVC 中 HttpMessageConverter 转换器 - Rainbow-Sea
  • SpringBoot+mail 轻松实现各类邮件自动推送
  • Spring MVC 获取三个域(request请求域，session 会话域，application 应用域)对象的方式 - Rainbow-Sea
  • SpringBoot3整合SpringDoc实现在线接口文档

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号