BeanNameUrlHandlerMapping类介绍

╰+攻爆jí腚メ 2022-12-16 03:56 235阅读 0赞

## 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：入口 ###

先看下`BeanNameUrlHandlerMapping`的uml图，如下:  
![在这里插入图片描述][20201018151626806.png_pic_center]  
注意最终实现了接口`org.springframework.context.ApplicationContextAware`，该接口定义如下：

public interface ApplicationContextAware extends Aware { 
    	void setApplicationContext(ApplicationContext applicationContext) throws BeansException;
    }

可以看到该接口实现了接口`org.springframewor.beans.factory.Aware`,因此值是一个`索取接口`，spring会调用`setApplicationContext(ac)`方法，该方法定义在`ApplicationSupprort`中，源码如下:

@Override
    	public final void setApplicationContext(@Nullable ApplicationContext context) throws BeansException { 
    		if (context == null && !isContextRequired()) { 
    			// Reset internal context state.
    			this.applicationContext = null;
    			this.messageSourceAccessor = null;
    		}
    		else if (this.applicationContext == null) { 
    			// Initialize with passed-in context.
    			if (!requiredContextClass().isInstance(context)) { 
    				throw new ApplicationContextException(
    						"Invalid application context: needs to be of type [" + requiredContextClass().getName() + "]");
    			}
    			this.applicationContext = context;
    			this.messageSourceAccessor = new MessageSourceAccessor(context);
    			initApplicationContext(context);
    		}
    		else { 
    			// Ignore reinitialization if same context passed in.
    			if (this.applicationContext != context) { 
    				throw new ApplicationContextException(
    						"Cannot reinitialize with different application context: current one is [" +
    						this.applicationContext + "], passed-in one is [" + context + "]");
    			}
    		}
    	}

最重要的是该方法会调用`initApplicationContext(context);`子类正式通过实现该方法从而加入到spring的初始化过程的，好的，现在看先`BeanNameUrlHandlerMapping`是否复写了该方法呢，其实没有，其实是在其父类`AbstractDetectingUrlHandlerMapping`，源码如下：

org.springframework.web.servlet.handler.AbstractDetectingUrlHandlerMapping#initApplicationContext
    @Override
    public void initApplicationContext() throws ApplicationContextException { 
    	super.initApplicationContext();
    	detectHandlers();
    }

好的，入口找到了，那就让我们开始吧！

### 2.2：AbstractDetectingUrlHandlerMapping\#initApplicationContext ###

源码：

@Override
    public void initApplicationContext() throws ApplicationContextException { 
    	// <1>
    	super.initApplicationContext();
    	// <2>
    	detectHandlers();
    }

`<1>`该处是通过调用`AbstractHandlerMapping`初始化HandlerInterceptor,详细参考[这里][Link 1]。`<2>`是用于获取handlers，详细继续向后看。

### 2.3：AbstractDetectingUrlHandlerMapping\#detectHandlers ###

源码：

protected void detectHandlers() throws BeansException { 
        // <1>
    	ApplicationContext applicationContext = obtainApplicationContext();
    	// <2>
    	String[] beanNames = (this.detectHandlersInAncestorContexts ?
    			BeanFactoryUtils.beanNamesForTypeIncludingAncestors(applicationContext, Object.class) :
    			applicationContext.getBeanNamesForType(Object.class));
    	// <3>
    	// Take any bean name that we can determine URLs for.
    	for (String beanName : beanNames) { 
    	    // <4>
    		String[] urls = determineUrlsForHandler(beanName);
    		// <5>
    		if (!ObjectUtils.isEmpty(urls)) { 
    			// URL paths found: Let's consider it a handler.
    			// <6>
    			registerHandler(urls, beanName);
    		}
    	}
    
    	if ((logger.isDebugEnabled() && !getHandlerMap().isEmpty()) || logger.isTraceEnabled()) { 
    		logger.debug("Detected " + getHandlerMap().size() + " mappings in " + formatMappingName());
    	}
    }

