详解SpringMVC组件之HandlerMapping(一)
作者：姠惢荇者
1、HandlerMapping简介
HandlerMapping组件是Spring MVC核心组件，用来根据请求的request查找对应的Handler。
在Spring MVC中，有各式各样的Web请求，每个请求都需要一个对应的Handler来处理，具体接收到一个request请求，应该有那个Handler处理呢？这就是HandlerMapping组件的作用。
在Spring MVC框架中，HandlerMapping组件及其实现类的如下所示：
在HandlerMapping类的层级结构图中，MatchableHandlerMapping接口是一个从Spring4.3.1开始新增的一个接口，用来判断给定的请求是否符合请求条件。
除此之外，HandlerMapping接口有一个公共的抽象类AbstractHandlerMapping，所有子孙实现类都需要继承。
该抽象类下有三个直接子类，分别是AbstractHandlerMethodMapping、AbstractUrlHandlerMapping和RouterFunctionMapping
其中RouterFunctionMapping是从Spring MVC5.2开始引入的，主要用于WebFlux处理中；
而另外两个直接实现类，代表了两大类实现方式：
- AbstractUrlHandlerMapping表示根据url获取对应的handler；
- AbstractHandlerMethodMapping表示基于方法的映射方式，这也是我们在实际工作中使用较多的一种方式。
2、AbstractHandlerMapping抽象类
AbstractHandlerMapping是HandlerMapping的抽象类，所有子类都是继承于该抽象类。该抽象类采用了模板方法，定义了HandlerMapping的核心逻辑。
在抽象类AbstractHandlerMapping中，通过继承WebApplicationObjectSupport类（间接实现了ApplicationContextAware接口），实现了拦截器相关信息的初始化，然后实现了接口中的getHandler()方法，通过调用抽象方法getHandlerInternal()获取Handler，然后把Handler封装成HandlerExecutionChain对象（该对象包括了拦截器信息和跨域访问相关信息），并进行返回。
拦截器初始化：
首先分析，AbstractHandlerMapping抽象类如何初始化拦截器的。因为AbstractHandlerMapping抽象类间接继承了ApplicationContextAware接口，所以容器初始化是会自动调用setApplicationContext()方法，该setApplicationContext()方法经过ApplicationObjectSupport、WebApplicationObjectSupport层级，最终调用了AbstractHandlerMapping抽象类的initApplicationContext()方法，拦截器的初始化工作就是在这个方法中实现的，代码如下：
@Override
protected void initApplicationContext() throws BeansException {
extendInterceptors(this.interceptors);
detectMappedInterceptors(this.adaptedInterceptors);
initInterceptors();
}其中，extendInterceptors()方法是模板方法，供子类重写，提供添加或修改拦截器的入口；detectMappedInterceptors()方法，用于将容器（包括父级容器）中所有注册的MappedInterceptor类型的Bean添加到adaptedInterceptors属性中；initInterceptors()方法用于初始化拦截器。
detectMappedInterceptors()方法 通过BeanFactoryUtils.beansOfTypeIncludingAncestors()方法查询所有的MappedInterceptor类型的实例，并添加到adaptedInterceptors属性中。
protected void detectMappedInterceptors(List<HandlerInterceptor> mappedInterceptors) {
mappedInterceptors.addAll(
BeanFactoryUtils.beansOfTypeIncludingAncestors(
obtainApplicationContext(), MappedInterceptor.class, true, false).values());
}initInterceptors()方法 在初始化方法中，主要实现了把interceptors属性中的拦截器根据拦截器类型，进行适配，然后放到adaptedInterceptors变量中。
在Spring4.2之前的版本，有一个变量mappedInterceptors ，所以MappedInterceptor类型的拦截器会放到该变量中，但是再Spring4.2及之后的版本，该变量被移除，所以interceptors属性中的MappedInterceptor类型（HandlerInterceptor的子类）的实例，进行适配时按照HandlerInterceptor类型进行，并统一保存到了adaptedInterceptors变量，不再进行区分。
protected void initInterceptors() {
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));
}
}
}
protected HandlerInterceptor adaptInterceptor(Object interceptor) {
if (interceptor instanceof HandlerInterceptor) {
return (HandlerInterceptor) interceptor;
}
else if (interceptor instanceof WebRequestInterceptor) {
return new WebRequestHandlerInterceptorAdapter((WebRequestInterceptor) interceptor);
}
else {
throw new IllegalArgumentException("Interceptor type not supported: " + interceptor.getClass().getName());
}
}getHandler()方法实现
在HandlerMapping接口中，通过getHandler()方法获取request对应的处理器Handler和拦截器Interceptor的，在AbstractHandlerMapping抽象类的实现如下：
@Override
@Nullable
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
//调用模板方法，获取request对应的处理器Handler
Object handler = getHandlerInternal(request);
if (handler == null) {//如果handler为空，获取默认的handler
handler = getDefaultHandler();
}
if (handler == null) {
return null;
}
// 如果handler是实例的名称，需要从容器中获取对应的Bean实例
if (handler instanceof String) {
String handlerName = (String) handler;
handler = obtainApplicationContext().getBean(handlerName);
}
//根据Handler获取对应的executionChain对象，该过程会把对应的拦截器添加到executionChain对象中
HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
if (logger.isTraceEnabled()) {
logger.trace("Mapped to " + handler);
}
else if (logger.isDebugEnabled() && !request.getDispatcherType().equals(DispatcherType.ASYNC)) {
logger.debug("Mapped to " + executionChain.getHandler());
}
//处理跨域问题
if (hasCorsConfigurationSource(handler)) {
//初始化时如果有跨域配置，则获取config 对象
CorsConfiguration config = (this.corsConfigurationSource != null ? this.corsConfigurationSource.getCorsConfiguration(request) : null);
//如果当前handler中有跨域配置，获取handlerConfig对象
CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
//合并配置
config = (config != null ? config.combine(handlerConfig) : handlerConfig);
//把跨域处理的拦截器，添加到HandlerExecutionChain对象中
executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
}
return executionChain;
}在getHandler()方法中，主要做了以下几件事：
- 调用模板方法getHandlerInternal()，获取request对应的handler。模板方法由子类实现。
- 当获取的handler为空时，获取默认的handler，即获取对应的defaultHandler属性
- 判断handler是否时Bean的名称，如果是，获取对应的Bean实例
- 获取对应的HandlerExecutionChain对象，封装了初始化时的拦截器
- 处理跨域问题，处理跨域问题涉及到了内部类PreFlightHandler、CorsInterceptor和属性CorsProcessor对应的实现类，这里暂不深入分析。
3、AbstractUrlHandlerMapping类
AbstractUrlHandlerMapping系列的类都继承自AbstractUrlHandlerMapping抽象类，主要用来通过URL进行匹配。思路如下：把URL与Handler的对应关系存到一个Map中，然后在getHandlerInternal方法中，根据URL去获取对应的Handler对象，在AbstractUrlHandlerMapping抽象类中，主要实现了根据url获取对应Handler的方法，如何初始化这个Map对象，交由子类进行实现。
3.1、定义的属性
//根处理器，处理“/”的处理器 @Nullable private Object rootHandler; //是否匹配尾部的“/”，比如：如果设置为ture,则"/users"的匹配模式，也会匹配"/users/" private boolean useTrailingSlashMatch = false; //设置是否延迟加载，只对单例的处理器有效 private boolean lazyInitHandlers = false; //保存request和Handler对应关系的变量 private final Map<String, Object> handlerMap = new LinkedHashMap<>();
3.2、getHandlerInternal()方法
实现了父类中的抽象方法，根据request获取对应的handler，实际上还有由定义的lookupHandler()方法实现。如果没有获取对应的handler，就会尝试获取根处理器或默认处理器。
@Override
@Nullable
protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
//获取lookupPath，并保存到request属性中
String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
request.setAttribute(LOOKUP_PATH, lookupPath);
//获取lookupPath 对应的handler
Object handler = lookupHandler(lookupPath, request);
if (handler == null) {//如果没有获取到对应的handler，则进行下面处理
// 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)) {//如果时根路径，则获取根处理器，即属性rootHandler中保存的处理器
rawHandler = getRootHandler();
}
if (rawHandler == null) {//获取默认处理器，在父类中定义，即父类中的defaultHandler属性
rawHandler = getDefaultHandler();
}
if (rawHandler != null) {
// Bean name or resolved handler?
if (rawHandler instanceof String) {//获取对应的Bean实例
String handlerName = (String) rawHandler;
rawHandler = obtainApplicationContext().getBean(handlerName);
}
//模板方法，校验处理器，交由子类实现或扩展
validateHandler(rawHandler, request);
//根据原始的handler构建实际的handler，主要实现构建HandlerExecutionChain对象，并在request添加对应的参数，后续在详细分析
handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
}
}
return handler;
}在代码上，添加了注释，不再分析处理逻辑，我们下面详细分析其中的lookupHandler()方法和buildPathExposingHandler()方法。
3.2.1、lookupHandler()方法
因为从Map对象获取对应的Handler，不是简单的Map.get()，因为还涉及到了正则匹配等问题，所以在专门的方法中进行处理，在该方法中，主要实现了根据lookupPath获取对应的handler，然后处理当获取多个匹配handler后，如何获取最佳匹配的Handler等。
代码如下：
@Nullable
protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
// urlPath正好对应Map的key，则直接获取，并进行处理
Object handler = this.handlerMap.get(urlPath);
if (handler != null) {
// Bean name or resolved handler?
if (handler instanceof String) {
String handlerName = (String) handler;
handler = obtainApplicationContext().getBean(handlerName);
}
validateHandler(handler, request);
return buildPathExposingHandler(handler, urlPath, urlPath, null);
}
// 模式匹配，获取handlerMap中对应的所有可能匹配的模式
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;
//定义最佳匹配的比较器，为了获取最佳的处理器Handler
Comparator<String> patternComparator = getPathMatcher().getPatternComparator(urlPath);
if (!matchingPatterns.isEmpty()) {
//根据比较器进行排序，最佳handler排在第一个
matchingPatterns.sort(patternComparator);
if (logger.isTraceEnabled() && matchingPatterns.size() > 1) {
logger.trace("Matching patterns " + matchingPatterns);
}
//获取最佳的handler
bestMatch = matchingPatterns.get(0);
}
if (bestMatch != null) {//获取最佳处理器对应的key，然后进一步处理Handler
//获取key对应的Handler
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) {//如果时bean的名称，则获取对应的实例
String handlerName = (String) handler;
handler = obtainApplicationContext().getBean(handlerName);
}
validateHandler(handler, request);
String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestMatch, urlPath);
//最佳匹配可能存在多个，比如：/book/{id}和/book/{name}，那就再添加一个UriTemplateVariablesHandlerInterceptor拦截器，并在request设置一个key为 org.springframework.web.servlet.HandlerMapping.uriTemplateVariables的变量。
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;
}3.2.2、buildPathExposingHandler()方法
在Map对象中映射的是真正的handler对象，在buildPathExposingHandler()方法中，实现了把rawHandler封装成HandlerExecutionChain对象，然后添加内部拦截器类PathExposingHandlerInterceptor和UriTemplateVariablesHandlerInterceptor。
protected Object buildPathExposingHandler(Object rawHandler, String bestMatchingPattern,
String pathWithinMapping, @Nullable 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;
}其中，PathExposingHandlerInterceptor拦截器主要设置了request中的 “xxx.bestMatchingHandler”、".introspectTypeLevelMapping"（一直为false）、.bestMatchingPattern"和".pathWithinHandlerMapping"属性，UriTemplateVariablesHandlerInterceptor拦截器，主要是当uriTemplateVariables不为空时设置，主要添加了"xxx.uriTemplateVariables"属性，值就是变量uriTemplateVariables。其中，xxx表示HandlerMapping.class.getName()，即为“org.springframework.web.servlet.HandlerMapping”。
3.3、handlerMap的初始化
在AbstractUrlHandlerMapping抽象类中，handlerMap（request和handler映射关系）的初始化主要由registerHandler()方法来实现的。而registerHandler()方法，一般在子类中进行调用，从而实现不同的子类就可以通过注册不同的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);
}
}
//第二个方法：真正实现处理器的注册
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;
// 加载处理器（当处理器是非延时加载时进行）
if (!this.lazyInitHandlers && handler instanceof String) {
String handlerName = (String) handler;
ApplicationContext applicationContext = obtainApplicationContext();
if (applicationContext.isSingleton(handlerName)) {
resolvedHandler = applicationContext.getBean(handlerName);
}
}
Object mappedHandler = this.handlerMap.get(urlPath);
if (mappedHandler != null) {//如果Map中存在处理器，且和当前的不一样，就直接抛出异常。
if (mappedHandler != resolvedHandler) {
throw new IllegalStateException(
"Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
"]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
}
}
else {//当前Map不存在处理器
if (urlPath.equals("/")) {//设置根处理器
if (logger.isTraceEnabled()) {
logger.trace("Root mapping to " + getHandlerDescription(handler));
}
setRootHandler(resolvedHandler);
}
else if (urlPath.equals("/*")) {//设置默认处理器
if (logger.isTraceEnabled()) {
logger.trace("Default mapping to " + getHandlerDescription(handler));
}
setDefaultHandler(resolvedHandler);
}
else {//在Map中添加urlPath和处理器对应的关系
this.handlerMap.put(urlPath, resolvedHandler);
if (logger.isTraceEnabled()) {
logger.trace("Mapped [" + urlPath + "] onto " + getHandlerDescription(handler));
}
}
}
}4、BeanNameUrlHandlerMapping类
4.1、使用方法
1、定义一个Controller
public class TestController implements Controller {
@Override
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) {
ModelAndView mav = new ModelAndView("test");
mav.addObject("context", “test”);
return mav;
}
}2、TestController 注入到Spring容器
@Configuration
public class ControllerBeanConfig {
/**
* 注意 :
* 1. 该 bean 实现了接口 org.springframework.web.servlet.mvc.Controller,
* 2. 该 bean 没有使用注解 @Controller,
* (如果使用了注解@Controller,就会被RequestMappingHandlerMapping接管，而不是由BeanNameUrlHandlerMapping处理)
* 3. 映射到匹配 /test/* 的url
* @return
*/
@Bean(name = "/test/*")
public TestController beanTestController() {
return new TestController();
}
}通过上述配置，在初始化时，会采用BeanNameUrlHandlerMapping类，进行获取request对应de 处理器。在这个过程中，BeanNameUrlHandlerMapping类是如何产生作用的呢？下面我们详细的分析。
4.2、AbstractDetectingUrlHandlerMapping、BeanNameUrlHandlerMapping原理
BeanNameUrlHandlerMapping类继承了抽象类AbstractDetectingUrlHandlerMapping，然后又继承了AbstractUrlHandlerMapping抽象类，AbstractUrlHandlerMapping抽象类在前面已经分析过了。在前面介绍抽象类AbstractUrlHandlerMapping的时候，我们知道会在spring初始化的时候，执行initApplicationContext()方法，我们阅读AbstractDetectingUrlHandlerMapping类的代码时，发现它又重写了initApplicationContext()方法，所以在spring初始化的时候，会执行该方法。代码如下：
@Override
public void initApplicationContext() throws ApplicationContextException {
super.initApplicationContext();
detectHandlers();
}其中，super.initApplicationContext()方法调用了父类中的方法，前面已经介绍过了。同时，又调用了detectHandlers()方法，该方法主要实现了检测容器中注册的所有的handler。根据detectHandlersInAncestorContexts参数的配置，可以检查当前容器或者当前容器及其祖先容器中注册的handler。代码如下：
protected void detectHandlers() throws BeansException {
ApplicationContext applicationContext = obtainApplicationContext();
String[] beanNames = (this.detectHandlersInAncestorContexts ?
BeanFactoryUtils.beanNamesForTypeIncludingAncestors(applicationContext, Object.class) :
applicationContext.getBeanNamesForType(Object.class));
// Take any bean name that we can determine URLs for.
for (String beanName : beanNames) {
String[] urls = determineUrlsForHandler(beanName);
if (!ObjectUtils.isEmpty(urls)) {
// URL paths found: Let's consider it a handler.
registerHandler(urls, beanName);
}
}
if ((logger.isDebugEnabled() && !getHandlerMap().isEmpty()) || logger.isTraceEnabled()) {
logger.debug("Detected " + getHandlerMap().size() + " mappings in " + formatMappingName());
}
}在detectHandlers()方法中，通过处理器实例，可以获取对应的url，该逻辑由determineUrlsForHandler()方法实现，该方法由子类BeanNameUrlHandlerMapping中实现。然后再把urls和对应的handler通过父类AbstractUrlHandlerMapping中的registerHandler()方法，注册到Map对象中。
最后，determineUrlsForHandler()方法的实现，这里主要通过判断对应实例的name或aliases 来判断，只有以“/”开头的才是有效的url，代码如下：
public class BeanNameUrlHandlerMapping extends AbstractDetectingUrlHandlerMapping {
@Override
protected String[] determineUrlsForHandler(String beanName) {
List<String> urls = new ArrayList<>();
if (beanName.startsWith("/")) {
urls.add(beanName);
}
String[] aliases = obtainApplicationContext().getAliases(beanName);
for (String alias : aliases) {
if (alias.startsWith("/")) {
urls.add(alias);
}
}
return StringUtils.toStringArray(urls);
}
}通过上面的分析，我们知道：在initApplicationContext()方法中实现初始化工作，其中AbstractDetectingUrlHandlerMapping类主要实现了处理器的检测，BeanNameUrlHandlerMapping类实现handler对应url的判断。
5、其他
通过前面的分析，我们知道HandlerMapping有两个分支的实现，在这篇中我们已经分析了AbstractUrlHandlerMapping系列的实现
由于篇幅原因，AbstractHandlerMethodMapping系列的分析，我们在《详解SpringMVC组件之HandlerMapping(二)》中进行。
到此这篇关于详解SpringMVC组件之HandlerMapping(一)的文章就介绍到这了,更多相关SpringMVC的HandlerMapping内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！