springMVC源码分析--AbstractUrlHandlerMapping（三）

最新推荐文章于 2023-11-09 09:48:19 发布
最新推荐文章于 2023-11-09 09:48:19 发布
阅读量379 收藏 1
点赞数
分类专栏： javaweb 文章标签： javaweb

转载 https://blog.csdn.net/weixin_37647084/article/details/60866211

接下来我们介绍其子类AbstractUrlHandlerMapping。

在上一篇博客中我们了解到AbstractHandlerMapping提供了一个抽象类getHandlerInternal（HttpServletRequest request），我们首先看看AbstractUrlHandlerMapping中对抽象类getHandlerInternal（HttpServletRequest request）的实现。
 

//获取Handler，主要是通过url和method的对应关系来查找
	@Override
	protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
		//获取request中的请求链接
		String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
		//根据链接查找handler
		Object handler = lookupHandler(lookupPath, request);
		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.
			//定义一个变量，保存找到的原始Handler
			Object rawHandler = null;
			if ("/".equals(lookupPath)) {
				rawHandler = getRootHandler();
			}
			if (rawHandler == null) {
				rawHandler = getDefaultHandler();
			}
			if (rawHandler != null) {
				// Bean name or resolved handler?
				//如果是String类型则到容器中查找具体的Bean
				if (rawHandler instanceof String) {
					String handlerName = (String) rawHandler;
					rawHandler = getApplicationContext().getBean(handlerName);
				}
				validateHandler(rawHandler, request);
				handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
			}
		}
		if (handler != null && logger.isDebugEnabled()) {
			logger.debug("Mapping [" + lookupPath + "] to " + handler);
		}
		else if (handler == null && logger.isTraceEnabled()) {
			logger.trace("No handler mapping found for [" + lookupPath + "]");
		}
		return handler;
	}

从上面的实现方法getHandlerInternal来看，首先是通过lookupHandler方法来查找Handler，这里我们看到了之前说的Map对象，用来存储url和Handler之间的关系，当Handler获取为String时需要从Bean容器中获取注入的实现类，当然在查找过程中也会有模糊匹配等查找过程。
 

protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
		// Direct match?
		//直接从map中获取
		Object handler = this.handlerMap.get(urlPath);
		if (handler != null) {
			// Bean name or resolved handler?
			//如果是String类型则从容器中获取
			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) {
				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>();
			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);
				}
			}
			if (logger.isDebugEnabled()) {
				logger.debug("URI Template variables for request [" + urlPath + "] are " + uriTemplateVariables);
			}
			return buildPathExposingHandler(handler, bestPatternMatch, pathWithinMapping, uriTemplateVariables);
		}
		// No handler found...
		return null;
	}

上面两个方法介绍了通过url来查找handlerMap获取handler的操作，AbstractUrlHandlerMapping中也提供了注册url和handler到handlerMap中的操作，具体的调用则要到AbstractUrlHandlerMapping的子类中实现。

