Spring5源码14-SpringMVC-HandlerMapping
站长
· 阅读数 18
欢迎大家关注 github.com/hsfxuebao ，希望对大家有所帮助，要是觉得可以的话麻烦给点一下Star哈
在 Spring MVC 的分析过程中，我们知道了 Spring mvc 默认会引入DispatcherServlet.properties 文件中的类(该文件和 DispatcherServlet 在同级目录) 的一些类。DispatcherServlet.properties 配置文件如下。
# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.
org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver
org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,\
org.springframework.web.servlet.function.support.RouterFunctionMapping
org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter,\
org.springframework.web.servlet.function.support.HandlerFunctionAdapter
org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver
org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator
org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager
下面我们来看看 HandlerMapping 不同实现类的区别。
1. HandlerMapping
从 DispatcherServlet.properties 文件中得知。HandlerMapping 默认引入三个类BeanNameUrlHandlerMapping、RequestMappingHandlerMapping、RouterFunctionMapping
org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,\
org.springframework.web.servlet.function.support.RouterFunctionMapping
我们来看看他们的区别：
-
BeanNameUrlHandlerMapping：以beanName 作为key值 -
RequestMappingHandlerMapping：完成@Controller和@RequestMapping的解析，并将解析保存。请求发送时与请求路径进行匹配对应找到合适的Handler。RequestMappingHandlerMapping实现了InitializingBean接口，会在afterPropertiesSet方法中。- 调用时机: 解析
@Controller和@RequestMapping注解是在afterPropertiesSet方法中进行的。匹配调用则是在DispatcherServlet doDispatch方法中的getHandler中调用了HandlerMapper中的getHandler中的getHandlerInternal方法。
- 调用时机: 解析
-
RouterFunctionMapping：RouterFunctionMapping是检索RouterFunction应用程序上下文中创建的所有bean 的类。
在 Spring mvc 加载 HandlerMapping 的代码分析中，我们知道，Spring 默认会加载 DispatcherServlet.properties 中的所有的 HandlerMapping。同时我们可以通过 DispatcherServlet.detectAllHandlerMappings 属性来控制是否加载所有的HandlerMapping，还是只加载唯一的HandlerMapping。
为了方便，先禁用寻找所有的HandlerMapping。
@Bean
public DispatcherServlet dispatcherServlet(){
DispatcherServlet dispatcherServlet = new DispatcherServlet();
// 设置false，则只寻找beanName 为 handlerMapping 的类，不加载所有HandlerMapping类
dispatcherServlet.setDetectAllHandlerMappings(false);
return dispatcherServlet;
}
1.1. BeanNameUrlHandlerMapping
BeanNameUrlHandlerMapping 顾名思义，就是根据beanName 来 进行映射。
我们创建一个Controller如下，这里有两点需要注意：
- 映射的Controller 需要实现
org.springframework.web.servlet.mvc.Controller接口。 - beanName 需要以
‘/’开头。
@org.springframework.stereotype.Controller("/helloSimple")
public class HelloSimpleController implements Controller {
@Override
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
return null;
}
}
这里解释分析一下为什么要 beanName 以 ‘/’ 开头?
- 我们来看
BeanNameUrlHandlerMapping的源码如下， 可以很清楚的看到这里有对/的判断。寻找到以/开头的beanName 并作为url返回。
public class BeanNameUrlHandlerMapping extends AbstractDetectingUrlHandlerMapping {
/**
* Checks name and aliases of the given bean for URLs, starting with "/".
*/
@Override
protected String[] determineUrlsForHandler(String beanName) {
List<String> urls = new ArrayList<>();
// 判断 beanName 是否是 / 开头
if (beanName.startsWith("/")) {
urls.add(beanName);
}
// 判断 beanName 的别名是否是 / 开头哦
String[] aliases = obtainApplicationContext().getAliases(beanName);
for (String alias : aliases) {
if (alias.startsWith("/")) {
urls.add(alias);
}
}
// 将是 / 的beanname 转化成数组并返回。
return StringUtils.toStringArray(urls);
}
}
返回之后，在AbstractDetectingUrlHandlerMapping#detectHandlers 方法中完成了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.
// 遍历所有的BeanName
for (String beanName : beanNames) {
// 获取到符合规则的Url
String[] urls = determineUrlsForHandler(beanName);
if (!ObjectUtils.isEmpty(urls)) {
// URL paths found: Let's consider it a handler.
// 注册成handler
registerHandler(urls, beanName);
}
}
...
}
我们来进一步看看Handler 注册的流程。注册流程其实很简单，其实就是利用AbstractUrlHandlerMapping#handlerMap 中保存了url 和 Handler。key为 urlPath，value为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;
// Eagerly resolve handler if referencing singleton via name.
// 如果不是懒加载 && handler 是 String类型。
if (!this.lazyInitHandlers && handler instanceof String) {
String handlerName = (String) handler;
ApplicationContext applicationContext = obtainApplicationContext();
// 如果是handler是单例，则从上下文中根据 beanName 获取handler 对象实例
if (applicationContext.isSingleton(handlerName)) {
resolvedHandler = applicationContext.getBean(handlerName);
}
}
// 判断 handlerMap 中已经保存了该 url
Object mappedHandler = this.handlerMap.get(urlPath);
if (mappedHandler != null) {
// 如果该url 对应的两个不同的 handler，则抛出异常
if (mappedHandler != resolvedHandler) {
throw new IllegalStateException(
"Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
"]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
}
}
else {
// 如果是 urlPath 是 / 开头。则设置为 根处理器
if (urlPath.equals("/")) {
if (logger.isTraceEnabled()) {
logger.trace("Root mapping to " + getHandlerDescription(handler));
}
setRootHandler(resolvedHandler);
}
// 如果是 urlPath 是 / 开头。则设置为 默认处理器
else if (urlPath.equals("/*")) {
if (logger.isTraceEnabled()) {
logger.trace("Default mapping to " + getHandlerDescription(handler));
}
setDefaultHandler(resolvedHandler);
}
else {
// 否则的话，保存到 handlerMap 中
this.handlerMap.put(urlPath, resolvedHandler);
if (logger.isTraceEnabled()) {
logger.trace("Mapped [" + urlPath + "] onto " + getHandlerDescription(handler));
}
}
}
}
1.2 RequestMappingHandlerMapping
RequestMappingHandlerMapping，即我们平常最常用的一种形式，通过 @ResquestMapping 注解的方式来执行路径，由于下面有关于RequestMappingHandlerMapping 注册流程的分析，这里就不再赘述 。
1.3 RouterFunctionMapping
RouterFunctionMapping没用过 。参看 www.leftso.com/blog/380.ht…
2. RequestMappingHandlerMapping
下面的解析以 RequestMappingHandlerMapping 为例，因为 RequestMappingHandlerMapping 也是我们最常使用的 HandlerMapping。
2.1 Handler的注册
我们首先来看一下 RequestMappingHandlerMapping 的结构图
我们看到其实现了其实 RequestMappingHandlerMapping 实现了 InitializingBean 接口(实际上是 AbstractHandlerMethodMapping 实现的。看了这么久的源码，我们可以大胆的猜测，对 Handler 的解析应该就在 InitializingBean#afterPropertiesSet 方法中。
我们来看一下 RequestMappingHandlerMapping#afterPropertiesSet 的实现如下。
@Override
@SuppressWarnings("deprecation")
public void afterPropertiesSet() {
// 进行 RequestMapping 的配置
this.config = new RequestMappingInfo.BuilderConfiguration();
this.config.setUrlPathHelper(getUrlPathHelper());
this.config.setPathMatcher(getPathMatcher());
this.config.setSuffixPatternMatch(useSuffixPatternMatch());
this.config.setTrailingSlashMatch(useTrailingSlashMatch());
this.config.setRegisteredSuffixPatternMatch(useRegisteredSuffixPatternMatch());
this.config.setContentNegotiationManager(getContentNegotiationManager());
// 调用父类的 afterPropertiesSet 方法。
super.afterPropertiesSet();
}
上面我们看到，其主要内容还是在父类的 afterPropertiesSet 方法中。因此下面我们来看AbstractHandlerMethodMapping#afterPropertiesSet:
private static final String SCOPED_TARGET_NAME_PREFIX = "scopedTarget.";
/**
* Detects handler methods at initialization.
* @see #initHandlerMethods
*/
@Override
public void afterPropertiesSet() {
initHandlerMethods();
}
/**
* Scan beans in the ApplicationContext, detect and register handler methods.
* @see #getCandidateBeanNames()
* @see #processCandidateBean
* @see #handlerMethodsInitialized
*/
protected void initHandlerMethods() {
// getCandidateBeanNames() : 从 Spring 容器中获取所有候选的beanName。
for (String beanName : getCandidateBeanNames()) {
// 如果beanName 不是以 SCOPED_TARGET_NAME_PREFIX 开头，则进行处理
if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
// 1. 初始 候选的beanName
processCandidateBean(beanName);
}
}
// 这里就是打印了一下log日志
handlerMethodsInitialized(getHandlerMethods());
}
我们根据 initHandlerMethods 的注释就可以知道 initHandlerMethods 的作用是扫描 ApplicationContext，检测并注册 Handler方法。我们可以看到其中的关键方法就是 processCandidateBean(处理候选的Bean。这里实际完成了对 HandlerMethod 的解析和注册)。
在processCandidateBean 方法中，完成了对 HandlerMethod 的解析和注册 。而processCandidateBean的具体实现在 AbstractHandlerMethodMapping#processCandidateBean中。
下面我们来看看具体实现
protected void processCandidateBean(String beanName) {
Class<?> beanType = null;
try {
// 获取beanType
beanType = obtainApplicationContext().getType(beanName);
}
catch (Throwable ex) {
...
}
// 如果 beanType != null && beanType 是 handler。在 RequestMappingHandlerMapping 中的判断是 bean被 @Controller 或者 @RequestMapping 注解修饰。则会进行bean的handler方法筛选
if (beanType != null && isHandler(beanType)) {
// 筛选出合适的 HandlerMethod 注册
detectHandlerMethods(beanName);
}
}
可以看到其逻辑并不复杂，我们有两个方法需要关注：
isHandler(beanType)： 判断当前bean是否满足 Handler 条件detectHandlerMethods(beanName)： 解析 handler 里面的方法并注册 下面我们来看一看逐一来看一看：
2.1.1 isHandler(beanType)
这个方法在 AbstractHandlerMethodMapping 并没有具体实现，是供子类实现，目的是判断当前 Bean是否是 Handler (满足Handler 的条件)。我们这里来看看 RequestMappingHandlerMapping 的实现。
// RequestMappingHandlerMapping 中 isHandler 的实现
@Override
protected boolean isHandler(Class<?> beanType) {
return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));
}
可以看到，在 RequestMappingHandlerMapping 中 这里判断当前的bean 是否可以作为handler 的条件是 ： bean被 @Controller 或者 @RequestMapping 注解修饰。则会进行bean的handler方法筛选。如果满足，则会通过 AbstractHandlerMethodMapping#detectHandlerMethods方法来进行下一步的筛选Handler的方法筛选。
2.1.2. detectHandlerMethods(beanName)
detectHandlerMethods 的作用是筛选出合适的 Handler Method 方法，并进行注册。接下来来看看 AbstractHandlerMethodMapping#detectHandlerMethods方法的具体实现。
// 检测 handler 方法并注册
protected void detectHandlerMethods(Object handler) {
// 获取 handlerType。这里传入的 handler如果是 String 就是 beanName，从上下文中获取type，否则就直接认为是 Handler
Class<?> handlerType = (handler instanceof String ?
obtainApplicationContext().getType((String) handler) : handler.getClass());
if (handlerType != null) {
// 返回给定类的用户定义类：通常只是给定的类，但对于CGLIB生成的子类，则返回原始类
Class<?> userType = ClassUtils.getUserClass(handlerType);
// 遍历当前bean的所有方法，筛选出合适的 handler 方法 以及 注解信息
// 这里需要注意的是 MethodIntrospector.selectMethods 底层将 getMappingForMethod 返回为null 的值给过滤掉了。
Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
(MethodIntrospector.MetadataLookup<T>) method -> {
try {
// 供子类实现
return getMappingForMethod(method, userType);
}
catch (Throwable ex) {
throw new IllegalStateException("Invalid mapping on handler class [" +
userType.getName() + "]: " + method, ex);
}
});
if (logger.isTraceEnabled()) {
logger.trace(formatMappings(userType, methods));
}
// 遍历所有的methods(这里的methods经过上面的筛选后，都是被 @RequestMapping 注解修饰的方法)
methods.forEach((method, mapping) -> {
// 这里是针对 cglib 代理特殊处理。
Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
//注册 HandlerMethod 。
registerHandlerMethod(handler, invocableMethod, mapping);
});
}
}
在上述代码中通过 MethodIntrospector#selectMethods(...) 方法遍历了当前bean的所有方法，并调用 getMappingForMethod 方法进行处理。getMappingForMethod 方法在 AbstractHandlerMethodMapping 中并未有具体实现，这里我们看看 RequestMappingHandlerMapping 中的实现。
// RequestMappingHandlerMapping 中的实现
@Override
@Nullable
protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
// 转换成 RequestMappingInfo ，如果方法没有被 @RequestMapping 注解修饰，则会返回null
// 解析出来方法上 @RequestMapping 注解的各种信息
RequestMappingInfo info = createRequestMappingInfo(method);
if (info != null) {
// 解析出来 bean 上 @RequestMapping 注解的各种信息
RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
if (typeInfo != null) {
// 合并类和方法的 @RequestMapping 注解信息
info = typeInfo.combine(info);
}
// 获取前缀，拼接前缀
String prefix = getPathPrefix(handlerType);
if (prefix != null) {
info = RequestMappingInfo.paths(prefix).options(this.config).build().combine(info);
}
}
// 返回信息
return info;
}
getMappingForMethod 方法的作用是解析 方法上的@RequestMapping注解的信息并和类上 @RequestMapping 注解 的信息相结合。
@Nullable
private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
// 获取当前方法上的 @RequestMapping 注解
RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(element, RequestMapping.class);
// 获取自定义的方法条件
RequestCondition<?> condition = (element instanceof Class ?
getCustomTypeCondition((Class<?>) element) : getCustomMethodCondition((Method) element));
// 这里可以看到 如果 requestMapping = null，则会直接返回null，否则会封装成一个 RequestMappingInfo (包含 @RequestMapping 注解的各种参数) 返回。
return (requestMapping != null ? createRequestMappingInfo(requestMapping, condition) : null);
}
2.1.3. registerHandlerMethod(handler, invocableMethod, mapping)
registerHandlerMethod(handler, invocableMethod, mapping); 看方法名字就知道 注册 HandlerMethod。下面我们看看具体实现
// RequestMappingHandlerMapping 中
@Override
public void registerMapping(RequestMappingInfo mapping, Object handler, Method method) {
super.registerMapping(mapping, handler, method);
updateConsumesCondition(mapping, method);
}
@Override
protected void registerHandlerMethod(Object handler, Method method, RequestMappingInfo mapping) {
super.registerHandlerMethod(handler, method, mapping);
updateConsumesCondition(mapping, method);
}
...
// 对 @RequestBody 注解进行了进一步解析
private void updateConsumesCondition(RequestMappingInfo info, Method method) {
ConsumesRequestCondition condition = info.getConsumesCondition();
if (!condition.isEmpty()) {
for (Parameter parameter : method.getParameters()) {
MergedAnnotation<RequestBody> annot = MergedAnnotations.from(parameter).get(RequestBody.class);
if (annot.isPresent()) {
condition.setBodyRequired(annot.getBoolean("required"));
break;
}
}
}
}
其中 super.registerMapping(mapping, handler, method); 调用的是 AbstractHandlerMethodMapping#registerMapping 。如下
// RequestMappingInfo 和 MappingRegistration 的映射关系
private final Map<T, MappingRegistration<T>> registry = new HashMap<>();
// key是 RequestMappingInfo, value 是 HandlerMethod
private final Map<T, HandlerMethod> mappingLookup = new LinkedHashMap<>();
// url 和 RequestMappingInfo 映射起来。
private final MultiValueMap<String, T> urlLookup = new LinkedMultiValueMap<>();
// 类名#方法名 和 HandlerMethod 的映射关系
private final Map<String, List<HandlerMethod>> nameLookup = new ConcurrentHashMap<>();
// HandlerMethod 和 CorsConfiguration 的映射关系
private final Map<HandlerMethod, CorsConfiguration> corsLookup = new ConcurrentHashMap<>();
private final MappingRegistry mappingRegistry = new MappingRegistry();
// super.registerMapping(mapping, handler, method); 调用的是 AbstractHandlerMethodMapping#registerMapping 。如下
public void registerMapping(T mapping, Object handler, Method method) {
if (logger.isTraceEnabled()) {
logger.trace("Register \"" + mapping + "\" to " + method.toGenericString());
}
// 完成了handler method 的注册
this.mappingRegistry.register(mapping, handler, method);
}
下面我们来看看 this.mappingRegistry.register(mapping, handler, method); 的具体实现 (AbstractHandlerMethodMapping.MappingRegistry#register) 如下
public void register(T mapping, Object handler, Method method) {
// Assert that the handler method is not a suspending one.
if (KotlinDetector.isKotlinType(method.getDeclaringClass())) {
Class<?>[] parameterTypes = method.getParameterTypes();
if ((parameterTypes.length > 0) && "kotlin.coroutines.Continuation".equals(parameterTypes[parameterTypes.length - 1].getName())) {
throw new IllegalStateException("Unsupported suspending handler method detected: " + method);
}
}
// 加写锁
this.readWriteLock.writeLock().lock();
try {
// 将 handler 和 method 封装成一个 HandlerMethod 实例
HandlerMethod handlerMethod = createHandlerMethod(handler, method);
// 校验实例的合法性。即唯一性
validateMethodMapping(handlerMethod, mapping);
// 保存映射关心， key是 RequestMappingInfo, value 是 HandlerMethod
this.mappingLookup.put(mapping, handlerMethod);
// 获取url映射，如果是 restful 请求则获取不到。建立 url 和Mapping 的映射。
// 一个mapping 可以对应多个url
List<String> directUrls = getDirectUrls(mapping);
// 这里将url 和 mapping映射起来
// 在进行匹配的时候，就是先根据url找到合适的mapping，然后根据找到的mapping再去找到HandlerMethod
for (String url : directUrls) {
this.urlLookup.add(url, mapping);
}
// 保存 类名#方法名 ： HandlerMethod 的映射关系
String name = null;
if (getNamingStrategy() != null) {
// 这里解析出来的name 并不是完整的类名，而是类名的首字母组合。比如方法名是 DemoController.say() ，解析出来的name即为 DC#say。如果是 SayController.say()。解析出来则为 name = SC#say
name = getNamingStrategy().getName(handlerMethod, mapping);
addMappingName(name, handlerMethod);
}
//@CrossOrigin跨域注解请求的初始化配置
CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
if (corsConfig != null) {
this.corsLookup.put(handlerMethod, corsConfig);
}
// 保存到 registry 中
this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
}
finally {
this.readWriteLock.writeLock().unlock();
}
}
2.1.4. 总结
经过上面的分析我们可以得知：
- Spring启动时加载
RequestMappingHandlerMapping。RequestMappingHandlerMapping在初始化的时候会从 Spring容器中获取bean - 遍历每个bean，判断是否满足成为
Handler的条件(bean被 @Controller 或者 @RequestMapping 注解修饰)。满足条件的作为 Handler进行下一步处理 - 通过反射获取每个 Handler 里面的方法，去判断是否被
@RequestMapping注解修饰，如果被修饰，则获取@RequestMapping注解的信息与类上面的@RequestMapping注解信息合并后注册HandlerMethod。
2.2 Handler 的筛选
当一个请求过来的的时候，会交由 DispatcherServlet 来进行请求分发。根据请求的 request 查找到对应的 handler。这里来分析一下这个查找过程。
DispatcherServlet 的查找方法是 DispatcherServlet#getHandler。如下
@Nullable
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
if (this.handlerMappings != null) {
// 这里的 HandlerMapping 如果没有特殊操作，则默认是从配置文件中读取并加载的 HandlerMapping
for (HandlerMapping mapping : this.handlerMappings) {
// 调用HandlerMapping 的getHandler 方法。
HandlerExecutionChain handler = mapping.getHandler(request);
if (handler != null) {
return handler;
}
}
}
return null;
}
mapping.getHandler(request); 调用的是 AbstractHandlerMapping#getHandler 方法。其实现如下:
@Override
@Nullable
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
// 1. 调用 getHandlerInternal 获取 handler 。该方法供子类实现
Object handler = getHandlerInternal(request);
// 如果没有获取到 handler。则获取默认的handler
if (handler == null) {
handler = getDefaultHandler();
}
if (handler == null) {
return null;
}
// Bean name or resolved handler?
// 如果 handler 是 String类型，则会认为是 beanName。从Spring容器中获取 bean实例
if (handler instanceof String) {
String handlerName = (String) handler;
handler = obtainApplicationContext().getBean(handlerName);
}
// 2. 生成拦截器链路
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) || CorsUtils.isPreFlightRequest(request)) {
CorsConfiguration config = (this.corsConfigurationSource != null ? this.corsConfigurationSource.getCorsConfiguration(request) : null);
CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
config = (config != null ? config.combine(handlerConfig) : handlerConfig);
executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
}
return executionChain;
}
2.2.1. getHandlerInternal(request)
该方法在 AbstractHandlerMethodMapping#getHandlerInternal 中没有具体实现，是供不同的 HandlerMapping 子类自己实现的。这里我们直接看 RequestMappingInfoHandlerMapping#getHandlerInternal
@Override
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
request.removeAttribute(PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);
try {
return super.getHandlerInternal(request);
}
finally {
ProducesRequestCondition.clearMediaTypesAttribute(request);
}
}
super.getHandlerInternal(request); 调用的是 AbstractHandlerMethodMapping#getHandlerInternal。如下
@Override
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
// 从 request 中解析出 请求路径
String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
request.setAttribute(LOOKUP_PATH, lookupPath);
this.mappingRegistry.acquireReadLock();
try {
// 查找 HandlerMethod
HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
}
finally {
this.mappingRegistry.releaseReadLock();
}
}
...
@Nullable
protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
List<Match> matches = new ArrayList<>();
// 通过 url 获取匹配路径
// springMVC会在初始化的时候建立URL和相应RequestMappingInfo的映射，这点在上面的解析中我们可以知道。如果不是restful接口，这里就可以直接获取到。
// 这里是通过 urlLookup 获取的 RequestMappingInfo
List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
if (directPathMatches != null) {
// 将匹配的 Mapping 保存到 matches 中。
addMatchingMappings(directPathMatches, matches, request);
}
// 如果上面没有获取到匹配的路径，则只能遍历所有的 mapping。
// 由于会遍历所有的 RequestMapping。所以性能会随着 RequestMapping数量的增加降低
if (matches.isEmpty()) {
// No choice but to go through all mappings...
addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);
}
// 如果 matches 不为空，则说明有匹配的 Mapping
if (!matches.isEmpty()) {
Match bestMatch = matches.get(0);
// 如果合适的 Mapping 不止一个，则筛选出最合适的
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)) {
return PREFLIGHT_AMBIGUOUS_MATCH;
}
Match secondBestMatch = matches.get(1);
if (comparator.compare(bestMatch, secondBestMatch) == 0) {
Method m1 = bestMatch.handlerMethod.getMethod();
Method m2 = secondBestMatch.handlerMethod.getMethod();
String uri = request.getRequestURI();
throw new IllegalStateException(
"Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}");
}
}
request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.handlerMethod);
handleMatch(bestMatch.mapping, lookupPath, request);
return bestMatch.handlerMethod;
}
else {
return handleNoMatch(this.mappingRegistry.getMappings().keySet(), lookupPath, request);
}
}
...
private void addMatchingMappings(Collection<T> mappings, List<Match> matches, HttpServletRequest request) {
for (T mapping : mappings) {
T match = getMatchingMapping(mapping, request);
if (match != null) {
matches.add(new Match(match, this.mappingRegistry.getMappings().get(mapping)));
}
}
}
...
// this.mappingRegistry.getMappingsByUrl(lookupPath);
// 也就是 AbstractHandlerMethodMapping.MappingRegistry#getMappingsByUrl
@Nullable
public List<T> getMappingsByUrl(String urlPath) {
return this.urlLookup.get(urlPath);
}
2.2.2 getHandlerExecutionChain(handler, request)
AbstractHandlerMapping#getHandlerExecutionChain。主要目的是将配置中对应的拦截器加入到执行链中，以保证这些拦截器可以有效的作用于目标对象
protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
// 构建一个执行链
HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
(HandlerExecutionChain) handler : new HandlerExecutionChain(handler));
// 解析出来 请求路径
String lookupPath = this.urlPathHelper.getLookupPathForRequest(request, LOOKUP_PATH);
// 遍历所有的拦截器，如果拦截器匹配符则加入到执行链中。adaptedInterceptors 是在 Mapping 初始化的时候加载的
for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
if (interceptor instanceof MappedInterceptor) {
MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
chain.addInterceptor(mappedInterceptor.getInterceptor());
}
}
else {
chain.addInterceptor(interceptor);
}
}
return chain;
}
关于 adaptedInterceptors、interceptors 两个拦截器集合：adaptedInterceptors 是 AbstractHandlerMapping 在初始化的时候实现了 ApplicationContextAware 接口，在 ApplicationObjectSupport#setApplicationContext 方法中调用 initApplicationContext 方法，进行了 adaptedInterceptors 的初始化。而 interceptors 则可以通过 set 方法进行注入。
// AbstractHandlerMapping
@Override
protected void initApplicationContext() throws BeansException {
extendInterceptors(this.interceptors);
detectMappedInterceptors(this.adaptedInterceptors);
initInterceptors();
}
...
// 从容器中 获取所有MappedInterceptor类型的拦截器
protected void detectMappedInterceptors(List<HandlerInterceptor> mappedInterceptors) {
mappedInterceptors.addAll(BeanFactoryUtils.beansOfTypeIncludingAncestors(
obtainApplicationContext(), MappedInterceptor.class, true, false).values());
}
2.2.3 总结
总结部分:
-
List directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);这个方法是非常直观的根据URL来获取,springMVC会在初始化的时候建立URL和相应RequestMappingInfo的映射。如果不是restful接口，这里就可以直接获取到了。 -
如果1中已经获取到，则调用方法
addMatchingMappings(directPathMatches, matches, request)进行匹配校验。 -
如果1中未获取到匹配方法信息，则调用方法
addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);进行全局（all mappings）扫描匹配(this.mappingRegistry.getMappings().keySet())。且会把所有的RequestMappingInfo都遍历完才会停止，也就是说项目中的@RequestMapping方法越多，这个匹配的效率就越低，性能越差。 -
在遍历过程中，SpringMVC首先会根据@RequestMapping中的headers, params, produces, consumes, methods与实际的HttpServletRequest中的信息对比，剔除掉一些明显不合格的RequestMapping。 如果以上信息都能够匹配上，那么SpringMVC会对RequestMapping中的path进行正则匹配，剔除不合格的。接下来会对所有留下来的候选@RequestMapping进行评分并排序。最后选择分数最高的那个作为结果。
评分的优先级为：path pattern > params > headers > consumes > produces > methods
参考文章
Spring5源码注释github地址 Spring源码深度解析（第2版） spring源码解析 Spring源码深度解析笔记 Spring注解与源码分析 Spring注解驱动开发B站教程
转载自:https://juejin.cn/post/7140236556769427487