@RequestMapping/@Controller注解在哪里得到处理？

1 结论

@RequestMapping/@Controller注解在实例化RequestMappingHandlerMapping的时候处理。先从ApplicationContext获取所有已注册Bean，然后依次判断是否包含这两个注解，如果是则把RequestMapping标注的method注册到RequestMappingHandlerMapping$MappingRegistry.mapptingLookUp（一个Map<T,HandlerMethod>）,RequestMappingHandlerMapping包含在DispatcherServlet的属性handlerMappings（一个List）之中，请求进入时会遍历handlerMappings，就能找到对应的映射关系。
找到的Handler会和相关的Interceptors一起封装成HandlerExecutionChain供DispatcherServlet使用。

2 源码分析

去掉了无关代码，只在关键部位做了注释。

//AbstractApplicationContext  该方法是Spring的主要启动过程
 public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);

            try {
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);  //这一步
                this.finishRefresh();
            } catch (BeansException var9) {
            .....
            } finally {
            .....
            }
        }
    }

//AbstractApplicationContext
 protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        .........
        beanFactory.setTempClassLoader((ClassLoader)null);
        beanFactory.freezeConfiguration();
        beanFactory.preInstantiateSingletons();  //这一步
    }

//DefaultListableBeanFactory
public void preInstantiateSingletons() throws BeansException {
        ......
        List<String> beanNames = new ArrayList(this.beanDefinitionNames);
        Iterator var2 = beanNames.iterator();

        while(true) {
            String beanName;
            Object bean;
            do {
                while(true) {
                    RootBeanDefinition bd;
                    do {
                        do {
                            do {
                                if (!var2.hasNext()) {
                                    var2 = beanNames.iterator();

                                    while(var2.hasNext()) {
                                        beanName = (String)var2.next();
                                        Object singletonInstance = this.getSingleton(beanName);
                                        if (singletonInstance instanceof SmartInitializingSingleton) {
                                            SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
                                            if (System.getSecurityManager() != null) {
                                                AccessController.doPrivileged(() -> {
                                                    smartSingleton.afterSingletonsInstantiated();
                                                    return null;
                                                }, this.getAccessControlContext());
                                            } else {
                                                smartSingleton.afterSingletonsInstantiated();
                                            }
                                        }
                                    }

                                    return;
                                }

                                beanName = (String)var2.next();
                                bd = this.getMergedLocalBeanDefinition(beanName);
                            } while(bd.isAbstract());
                        } while(!bd.isSingleton());
                    } while(bd.isLazyInit());

                    if (this.isFactoryBean(beanName)) {
                        bean = this.getBean("&" + beanName);
                        break;
                    }

                    this.getBean(beanName);  //这一步，beanName = “requestMappingHandlerMapping”
                }
            } while(!(bean instanceof FactoryBean));

    //RequestMappingHandlerMapping  super.afterPropertiesSet()
	@Override
	public void afterPropertiesSet() {
		initHandlerMethods();
	}


	protected void initHandlerMethods() {
		for (String beanName : getCandidateBeanNames()) {
			if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
				processCandidateBean(beanName);   //这一步
			}
		}
		handlerMethodsInitialized(getHandlerMethods());
	}

//AbstractHandlerMethodMapping
protected void processCandidateBean(String beanName) {
		Class<?> beanType = null;
		try {
			beanType = obtainApplicationContext().getType(beanName);
		}
		catch (Throwable ex) {

		}
		if (beanType != null && isHandler(beanType)) {  //isHandler判断Controller类的注解
			detectHandlerMethods(beanName);  //这一步，注册Controller方法到
		}
	}
//RequestMappingHandlerMapping
protected boolean isHandler(Class<?> beanType) {
    //判断是否包含@Controller或@RequestMapping
	return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
		AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));
}

//AbstractHandlerMethodMapping
protected void detectHandlerMethods(Object handler) {
		Class<?> handlerType = (handler instanceof String ?
				obtainApplicationContext().getType((String) handler) : handler.getClass());

		if (handlerType != null) {
			Class<?> userType = ClassUtils.getUserClass(handlerType);
			Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
					(MethodIntrospector.MetadataLookup<T>) method -> {
						try {
							return getMappingForMethod(method, userType);
						}
						catch (Throwable ex) {

						}
					});
			if (logger.isTraceEnabled()) {
				logger.trace(formatMappings(userType, methods));
			}
			//遍历Controller方法
			methods.forEach((method, mapping) -> {
				Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
				registerHandlerMethod(handler, invocableMethod, mapping);  //这一步，注册
			});
		}
	}
//AbstractHandlerMethodMapping
	protected void registerHandlerMethod(Object handler, Method method, T mapping) {
		this.mappingRegistry.register(mapping, handler, method); //这一步，注册
	}

AbstractHandlerMethodMapping $MappingRegistry
public void register(T mapping, Object handler, Method method) {
			this.readWriteLock.writeLock().lock();
			try {
				HandlerMethod handlerMethod = createHandlerMethod(handler, method);
				assertUniqueMethodMapping(handlerMethod, mapping);
				this.mappingLookup.put(mapping, handlerMethod); //注册，mappingLookup是一个Map<T,HandlerMethod>
				......

以上发生在Spring启动过程，以下是请求到来的时候DispatcherServlet的映射过程，注意DispatcherServlet返回一个HandlerExecutionChain。

//AbstractHandlerMethodMapping  请求映射过程
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		Object handler = getHandlerInternal(request); //查找最佳请求处理器
		if (handler == null) {
			handler = getDefaultHandler();
		}
		if (handler == null) {
			return null;
		}
		if (handler instanceof String) {
			String handlerName = (String) handler;
			handler = obtainApplicationContext().getBean(handlerName);
		}
		//封装成HandlerExecutionChain，这里会加入拦截器
		HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);

		if (CorsUtils.isCorsRequest(request)) {
			CorsConfiguration globalConfig = this.corsConfigurationSource.getCorsConfiguration(request);
			CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
			CorsConfiguration config = (globalConfig != null ? globalConfig.combine(handlerConfig) : handlerConfig);
			executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
		}

		return executionChain;
	}
//封装和加拦截器的过程
protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
		HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
				(HandlerExecutionChain) handler : new HandlerExecutionChain(handler));

		String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
		//adaptedInterceptors是该类的interceptors属性处理而来，interceptors则是set进来的
		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;
	}

完。