spring4.3.6源代码 - webmvc - BeanNameUrlHandlerMapping 路由识别、拦截器识别、路由匹配、参数解析器、返回值处理器

最新推荐文章于 2024-08-18 13:32:19 发布
最新推荐文章于 2024-08-18 13:32:19 发布
阅读量160 收藏
点赞数
分类专栏： spring4.3.6 spring Java 文章标签： spring java spring4.3.6
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouzhiande/article/details/108227603
版权
Java 同时被 3 个专栏收录
133 篇文章 1 订阅
订阅专栏
spring
37 篇文章 0 订阅
订阅专栏
spring4.3.6
21 篇文章 0 订阅
订阅专栏

 

org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping

--------------BeanNameUrlHandlerMapping如何扫描Interceptor、Handler-------------------
org.springframework.context.support.ApplicationObjectSupport.setApplicationContext(ApplicationContext context)
{
	this.applicationContext = context;
	org.springframework.web.context.support.WebApplicationObjectSupport.initApplicationContext(ApplicationContext context)
	{
		org.springframework.context.support.ApplicationObjectSupport.initApplicationContext(ApplicationContext context)
		{
			org.springframework.web.servlet.handler.AbstractDetectingUrlHandlerMapping.initApplicationContext()
			{
				org.springframework.web.servlet.handler.AbstractHandlerMapping.initApplicationContext()
				{
					AbstractHandlerMapping.extendInterceptors(this.interceptors); // 空方法
				AbstractHandlerMapping.detectMappedInterceptors(this.adaptedInterceptors); // 扫描applicationContext.xml文件，找出MappedInterceptor类型的bean
				{
					mappedInterceptors.addAll(
						BeanFactoryUtils.beansOfTypeIncludingAncestors(
								getApplicationContext(), MappedInterceptor.class, true, false).values());
				}
				AbstractHandlerMapping.initInterceptors(); // 适配 Interceptors
				{
					if (!this.interceptors.isEmpty()) {
						for (int i = 0; i < this.interceptors.size(); i++) {
							Object interceptor = this.interceptors.get(i);
							if (interceptor == null) {
								throw new IllegalArgumentException("Entry number " + i + " in interceptors array is null");
							}
							this.adaptedInterceptors.add(adaptInterceptor(interceptor){
								if (interceptor instanceof HandlerInterceptor) {
									return (HandlerInterceptor) interceptor;
								}
								else if (interceptor instanceof WebRequestInterceptor) {
									return new WebRequestHandlerInterceptorAdapter((WebRequestInterceptor) interceptor);
								}
							}); // 适配，并注册Interceptor ----- 1
						}
					}
				}
				}
				
				org.springframework.web.servlet.handler.AbstractDetectingUrlHandlerMapping.detectHandlers() // 扫描applicationContext.xml文件的所有bean，根据beanName识别出Handler
				{
					String[] beanNames = (this.detectHandlersInAncestorContexts ?
						BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
						getApplicationContext().getBeanNamesForType(Object.class));
				// Take any bean name that we can determine URLs for.
				for (String beanName : beanNames) {
					String[] urls = determineUrlsForHandler(beanName);
					{
						org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping.determineUrlsForHandler(String beanName)
						{
							List<String> urls = new ArrayList<String>();
							if (beanName.startsWith("/")) { // 以“/”开头的beanName被认为是Handler
								urls.add(beanName);
							}
							String[] aliases = getApplicationContext().getAliases(beanName);
							for (String alias : aliases) {
								if (alias.startsWith("/")) {
									urls.add(alias);
								}
							}
							return StringUtils.toStringArray(urls);
						}
					}
					if (!ObjectUtils.isEmpty(urls)) {
						// URL paths found: Let's consider it a handler.
						registerHandler(urls, beanName); // !!!
						{
							org.springframework.web.servlet.handler.AbstractUrlHandlerMapping.registerHandler(String[] urlPaths, String beanName)
							{
								for (String urlPath : urlPaths) {
									AbstractUrlHandlerMapping.registerHandler(urlPath, beanName);
									{
										if (urlPath.equals("/")) {
											setRootHandler(resolvedHandler);
										}
										else if (urlPath.equals("/*")) {
											setDefaultHandler(resolvedHandler);
										}
										else {
											this.handlerMap.put(urlPath, resolvedHandler); // 注册Handler ----- 2
										}
									}
								}
							}
						}
					}
					else {
					}
				}
				}
			}
		}
		this.servletContext = ((WebApplicationContext) context).getServletContext();
		org.springframework.web.context.support.WebApplicationObjectSupport.initServletContext(ServletContext servletContext);
	}
}