`<1>`处是获取IOC容器，这里获取的是[Root WebApplicationContext][]容器。`<2>`处是获取所有的bean名称。`<3>`处遍历所有的bean名称，`<4>`处获取名称以及别名是以`/`开头的名称，源码如下:

protected String[] determineUrlsForHandler(String beanName) { 
    	List<String> urls= new ArrayList<>();
    	// 如果是benaName是通过斜杠开头/的，则作为可对外暴露服务的url之一
    	if (beanName.startsWith("/")) { 
    		urls.add(beanName);
    	}
    	// 获取beanName所有的代称，如果是以/开头则也作为handlermapping中的url
    	// 代称alias中所有已斜杠/开头的名称也作为对外暴露服务的url备选项
    	String[] aliases = obtainApplicationContext().getAliases(beanName);
    	for (String alias : aliases) { 
    		if (alias.startsWith("/")) { 
    			urls.add(alias);
    		}
    	}
    	// 将List转换为String返回
    	return StringUtils.toStringArray(urls);
    }

`<5>`处如果是有数据则通过`<6>`处注册存储`url->handler`的对应关系，源码如下:

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);
    	}
    }

遍历调用重载方法，详细继续向下看。

### 2.4：AbstractUrlHandlerMapping\#registerHandler(java.lang.String, java.lang.Object) ###

源码：

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");
    	// <1>
    	Object resolvedHandler = handler;
    
    	// Eagerly resolve handler if referencing singleton via name.
    	// <2>
    	if (!this.lazyInitHandlers && handler instanceof String) { 
    		String handlerName = (String) handler;
    		ApplicationContext applicationContext = obtainApplicationContext();
    		if (applicationContext.isSingleton(handlerName)) { 
    			resolvedHandler = applicationContext.getBean(handlerName);
    		}
    	}
    	// <3>
    	Object mappedHandler = this.handlerMap.get(urlPath);
    	// <4>
    	if (mappedHandler != null) { 
    		if (mappedHandler != resolvedHandler) { 
    			throw new IllegalStateException(
    					"Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
    					"]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
    		}
    	}
    	else { 
    		// <5>
    		if (urlPath.equals("/")) { 
    			if (logger.isTraceEnabled()) { 
    				logger.trace("Root mapping to " + getHandlerDescription(handler));
    			}
    			setRootHandler(resolvedHandler);
    		}
    		// <6>
    		else if (urlPath.equals("/*")) { 
    			if (logger.isTraceEnabled()) { 
    				logger.trace("Default mapping to " + getHandlerDescription(handler));
    			}
    			setDefaultHandler(resolvedHandler);
    		}
    		else { 
    		    // <7>
    			this.handlerMap.put(urlPath, resolvedHandler);
    			if (logger.isTraceEnabled()) { 
    				logger.trace("Mapped [" + urlPath + "] onto " + getHandlerDescription(handler));
    			}
    		}
    	}
    }

`<1>`处变量存储的是对应的handler对象。`<2>`处如果是string类型则从容器中获取对应的对象，并赋值到resolvedHandler。`<3>`处获取老的handler，`<4>`处判断如果是老的和现在的不是同一个，则抛出`java.lang.IllegalStateException`，因为相同的url不能有不同的handler。`<5>`如果是路径是`/`则作为`rootHandler`，`<6>`处如果是`/*`则作为默认handler。`<7>`处存储url和hander的对应关系。

## 3：获取 ##

### 3.1：入口 ###

`org.springframework.web.servlet.DispatcherServlet#doDispatch`，该方法内的`mappedHandler = getHandler(processedRequest);`源码：

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;
    }

这里会遍历所有的HandlerMapping，因为我们这里调试的是`BeanNameUrlHandlerMapping`，所以可以在`HandlerExecutionChain handler = mapping.getHandler(request)`该行代码增加条件变量`mapping instanceof BeanNameUrlHandlerMapping`方便调试，如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70_pic_center]  
首先会调用`org.springframework.web.servlet.handler.AbstractHandlerMapping#getHandler`其内部代码`Object handler = getHandlerInternal(request);`调用模板方法`getHandlerInternal`完成handler的获取工作。

### 3.2：AbstractUrlHandlerMapping\#getHandlerInternal ###