//注册url和Bean的map，注册多个string的url到一个处理器中
	protected void registerHandler(String[] urlPaths, String beanName) throws BeansException, IllegalStateException {
		Assert.notNull(urlPaths, "URL path array must not be null");
		for (String urlPath : urlPaths) {
			registerHandler(urlPath, beanName);
		}
	}
	
	注册url和Bean的map,将具体的Handler注入到url对应的map中
	protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {
		Assert.notNull(urlPath, "URL path must not be null");
		Assert.notNull(handler, "Handler object must not be null");
		Object resolvedHandler = handler;
 
		// Eagerly resolve handler if referencing singleton via name.
		//如果Handler是String类型而且没有设置lazyInitHandlers则从springMVC容器中获取handler
		if (!this.lazyInitHandlers && handler instanceof String) {
			String handlerName = (String) handler;
			if (getApplicationContext().isSingleton(handlerName)) {
				resolvedHandler = getApplicationContext().getBean(handlerName);
			}
		}
 
		Object mappedHandler = this.handlerMap.get(urlPath);
		if (mappedHandler != null) {
			if (mappedHandler != resolvedHandler) {
				throw new IllegalStateException(
						"Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
						"]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
			}
		}
		else {
			if (urlPath.equals("/")) {
				if (logger.isInfoEnabled()) {
					logger.info("Root mapping to " + getHandlerDescription(handler));
				}
				setRootHandler(resolvedHandler);
			}
			else if (urlPath.equals("/*")) {
				if (logger.isInfoEnabled()) {
					logger.info("Default mapping to " + getHandlerDescription(handler));
				}
				setDefaultHandler(resolvedHandler);
			}
			else {
				this.handlerMap.put(urlPath, resolvedHandler);
				if (logger.isInfoEnabled()) {
					logger.info("Mapped URL path [" + urlPath + "] onto " + getHandlerDescription(handler));
				}
			}
		}
	}

通过上面介绍我们知道AbstractUrlHandlerMapping提供的功能就是根据url从handlerMap中获取handler和注册url和handler的对应关系到handlerMap中，当然这个过程中还包含很多其他的操作。
AbstractUrlHandlerMapping的完整源码如下：
 

public abstract class AbstractUrlHandlerMapping extends AbstractHandlerMapping {
 
	private Object rootHandler;
 
	private boolean useTrailingSlashMatch = false;
 
	private boolean lazyInitHandlers = false;
 
	private final Map<String, Object> handlerMap = new LinkedHashMap<String, Object>();
 
	public void setRootHandler(Object rootHandler) {
		this.rootHandler = rootHandler;
	}
 
	public Object getRootHandler() {
		return this.rootHandler;
	}
 
	public void setUseTrailingSlashMatch(boolean useTrailingSlashMatch) {
		this.useTrailingSlashMatch = useTrailingSlashMatch;
	}
 
	public boolean useTrailingSlashMatch() {
		return this.useTrailingSlashMatch;
	}
 
	public void setLazyInitHandlers(boolean lazyInitHandlers) {
		this.lazyInitHandlers = lazyInitHandlers;
	}
	
	//获取Handler，主要是通过url和method的对应关系来查找
	@Override
	protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
		//获取request中的请求链接
		String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
		//根据链接查找handler
		Object handler = lookupHandler(lookupPath, request);
		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.
			//定义一个变量，保存找到的原始Handler
			Object rawHandler = null;
			if ("/".equals(lookupPath)) {
				rawHandler = getRootHandler();
			}
			if (rawHandler == null) {
				rawHandler = getDefaultHandler();
			}
			if (rawHandler != null) {
				// Bean name or resolved handler?
				//如果是String类型则到容器中查找具体的Bean
				if (rawHandler instanceof String) {
					String handlerName = (String) rawHandler;
					rawHandler = getApplicationContext().getBean(handlerName);
				}
				validateHandler(rawHandler, request);
				handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
			}
		}
		if (handler != null && logger.isDebugEnabled()) {
			logger.debug("Mapping [" + lookupPath + "] to " + handler);
		}
		else if (handler == null && logger.isTraceEnabled()) {
			logger.trace("No handler mapping found for [" + lookupPath + "]");
		}
		return handler;
	}
	
	protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
		// Direct match?
		//直接从map中获取
		Object handler = this.handlerMap.get(urlPath);
		if (handler != null) {
			// Bean name or resolved handler?
			//如果是String类型则从容器中获取
			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) {
				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>();
			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);
				}
			}
			if (logger.isDebugEnabled()) {
				logger.debug("URI Template variables for request [" + urlPath + "] are " + uriTemplateVariables);
			}
			return buildPathExposingHandler(handler, bestPatternMatch, pathWithinMapping, uriTemplateVariables);
		}
		// No handler found...
		return null;
	}
 
	protected void validateHandler(Object handler, HttpServletRequest request) throws Exception {
	}
 
	//用于给找到的Handler注册两个拦截器PathExposingHandlerInterceptor和UriTemplateVariablesHandlerInterceptor
	//这两个拦截器的的作用是将与当前url实际匹配的Pattern、匹配条件和url模板参数设置到request的属性中
	protected Object buildPathExposingHandler(Object rawHandler, String bestMatchingPattern,
			String pathWithinMapping, Map<String, String> uriTemplateVariables) {
 
		HandlerExecutionChain chain = new HandlerExecutionChain(rawHandler);
		chain.addInterceptor(new PathExposingHandlerInterceptor(bestMatchingPattern, pathWithinMapping));
		if (!CollectionUtils.isEmpty(uriTemplateVariables)) {
			chain.addInterceptor(new UriTemplateVariablesHandlerInterceptor(uriTemplateVariables));
		}
		return chain;
	}
 
	protected void exposePathWithinMapping(String bestMatchingPattern, String pathWithinMapping, HttpServletRequest request) {
		request.setAttribute(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE, bestMatchingPattern);
		request.setAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, pathWithinMapping);
	}
 
	protected void exposeUriTemplateVariables(Map<String, String> uriTemplateVariables, HttpServletRequest request) {
		request.setAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, uriTemplateVariables);
	}
	
	//注册url和Bean的map，注册多个string的url到一个处理器中
	protected void registerHandler(String[] urlPaths, String beanName) throws BeansException, IllegalStateException {
		Assert.notNull(urlPaths, "URL path array must not be null");
		for (String urlPath : urlPaths) {
			registerHandler(urlPath, beanName);
		}
	}
	
	注册url和Bean的map,将具体的Handler注入到url对应的map中
	protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {
		Assert.notNull(urlPath, "URL path must not be null");
		Assert.notNull(handler, "Handler object must not be null");
		Object resolvedHandler = handler;
 
		// Eagerly resolve handler if referencing singleton via name.
		//如果Handler是String类型而且没有设置lazyInitHandlers则从springMVC容器中获取handler
		if (!this.lazyInitHandlers && handler instanceof String) {
			String handlerName = (String) handler;
			if (getApplicationContext().isSingleton(handlerName)) {
				resolvedHandler = getApplicationContext().getBean(handlerName);
			}
		}
 
		Object mappedHandler = this.handlerMap.get(urlPath);
		if (mappedHandler != null) {
			if (mappedHandler != resolvedHandler) {
				throw new IllegalStateException(
						"Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
						"]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
			}
		}
		else {
			if (urlPath.equals("/")) {
				if (logger.isInfoEnabled()) {
					logger.info("Root mapping to " + getHandlerDescription(handler));
				}
				setRootHandler(resolvedHandler);
			}
			else if (urlPath.equals("/*")) {
				if (logger.isInfoEnabled()) {
					logger.info("Default mapping to " + getHandlerDescription(handler));
				}
				setDefaultHandler(resolvedHandler);
			}
			else {
				this.handlerMap.put(urlPath, resolvedHandler);
				if (logger.isInfoEnabled()) {
					logger.info("Mapped URL path [" + urlPath + "] onto " + getHandlerDescription(handler));
				}
			}
		}
	}
 
	private String getHandlerDescription(Object handler) {
		return "handler " + (handler instanceof String ? "'" + handler + "'" : "of type [" + handler.getClass() + "]");
	}
 
	public final Map<String, Object> getHandlerMap() {
		return Collections.unmodifiableMap(this.handlerMap);
	}
 
	protected boolean supportsTypeLevelMappings() {
		return false;
	}
 
	private class PathExposingHandlerInterceptor extends HandlerInterceptorAdapter {
 
		private final String bestMatchingPattern;
 
		private final String pathWithinMapping;
 
		public PathExposingHandlerInterceptor(String bestMatchingPattern, String pathWithinMapping) {
			this.bestMatchingPattern = bestMatchingPattern;
			this.pathWithinMapping = pathWithinMapping;
		}
 
		@Override
		public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
			exposePathWithinMapping(this.bestMatchingPattern, this.pathWithinMapping, request);
			request.setAttribute(HandlerMapping.INTROSPECT_TYPE_LEVEL_MAPPING, supportsTypeLevelMappings());
			return true;
		}
 
	}
	
	private class UriTemplateVariablesHandlerInterceptor extends HandlerInterceptorAdapter {
 
		private final Map<String, String> uriTemplateVariables;
 
		public UriTemplateVariablesHandlerInterceptor(Map<String, String> uriTemplateVariables) {
			this.uriTemplateVariables = uriTemplateVariables;
		}
 
		@Override
		public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
			exposeUriTemplateVariables(this.uriTemplateVariables, request);
			return true;
		}
	}
 
}

 