-------------- BeanNameUrlHandlerMapping 如何匹配符合条件的Handler-------------------
org.springframework.web.servlet.handler.AbstractHandlerMapping.getHandler(HttpServletRequest request)
{
	org.springframework.web.servlet.handler.AbstractUrlHandlerMapping.getHandlerInternal(HttpServletRequest request)
	{
		// org.springframework.web.util.UrlPathHelper.getLookupPathForRequest(request);
	String lookupPath = getUrlPathHelper().getLookupPathForRequest(request); // 请求地址
	Object handler = AbstractUrlHandlerMapping.lookupHandler(lookupPath, request); // !!! 返回Handler执行链
	{
		// Direct match?  直接匹配
		Object handler = this.handlerMap.get(urlPath);
		if (handler != null) {
			// Bean name or resolved handler?
			if (handler instanceof String) {
				String handlerName = (String) handler;
				handler = getApplicationContext().getBean(handlerName);
			}
			validateHandler(handler, request);
			return buildPathExposingHandler(handler, urlPath, urlPath, null);
		}
		// Pattern match? 正则表达式匹配
		List<String> matchingPatterns = new ArrayList<String>();
		for (String registeredPattern : this.handlerMap.keySet()) {
			if (getPathMatcher().match(registeredPattern, urlPath)) {
				matchingPatterns.add(registeredPattern);
			}
			else if (useTrailingSlashMatch()) {
				if (!registeredPattern.endsWith("/") && getPathMatcher().match(registeredPattern + "/", urlPath)) {
					matchingPatterns.add(registeredPattern +"/");
				}
			}
		}
		String bestPatternMatch = null;
		Comparator<String> patternComparator = getPathMatcher().getPatternComparator(urlPath);
		if (!matchingPatterns.isEmpty()) {
			Collections.sort(matchingPatterns, patternComparator);
			if (logger.isDebugEnabled()) {
				logger.debug("Matching patterns for request [" + urlPath + "] are " + matchingPatterns);
			}
			bestPatternMatch = matchingPatterns.get(0); // 取第一个作为命中
		}
		if (bestPatternMatch != null) { 
			handler = this.handlerMap.get(bestPatternMatch);
			if (handler == null) {
				Assert.isTrue(bestPatternMatch.endsWith("/"));
				handler = this.handlerMap.get(bestPatternMatch.substring(0, bestPatternMatch.length() - 1));
			}
			// Bean name or resolved handler?
			if (handler instanceof String) { // 配置的是beanName
				String handlerName = (String) handler;
				handler = getApplicationContext().getBean(handlerName); // 实例化
			}
			validateHandler(handler, request);
			String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestPatternMatch, urlPath);

			// There might be multiple 'best patterns', let's make sure we have the correct URI template variables
			// for all of them
			Map<String, String> uriTemplateVariables = new LinkedHashMap<String, String>(); // URL中的模板变量
			for (String matchingPattern : matchingPatterns) {
				if (patternComparator.compare(bestPatternMatch, matchingPattern) == 0) {
					Map<String, String> vars = getPathMatcher().extractUriTemplateVariables(matchingPattern, urlPath);
					Map<String, String> decodedVars = getUrlPathHelper().decodePathVariables(request, vars);
					uriTemplateVariables.putAll(decodedVars);
				}
			}
			return buildPathExposingHandler(handler, bestPatternMatch, pathWithinMapping, uriTemplateVariables);
			{
				HandlerExecutionChain chain = new HandlerExecutionChain(rawHandler); // Handler执行链
				chain.addInterceptor(new PathExposingHandlerInterceptor(bestMatchingPattern, pathWithinMapping){
					public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
						exposePathWithinMapping(this.bestMatchingPattern, this.pathWithinMapping, request);
						{
							request.setAttribute(BEST_MATCHING_PATTERN_ATTRIBUTE, bestMatchingPattern); //  -- 匹配的信息放入request
							request.setAttribute(PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, pathWithinMapping); //  -- 匹配的信息放入request
						}
						request.setAttribute(INTROSPECT_TYPE_LEVEL_MAPPING, supportsTypeLevelMappings());
						return true;
					}
				});// --- 添加内置的拦截器
				if (!CollectionUtils.isEmpty(uriTemplateVariables)) {
					chain.addInterceptor(new UriTemplateVariablesHandlerInterceptor(uriTemplateVariables){
						@Override
						public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
							exposeUriTemplateVariables(this.uriTemplateVariables, request);
							{
								request.setAttribute(URI_TEMPLATE_VARIABLES_ATTRIBUTE, uriTemplateVariables); //  -- 匹配的信息放入request
							}
							return true;
						}
					});// --- 添加内置的拦截器
				}
				return chain;
			}
		}
		// No handler found...
		return null;
	}
	if (handler == null) {
		// We need to care for the default handler directly, since we need to
		// expose the PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE for it as well.
		Object rawHandler = null;
		if ("/".equals(lookupPath)) {
			rawHandler = getRootHandler(); // 根处理器
		}
		if (rawHandler == null) {
			rawHandler = getDefaultHandler(); // 默认处理器
		}
		if (rawHandler != null) {
			// Bean name or resolved handler?
			if (rawHandler instanceof String) {
				String handlerName = (String) rawHandler;
				rawHandler = getApplicationContext().getBean(handlerName);
			}
			validateHandler(rawHandler, request); // 校验请求的method、参数、header是否符合@RequestMapping注解配置的
			handler = AbstractUrlHandlerMapping.buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null); // !!! 返回Handler执行链
			{
				HandlerExecutionChain chain = new HandlerExecutionChain(rawHandler); // Handler执行链
				chain.addInterceptor(new PathExposingHandlerInterceptor(bestMatchingPattern, pathWithinMapping){
					public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
						exposePathWithinMapping(this.bestMatchingPattern, this.pathWithinMapping, request);
						{
							request.setAttribute(BEST_MATCHING_PATTERN_ATTRIBUTE, bestMatchingPattern);
							request.setAttribute(PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, pathWithinMapping);
						}
						request.setAttribute(INTROSPECT_TYPE_LEVEL_MAPPING, supportsTypeLevelMappings());
						return true;
					}
				}); // --- 添加内置的拦截器
				if (!CollectionUtils.isEmpty(uriTemplateVariables)) {
					chain.addInterceptor(new UriTemplateVariablesHandlerInterceptor(uriTemplateVariables){
						@Override
						public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
							exposeUriTemplateVariables(this.uriTemplateVariables, request);
							{
								request.setAttribute(URI_TEMPLATE_VARIABLES_ATTRIBUTE, uriTemplateVariables);
							}
							return true;
						}
					}); // --- 添加内置的拦截器
				}
				return chain;
			}
		}
	}
	return handler;
	}
	
	if (handler == null) {
	handler = getDefaultHandler(); // 使用默认的
}
// Bean name or resolved handler?
if (handler instanceof String) {
	String handlerName = (String) handler;
	handler = getApplicationContext().getBean(handlerName);
}

HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request); // !!!! 获取符合条件的Interceptor
{
	HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
			(HandlerExecutionChain) handler : new HandlerExecutionChain(handler));

	String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
	for (HandlerInterceptor interceptor : this.adaptedInterceptors) {  // 匹配符合条件的Interceptor
		if (interceptor instanceof MappedInterceptor) {
			MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
			if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
				chain.addInterceptor(mappedInterceptor.getInterceptor()); 
			}
		}
		else {
			chain.addInterceptor(interceptor); // 添加拦截器
		}
	}
	return chain;
}
if (CorsUtils.isCorsRequest(request)) { // 是跨域请求
	CorsConfiguration globalConfig = this.corsConfigSource.getCorsConfiguration(request);
	CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
	CorsConfiguration config = (globalConfig != null ? globalConfig.combine(handlerConfig) : handlerConfig);
	executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
}
return executionChain;
}

--------------------执行Handler的过程--------------------------
org.springframework.web.servlet.DispatcherServlet.doDispatch(HttpServletRequest request, HttpServletResponse response)
{
// 如果不是文件上传，processedRequest就是request本身
// Determine handler for the current request.
mappedHandler = getHandler(processedRequest); // 决策一个适合processedRequest的Handler，执行链管理器 mappedHandler ==HandlerExecutionChain
if (mappedHandler == null || mappedHandler.getHandler() == null) {
	noHandlerFound(processedRequest, response);
	return;
}

// ha === org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter
// ha === org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler()); // 决策一个适合Handler的“Handler适配器”， 四种类型的适配器

// 执行拦截器的前置方法
org.springframework.web.servlet.HandlerExecutionChain.applyPreHandle(processedRequest, response)
{
	HandlerInterceptor[] interceptors = getInterceptors();
	if (!ObjectUtils.isEmpty(interceptors)) {
		for (int i = 0; i < interceptors.length; i++) {
			HandlerInterceptor interceptor = interceptors[i];
			if (!interceptor.preHandle(request, response, this.handler)) {
				triggerAfterCompletion(request, response, null); // 如果没有过，直接触发结束的
				{
					HandlerInterceptor[] interceptors = getInterceptors();
					if (!ObjectUtils.isEmpty(interceptors)) {
						for (int i = this.interceptorIndex; i >= 0; i--) {
							HandlerInterceptor interceptor = interceptors[i];
							try {
								interceptor.afterCompletion(request, response, this.handler, ex);
							}
							catch (Throwable ex2) {
								logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
							}
						}
					}
				}
				return false;
			}
			this.interceptorIndex = i;
		}
	}
	return true;
}
 	
// 执行业务方法
{
	if(当是“实现HttpRequestHandler接口的Handler”)
	{
		mv = org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter.handle(processedRequest, response, mappedHandler.getHandler()); // 执行handler的方法，返回值	
		{
			((HttpRequestHandler) handler).handleRequest(request, response); 
			return null; // 没有返回值
		}
	}
	else if(当是“实现Controller接口的Handler”)
	{
		mv = org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter.handle(processedRequest, response, mappedHandler.getHandler()); // 执行handler的方法，返回值	
		{
			return ((Controller) handler).handleRequest(request, response); // 有返回值
		}
	}
}

// 执行拦截器的后置方法
org.springframework.web.servlet.HandlerExecutionChain.applyPostHandle(processedRequest, response, mv);
{
	HandlerInterceptor[] interceptors = getInterceptors();
	if (!ObjectUtils.isEmpty(interceptors)) {
		for (int i = interceptors.length - 1; i >= 0; i--) {
			HandlerInterceptor interceptor = interceptors[i];
			interceptor.postHandle(request, response, this.handler, mv);
		}
	}
}

// 处理视图
org.springframework.web.servlet.DispatcherServlet.processDispatchResult( request,  response,  mappedHandler,  mv,  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);
		}
	}
	DispatcherServlet.render(mv, request, response); // 进行渲染 !!!
	{
		View view;
		if (mv.isReference()) {
			// We need to resolve the view name.
			view = resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request); // 解析视图
			{
				for (ViewResolver viewResolver : this.viewResolvers) {
					// 如：viewResolver == org.springframework.web.servlet.view.InternalResourceViewResolver
					View view = viewResolver.resolveViewName(viewName, locale);
					if (view != null) {
						return view;
					}
				}
			}
		}
		else {
			// No need to lookup: the ModelAndView object contains the actual View object.
			view = mv.getView();
		}

		// Delegate to the View object for rendering.
		try {
			if (mv.getStatus() != null) {
				response.setStatus(mv.getStatus().value()); // 响应状态
			}
			view.render(mv.getModelInternal(), request, response); // 渲染
		}
	}
	
	if (mappedHandler != null) {
		mappedHandler.triggerAfterCompletion(request, response, null); // 触发结束方法
		{
			HandlerInterceptor[] interceptors = getInterceptors();
			if (!ObjectUtils.isEmpty(interceptors)) {
				for (int i = this.interceptorIndex; i >= 0; i--) {
					HandlerInterceptor interceptor = interceptors[i];
					try {
						interceptor.afterCompletion(request, response, this.handler, ex);
					}
					catch (Throwable ex2) {
						logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
					}
				}
			}
		}
	}
}
}

 

 