源码：

protected Object getHandlerInternal(HttpServletRequest request) throws Exception { 
        // <1>
    	String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
    	// <2>
    	Object handler = lookupHandler(lookupPath, request);
    	// <3>
    	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 = obtainApplicationContext().getBean(handlerName);
    			}
    			validateHandler(rawHandler, request);
    			handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
    		}
    	}
    	return handler;
    }

`<1>`处获取请求路径，`<2>`处根据路径查询Handler，下面详细讲。`<3>`处如果是没有获取到handler则尝试通过根handler和默认handler获取。

### 3.3：AbstractUrlHandlerMapping\#lookupHandler ###

源码：

protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception { 
    	// Direct match?
    	// <1>
    	Object handler = this.handlerMap.get(urlPath);
    	// <2>
    	if (handler != null) { 
    		// Bean name or resolved handler?
    		if (handler instanceof String) { 
    			String handlerName = (String) handler;
    			handler = obtainApplicationContext().getBean(handlerName);
    		}
    		// <3>
    		validateHandler(handler, request);
    		// <4>
    		return buildPathExposingHandler(handler, urlPath, urlPath, null);
    	}
    
    	// Pattern match?
    	// <5>
    	List<String> matchingPatterns = new ArrayList<>();
    	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 bestMatch = null;
    	Comparator<String> patternComparator = getPathMatcher().getPatternComparator(urlPath);
    	if (!matchingPatterns.isEmpty()) { 
    		matchingPatterns.sort(patternComparator);
    		if (logger.isTraceEnabled() && matchingPatterns.size() > 1) { 
    			logger.trace("Matching patterns " + matchingPatterns);
    		}
    		bestMatch = matchingPatterns.get(0);
    	}
    	if (bestMatch != null) { 
    		handler = this.handlerMap.get(bestMatch);
    		if (handler == null) { 
    			if (bestMatch.endsWith("/")) { 
    				handler = this.handlerMap.get(bestMatch.substring(0, bestMatch.length() - 1));
    			}
    			if (handler == null) { 
    				throw new IllegalStateException(
    						"Could not find handler for best pattern match [" + bestMatch + "]");
    			}
    		}
    		// Bean name or resolved handler?
    		if (handler instanceof String) { 
    			String handlerName = (String) handler;
    			handler = obtainApplicationContext().getBean(handlerName);
    		}
    		validateHandler(handler, request);
    		String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestMatch, 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<>();
    		for (String matchingPattern : matchingPatterns) { 
    			if (patternComparator.compare(bestMatch, matchingPattern) == 0) { 
    				Map<String, String> vars = getPathMatcher().extractUriTemplateVariables(matchingPattern, urlPath);
    				Map<String, String> decodedVars = getUrlPathHelper().decodePathVariables(request, vars);
    				uriTemplateVariables.putAll(decodedVars);
    			}
    		}
    		if (logger.isTraceEnabled() && uriTemplateVariables.size() > 0) { 
    			logger.trace("URI variables " + uriTemplateVariables);
    		}
    		return buildPathExposingHandler(handler, bestMatch, pathWithinMapping, uriTemplateVariables);
    	}
    
    	// No handler found...
    	return null;
    }

`<1>`处直接获取handler，`<2>`如果handler不为空，则通过`<3>`进行相关的验证，`<4>`是设置系统提供的用于处理请参数等信息的拦截器。`<5>`处是无法唯一确定是，根据不同的优先级选择最优的一个handler。

## 最后：都让开，我要喝瑞幸 ##

![在这里插入图片描述][20200828090303329.png_pic_center]

[20201018151626806.png_pic_center]: /images/20221123/3b19b92fcefb404c892df17497199536.png
[Link 1]: https://blog.csdn.net/wang0907/article/details/108925784
[Root WebApplicationContext]: https://blog.csdn.net/wang0907/article/details/108472552
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/d4650d46581c45d0a762c3d3717b49b0.png
[20200828090303329.png_pic_center]: /images/20221123/86a22b99aeeb4d02aa473e4eeb6d6396.png