biange2019
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringMVC源码解读之HandlerMapping - AbstractUrlHandlerMapping系列request分发
09-02
主要介绍了SpringMVC源码解读之HandlerMapping - AbstractUrlHandlerMapping系列request分发 的相关资料,需要的朋友可以参考下
AntPathMatcher路径匹配器，Ant风格的URL
架构师：通透，才能写出好代码！
06-23 4261
Regex还是Ant风格的URL？
SpringMVC源码分析之一AbstractHandlerMapping
热门推荐
liushangzaibeijing的博客
08-15 6万+
关于HandlerMapping的抽象层面的三个类进行了简单的介绍和分析，HandlerMapping接口。 AbstractHandlerMapping接口：对HandlerMapping接口进行简单的实现，通过模板设计模式，提供相关的钩子函数进行子类实现 AbstractUrlHandlerMapping接口：根据url获取对应类级别的Handler对象的处理器。 AbstractHandlerMethodMapping接口：根据请求获取对应Method级别的Handler对象的处理器
Spring以及Springboot 参数绑定原理及使用
weiruiwei的专栏
04-19 3207
Spring-web给我们提供了丰富的参数绑定功能，本文主要说明参数绑定的原理以及使用方式，主要围绕@RequestBody @RequestParam @PathVariable这3种方式 public interface HandlerMethodArgumentResolver { /** * Whether the given {@linkplain MethodParameter method param......
在拦截器中获取 url 路径里面 @PathVariable 的参数值
nimo10050的博客
05-25 9689
解决办法 Map pathVariables = (Map) request.getAttribute( HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE); String classId = (String)pathVariables.get("classId"); 示例接口 // 获取某个班级下面的学生列表 @RequestMapping("/classes/{classId}/students") public String l
springmvc-base-quick.rar
最新发布
12-21
springmvc-base-quick.rar
SpringMVC-Mybatis-Shiro-redis-0.2-master
01-25
基于SpringMVC Mybatis Shiro Redis 的权限管理系统，该系统已经部署到线上，线上访问地址：http://shiro.itboy.net，登录账号：admin 密码：sojson，，详细教程参考sojson.com/shiro
SpringMVC ---- HelloWorld ---- 代码
09-18
SpringMVC ---- HelloWorld ---- 代码 SpringMVC ---- HelloWorld ---- 代码 SpringMVC ---- HelloWorld ---- 代码 SpringMVC ---- HelloWorld ---- 代码 SpringMVC ---- HelloWorld ---- 代码 SpringMVC ---- Hello...
SpringMVC-Mybatis-Shiro-redis
02-23
基于SpringMVC、Mybatis、Redis、Freemarker的Shiro管理Demo源码的升级版 相关详细配置说明请参看 --> http://www.sojson.com/shiro
HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE
每天开发代码之余，写点对大家有用的文章。
11-09 198
使用方式二：通过request的RequestMappingHandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE这个属性获取到一个Map,然后根据上面的key进行取值。使用方式一：就像上面那样{}代表占位符，匹配URL中/ /两个之间的内容，通过@PathVariable进行解析。
Spring MVC 源码 - HandlerMapping 组件（一）之 AbstractHandlerMapping
Coder_Boy_的博客
02-21 539
这里是通过一个一个的 HandlerMapping 组件去进行处理，如果找到对应 HandlerExecutionChain 对象则直接返回，不会继续下去，所以初始化的 HandlerMapping 组件是有一定的先后顺序的，默认是BeanNameUrlHandlerMapping -> RequestMappingHandlerMapping。方法，从 Spring 的上下文中，扫描已注册的 MappedInterceptor 的拦截器们，添加到。等注解的方式所取代。等注解的方式所取代。
SpringMVC------AbstractHandlerMapping
霓虹深处
07-29 300
初始化 @Override protected void initApplicationContext() throws BeansException { //供子类扩展添加拦截器，目前spring没有自行实现 extendInterceptors(this.interceptors); //搜寻springmvc中的MappedInterceptors...
SpringMVC源码分析之AbstractHandlerMethodMapping体系扩展
liushangzaibeijing的博客
09-12 5万+
该篇文章根据请求获取对应的Method级别的Handler,核心类为RequestMappingHandlerMapping该类也是我们业务场景中最常使用的spring处理器映射器的首选，本篇博文从两个方面对该类的功能进行分析 1是对所有使用@RequestMaping修饰的方法 抽取出对应的映射关系RequestMappingInfo进行初始化，2是模拟真实请求来通过处理器的核心方法getHandler(request)获取对应的Handler方法，对于我们理解spring处理器映射器有很大帮助。
SpringMVC源码系列：AbstractHandlerMapping
weixin_34087307的博客
01-11 188
SpringMVC源码系列：HandlerMapping SpringMVC源码系列：AbstractHandlerMapping AbstractHandlerMapping是实现HandlerMapping接口的一个抽象基类。支持排序，默认处理程序，处理程序拦截器，包括由路径模式映射的处理程序拦截器。所有的HandlerMapping都继承自AbstractHandlerMapping。另...
Spring MVC 源码 - HandlerMapping 组件（三）之 AbstractHandlerMethodMapping
Coder_Boy_的博客
02-21 702
这样一来，当 Spring MVC 的 DispatcherServlet 处理请求的时候，获取到对应的 HandlerMethod 处理器，就可以通过反射执行对应的方法了。时代，我们需要编写许多的 Servlet 去处理请求，然后在 web.xml 中进行配置，而 Spring MVC 让你通过只要在类和方法上面添加。这样是不是简化了你的工作量，让你专注于业务开发。注解的方法，假设它所在的类为 UserController ，对应的方法名为 login ，则它对应的 Mapping 的名字就是。
JavaWeb学习之——Spring篇之HandlerMapping
chuandie7960的博客
01-15 587
1.HandlerMapping HandlerMapping接口只有一个方法 HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception; 就是根据Reuqest返回HandlerExec...
springmvc三种不同的HandlerMapping介绍
cyh的博客
02-27 1236
先来看看继承关系，其中主要的类为 RequestMappingUrlHandlerMapping、 BeanNameUrlHandlerMapping、 SimpleUrlHandlerMapping。 1.类型一：RequestMappingUrlHandlerMapping 该类型用于匹配我们最常用的controller类。 原理是，发起请求后，RequestMappingUrlHandlerMapping匹配到RequestMapping注解中实际的url路径，从自身维护的map中根据url取出对应
请求处理过程3-解析参数
weixin_46666822的博客
05-14 731
请求进来，先找到能处理的controller，再找到处理器适配器，完成controller方法的调用。 调用方法的第一步就是先要获取方法参数，这里也是请求参数。然后处理返回结果，再然后渲染页面。 1.handle方法 调用刚刚找到的RequestMappingHandlerAdapter的handle方法，完成请求的执行。 2.handleInternal方法 然后调用RequestMappingHandlerAdapter类的handleInternal方法， 这里有三个步骤 1.对请求进行检查， 2.然
springmvc整合mybatis-plus
03-16
SpringMVC整合Mybatis-Plus是一种常见的Java Web开发方式，它可以让开发者更加方便地进行数据库操作。Mybatis-Plus是Mybatis的增强工具，可以简化Mybatis的开发流程，提高开发效率。整合SpringMVC和Mybatis-Plus需要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值