_jan_
关注
专栏目录
spring-framework-4.3.6.RELEASE-dist.zip
08-25
- **src**：源代码，对于学习和理解Spring的内部工作原理非常有用。 - **docs**：文档，包括API参考、用户指南和开发者指南，帮助开发者更好地使用Spring框架。 - **dist**：预编译的库文件，如jar包，可以被引入到...
spring-webmvc-portlet-4.3.6.RELEASE.jar
01-15
spring-webmvc-portlet-4.3.6.RELEASE.jar
Spring Web MVC 的HandlerMapping的使用之-------BeanNameUrlHandlerMapping
liuxiIT的专栏
07-06 9907
BeanNameUrlHandlerMapping是默认的HandlerMapping
Error creating bean with name ‘org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping
weixin_42596624的博客
06-27 387
跳转页面时出现500错误,Root Cause里写着 Error creating bean with name 'org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping
Spring MVC
最新发布
钟佩颖的学习
08-18 161
什么是MVC 面试题：什么是三层模型，并说一说MVC架构模式与三层模型的区别？ 什么是SpringMVC SpringMVC概述 SpringMVC帮我们做了什么 SpringMVC框架的特点 相关版本 第一个SpringMVC程序
SpringMVC 通过XML方式进行配置解析BeanNameUrlHandlerMapping
mexican_jacky的专栏
12-05 3924
在浏览器中URL地址访问 第一步：web.xml加载DispatcherServlet 在web.xml中配置 第二部：配置dispatcherServlet的配置文件，管理起springMvc的bean 第三部：创建控制器 这个视图解析: 1：http://localhost:808
Spring 源码分析衍生篇十一 ：HandlerMapping
猫吻鱼的博客
10-30 1175
一、前言 在 Spring MVC 的分析过程中，我们知道了 Spring mvc 默认会引入DispatcherServlet.properties 文件中的类(该文件和 DispatcherServlet 在同级目录) 的一些类。 DispatcherServlet.properties 配置文件如下。 # Default implementation classes for DispatcherServlet's strategy interfaces. # Used as fallback when
SpringMVC源码分析(四)--BeanNameUrlHandlerMapping
zmbw2015的博客
03-23 939
本文主要介绍了BeanNameUrlHandlerMapping的作用及原理
开发工具 spring-webmvc-4.3.6.RELEASE
05-31
开发工具 spring-webmvc-4.3.6.RELEASE开发工具 spring-webmvc-4.3.6.RELEASE开发工具 spring-webmvc-4.3.6.RELEASE开发工具 spring-webmvc-4.3.6.RELEASE开发工具 spring-webmvc-4.3.6.RELEASE开发工具 spring-web...
开发工具 框架JAR spring-framework-4.3.6.RELEASE-dist
05-31
开发工具 框架JAR spring-framework-4.3.6.RELEASE-dist开发工具 框架JAR spring-framework-4.3.6.RELEASE-dist开发工具 框架JAR spring-framework-4.3.6.RELEASE-dist开发工具 框架JAR spring-framework-4.3.6....
开发工具 spring-web-4.3.6.RELEASE
05-31
开发工具 spring-web-4.3.6.RELEASE开发工具 spring-web-4.3.6.RELEASE开发工具 spring-web-4.3.6.RELEASE开发工具 spring-web-4.3.6.RELEASE开发工具 spring-web-4.3.6.RELEASE开发工具 spring-web-4.3.6.RELEASE...
SpringMVC默认依赖Bean：BeanNameUrlHandlerMapping
书山有路，学海无涯
08-15 3038
BeanNameUrlHandlerMapping
SpringMVC 5 中的 HandlerMapping
norang的博客
07-14 266
这里写目录标题**HandlerMapping**org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping，org.springframework.web.servlet.handler.SimpleUrlHandlerMappingorg.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping注意参考目录 HandlerMappin
SpringMVC--BeanNameUrlHandlerMapping详解
笃行淡言
08-15 713
简述 SpringMVC框架中在定义URL与控制类之间的映射中有多种实现方式，比如org.springframework.web.servlet.handler.SimpleUrlHandlerMapping、 org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping、org.springframework.web.se
spring mvc源码解读二 ---BeanNameUrlHandlerMapping初始化
sonycong的专栏
06-14 717
大家都知道，springmvc有两个非常重要的类，分别是BeanNameUrlHandlerMapping ，RequestMappingHandlerMapping 这两个类，这两个类是用来存放url对应的controller，如果一个请求过来，会去这两个类中找到对应的controller然后反射调用方法，当然如果是springboot就自己实现3个HandlerMapping去处理更多的请求，...
Spring MVC : HandlerMappingIntrospector
Details Inside Spring
09-19 2172
概述 这是一个Spring MVC助手类，用于集合应用所配置的HandlerMapping(url pattern和请求处理handler之间的映射)表，用于获取针对某个请求的如下信息 : getMatchableHandlerMapping(javax.servlet.http.HttpServletRequest) 寻找能处理指定请求的HandlerMapping，如果找不到，返回null...
springMVC的各种HandlerMapping：（默认有BeanNameUrl和AnnotationHandlerMapping）
09-03 263
1.默认的BeanNameUrlHandlerMapping（通过name查找Controller）用Controller的name来访问 2.ControllerClassNameHandlerMapping（通过Controller类的名字查找Controller。在网页访问除了Controller类首字母大写，其他的（Controller1）都小写） <?...
springMVC源码分析--AbstractUrlHandlerMapping（三）
井底之蛙
12-19 2715
上一篇博客springMVC源码分析--AbstractHandlerMapping（二）中我们介绍了AbstractHandlerMapping了，接下来我们介绍其子类AbstractUrlHandlerMapping。在上一篇博客中我们了解到AbstractHandlerMapping提供了一个抽象类getHandlerInternal（HttpServletRequest request），
BeanNameUrlHandlerMapping类介绍
wang0907的博客
10-18 1794
1：介绍 该类用于维护比如实现了org.springframework.web.servlet.mvc.Controller接口的类型的handler。关于维护使用如@RequestMapping定义的handler的Mapping可以参考[这里],(https://blog.csdn.net/wang0907/article/details/108960496)。另外从其名称中也能看出来，这是一个使用BeanName作为url的mapping。 2：初始化 2.1：入口 先看下BeanNameUrlHan
深入解析Spring事务管理开发工具Spring-tx-4.3.6.RELEASE
资源摘要信息:"spring-tx-4.3.6.RELEASE是Spring框架的事务管理模块的特定版本。Spring框架是由Rod Johnson创建的开源应用程序框架和反转控制容器，用于Java平台。它支持企业级Java应用开发，可以集成多种不同的持久...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值