简介
基于上篇请求路径初步探索，了解到了一个请求到具体处理方法的大致路径，本篇就继续探索，看下路径是如何匹配到处理方法的
概览
基于上篇：Spring Web 请求初探
我们大致定位到了请求路径到处理方法的关键代码在类中：DispatcherServlet.java
具体的代码如下：
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
复制代码
mappedHandler 的获取就是关键了，下面我们就具体看下如何获取请求的 mappedHandler 的
源码解析
获取 mappedHandler
在类：DispatcherServlet.java 中，我们定位到 mappedHandler 获取的关键代码
// Determine handler for the current request.mappedHandler = getHandler(processedRequest);if (mappedHandler == null) { noHandlerFound(processedRequest, response); return;}
复制代码
通过上面的代码，我们可以看到是通过请求进行获取，我们还注意到了为 null 的情况，如下代码，大意就是经典的 404
/*** No handler found -> set appropriate HTTP response status.* @param request current HTTP request* @param response current HTTP response* @throws Exception if preparing the response failed*/protected void noHandlerFound(HttpServletRequest request, HttpServletResponse response) throws Exception { if (pageNotFoundLogger.isWarnEnabled()) { pageNotFoundLogger.warn("No mapping for " + request.getMethod() + " " + getRequestUri(request)); } if (this.throwExceptionIfNoHandlerFound) { throw new NoHandlerFoundException(request.getMethod(), getRequestUri(request), new ServletServerHttpRequest(request).getHeaders()); } else { response.sendError(HttpServletResponse.SC_NOT_FOUND); }}
复制代码
我们进入 getHandler 函数，看看其具体处理逻辑，代码如下：
/*** Return the HandlerExecutionChain for this request.* <p>Tries all handler mappings in order.* @param request current HTTP request* @return the HandlerExecutionChain, or {@code null} if no handler could be found*/@Nullableprotected 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;}
复制代码
从上面代码大意可以看出：循环遍历一个关于请求匹配的 Map，如果某个 Handler 匹配成功则返回
这个 Map 是如何初始化、具体包含哪些内容？
HandlerExecutionChain 具体是什么？
这部分疑问后面再看，感觉是个大工程，当前并不影响本篇的解析
请求与 Mapper 匹配
接着跟下去，到类：AbstractHandlerMethodMapping.java
我们来到了一个比较关键的处理，我们可以看到这里有相关的匹配逻辑，里面有很多的处理，有些目前都不知道有啥作用，后面查查资料后咱们再回过头来看看
@Override @Nullable public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception { Object handler = getHandlerInternal(request);
// 什么情况下会匹配到默认的Handler？ if (handler == null) { handler = getDefaultHandler(); } if (handler == null) { return null; }
// 什么情况下获取到的Bean是一个String？ // 需要从 obtainApplicationContext 中获取 // Bean name or resolved handler? if (handler instanceof String) { String handlerName = (String) handler; handler = obtainApplicationContext().getBean(handlerName); }
// 什么情况下会用到缓存？ // Ensure presence of cached lookupPath for interceptors and others if (!ServletRequestPathUtils.hasCachedPath(request)) { initLookupPath(request); }
HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
if (logger.isTraceEnabled()) { logger.trace("Mapped to " + handler); } else if (logger.isDebugEnabled() && !DispatcherType.ASYNC.equals(request.getDispatcherType())) { logger.debug("Mapped to " + executionChain.getHandler()); }
if (hasCorsConfigurationSource(handler) || CorsUtils.isPreFlightRequest(request)) { CorsConfiguration config = getCorsConfiguration(handler, request); if (getCorsConfigurationSource() != null) { CorsConfiguration globalConfig = getCorsConfigurationSource().getCorsConfiguration(request); config = (globalConfig != null ? globalConfig.combine(config) : config); } if (config != null) { config.validateAllowCredentials(); } executionChain = getCorsHandlerExecutionChain(request, executionChain, config); }
return executionChain; }
复制代码
其中的 getHandlerExecutionChain 还挺可疑，感觉也是关键代码，给设置了一堆的我们熟悉的 Interceptors,这里做个标记，后面再探索下
protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) { HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ? (HandlerExecutionChain) handler : new HandlerExecutionChain(handler));
for (HandlerInterceptor interceptor : this.adaptedInterceptors) { if (interceptor instanceof MappedInterceptor) { MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor; if (mappedInterceptor.matches(request)) { chain.addInterceptor(mappedInterceptor.getInterceptor()); } } else { chain.addInterceptor(interceptor); } } return chain; }
复制代码
Handler 匹配
下面就跟着断点来到了：AbstractHandlerMapping.java
看到下面的关键代码：在查找匹配的时候上了一个锁，进入具体的查找逻辑
@Override@Nullableprotected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception { // 这里一些处理得到我们的请求路径：”/" String lookupPath = initLookupPath(request); this.mappingRegistry.acquireReadLock(); try { HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request); return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null); } finally { this.mappingRegistry.releaseReadLock(); }}
复制代码
我们进入类：AbstractHandlerMethodMapping.java 中，查看具体的处理逻辑
我们可以看到这里进行了一系列的匹配，如果为空还能取默认值，这个默认值是个啥？
并且还有多个匹配上的还不会报错的情况，瞬间感觉 Web 这块还是有很多门道啊，但这些细节后面我们再看看，继续看下匹配的逻辑
@Nullable protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception { List<Match> matches = new ArrayList<>(); // 在这里获取到了相关的Handler，就是一个简单的Map取值（如后面的代码），那个Map如何初始化的得后面看看了 List<T> directPathMatches = this.mappingRegistry.getMappingsByDirectPath(lookupPath); if (directPathMatches != null) { addMatchingMappings(directPathMatches, matches, request); }
// 如果没有匹配上，这个默认值又是如何处理的呢？ if (matches.isEmpty()) { addMatchingMappings(this.mappingRegistry.getRegistrations().keySet(), matches, request); }
// 这里看到一些非常有趣的处理 // 如果同时匹配上了两个，好像不是一定报错？ if (!matches.isEmpty()) { Match bestMatch = matches.get(0); if (matches.size() > 1) { Comparator<Match> comparator = new MatchComparator(getMappingComparator(request)); matches.sort(comparator); bestMatch = matches.get(0); if (logger.isTraceEnabled()) { logger.trace(matches.size() + " matching mappings: " + matches); } // 这个的返回是什么意思？ if (CorsUtils.isPreFlightRequest(request)) { for (Match match : matches) { if (match.hasCorsConfig()) { return PREFLIGHT_AMBIGUOUS_MATCH; } } } else { Match secondBestMatch = matches.get(1); if (comparator.compare(bestMatch, secondBestMatch) == 0) { Method m1 = bestMatch.getHandlerMethod().getMethod(); Method m2 = secondBestMatch.getHandlerMethod().getMethod(); String uri = request.getRequestURI(); throw new IllegalStateException( "Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}"); } } } request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.getHandlerMethod()); handleMatch(bestMatch.mapping, lookupPath, request); return bestMatch.getHandlerMethod(); } else { return handleNoMatch(this.mappingRegistry.getRegistrations().keySet(), lookupPath, request); } }
复制代码
一个简单的 Map 取值（如后面的代码），那个 Map 如何初始化的得后面看看了
class MappingRegistry {
private final MultiValueMap<String, T> pathLookup = new LinkedMultiValueMap<>();
@Nullable public List<T> getMappingsByDirectPath(String urlPath) { return this.pathLookup.get(urlPath); }}
复制代码
到这里就匹配成功并返回了，但通过调试看到不是我们熟悉的类和方法
继续看看这行的具体处理逻辑：return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
看看类 HandlerMethod 的一些方法和构造函数：
下面函数我们看到了属性的获取 Bean
public HandlerMethod createWithResolvedBean() { Object handler = this.bean; if (this.bean instanceof String) { Assert.state(this.beanFactory != null, "Cannot resolve bean name without BeanFactory"); String beanName = (String) this.bean; handler = this.beanFactory.getBean(beanName); } return new HandlerMethod(this, handler); }
复制代码
在其构造函数中，直接将 Bean 和 Method 进行了初始化，这个如何初始化的我们后面再看
public HandlerMethod(Object bean, Method method) { Assert.notNull(bean, "Bean is required"); Assert.notNull(method, "Method is required"); this.bean = bean; this.beanFactory = null; this.beanType = ClassUtils.getUserClass(bean); this.method = method; this.bridgedMethod = BridgeMethodResolver.findBridgedMethod(method); this.parameters = initMethodParameters(); evaluateResponseStatus(); this.description = initDescription(this.beanType, this.method); }
复制代码
总结
本篇文章探索了下具体的请求如何匹配到处理方法的相关处理函数,了解到了核心逻辑就是遍历一个： handlerMappings
@Nullableprotected 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;}
复制代码
后面的具体匹配逻辑也有很多值得探索的细节，但接下来更重要的是弄清楚这个: handlerMappings ,是如何初始化和加载的
下面的文章我们会继续探索
评论