Spring MVC为何能准确的找到一个http请求对应controller的某个方法进行处理
问题已抛出，如标题。Spring版本基于5.1.3。
宏观而言，我们需要给一个类加注解@Controller，然后定义一个加了注解@RequestMapping的方法，这样Spring容器就可以准确找到对应的方法了。
其实要回答这个问题，可以从Spring源码去一步步分析。
在Spring MVC里，有一专门处理请求映射的接口HandlerMapping，查看此接口的实现类：
其中，RequestMappingHandlerMapping是我们需要关注的。我们首先看一下RequestMappingHandlerMapping的抽象父类AbstractHandlerMethodMapping，省略其他方法，先关注这两个相关核心方法：
public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping implements InitializingBean {
...
// Handler method detection
/**
* Detects handler methods at initialization.
*/
@Override
public void afterPropertiesSet() {
initHandlerMethods();
// Total includes detected mappings + explicit registrations via registerMapping..
int total = this.getHandlerMethods().size();
if ((logger.isTraceEnabled() && total == 0) || (logger.isDebugEnabled() && total > 0) ) {
logger.debug(total + " mappings in " + formatMappingName());
}
}
/**
* Scan beans in the ApplicationContext, detect and register handler methods.
* @see #isHandler(Class)
* @see #getMappingForMethod(Method, Class)
* @see #handlerMethodsInitialized(Map)
*/
protected void initHandlerMethods() {
String[] beanNames = obtainApplicationContext().getBeanNamesForType(Object.class);
for (String beanName : beanNames) {
if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
Class<?> beanType = null;
try {
beanType = obtainApplicationContext().getType(beanName);
}
catch (Throwable ex) {
// An unresolvable bean type, probably from a lazy bean - let's ignore it.
if (logger.isTraceEnabled()) {
logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
}
}
if (beanType != null && isHandler(beanType)) {
detectHandlerMethods(beanName);
}
}
}
handlerMethodsInitialized(getHandlerMethods());
}
...
}可以看到AbstractHandlerMethodMapping实现了InitializingBean接口，在Spring初始化bean的时候，如果bean实现了InitializingBean接口，会自动调用afterPropertiesSet方法。initHandlerMethods方法，顾名思义是初始化HandlerMethods，查看它是被afterPropertiesSet方法调用，这个方法代表bean在容器中被初始化的时候，会去执行initHandlerMethods方法。
那initHandlerMethods方法具体做了什么事情？大概看一下方法内部的业务，首先拿到容器里的所有bean名称放进数组beanNames中；然后遍历数组，拿到每一个bean的类型beanType，对每一个beanType做了一个判断isHandler(beanType)，查看此方法的实现，即进入RequestMappingHandlerMapping中：
public class RequestMappingHandlerMapping extends RequestMappingInfoHandlerMapping
implements EmbeddedValueResolverAware {
...
/**
* {@inheritDoc}
* Expects a handler to have a type-level @{@link Controller} annotation.
*/
@Override
protected boolean isHandler(Class<?> beanType) {
return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));
}
...
}·很容易看出来，是去判断该类是否加了注解@Controller或@RequestMapping。点进去查看AnnotatedElementUtils.hasAnnotation方法的实现：
public static boolean hasAnnotation(AnnotatedElement element, Class<? extends Annotation> annotationType) {
// Shortcut: directly present on the element, with no processing needed?
if (element.isAnnotationPresent(annotationType)) {
return true;
}
return Boolean.TRUE.equals(searchWithFindSemantics(element, annotationType, null, alwaysTrueAnnotationProcessor));
}所以我们判断一个类上是否加了什么注解，可以这么写：
public class Test {
public static void main(String[] args) {
Test.class.isAnnotationPresent(Override.class);
}
}判断完类上加了注解@Controller或者@RequestMapping后，看到继续执行了detectHandlerMethods方法：
/**
* Look for handler methods in a handler.
* @param handler the bean name of a handler or a handler instance
*/
protected void detectHandlerMethods(final Object handler) {
Class<?> handlerType = (handler instanceof String ?
obtainApplicationContext().getType((String) handler) : handler.getClass());
if (handlerType != null) {
final Class<?> userType = ClassUtils.getUserClass(handlerType);
Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
(MethodIntrospector.MetadataLookup<T>) method -> getMappingForMethod(method, userType));
if (logger.isTraceEnabled()) {
logger.trace(formatMappings(userType, methods));
}
methods.forEach((key, mapping) -> {
Method invocableMethod = AopUtils.selectInvocableMethod(key, userType);
registerHandlerMethod(handler, invocableMethod, mapping);
});
}
}
/**
* Register a handler method and its unique mapping. Invoked at startup for
* each detected handler method.
* @param handler the bean name of the handler or the handler instance
* @param method the method to register
* @param mapping the mapping conditions associated with the handler method
* @throws IllegalStateException if another method was already registered
* under the same mapping
*/
protected void registerHandlerMethod(Object handler, Method method, T mapping) {
this.mappingRegistry.register(mapping, handler, method);
}这个方法筛选出了类中加了注解@RequestMapping的方法，放进Map集合methods中，紧接着去遍历每一个method，进入registerHandlerMethod方法，注册到映射注册表mappingRegistry中，其中就是一些Map。
至此，我们就明白了在Spring初始化bean的时候，就把所有的加了@Controller/@RequestMapping的类里面的加了@RequestMapping的方法放进了map中，当http请求来临时，直接去map中迅速拿到对应信息。
