public void afterPropertiesSet() { //实现了InitializingBean接口的方法，进行初始化的入口。

         this.initHandlerMethods();

     }

     protected void initHandlerMethods() {

         if (this.logger.isDebugEnabled()) {

             this.logger.debug("Looking for request mappings in application context: " + this.getApplicationContext());

         }

 　　　　 //扫描应用下所有Object类

         String[] beanNames = this.detectHandlerMethodsInAncestorContexts ? BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.getApplicationContext(), Object.class) : this.getApplicationContext().getBeanNamesForType(Object.class);

         String[] arr$ = beanNames;

         int len$ = beanNames.length;

         for(int i$ = ; i$ < len$; ++i$) {

             String beanName = arr$[i$];

             if (this.isHandler(this.getApplicationContext().getType(beanName))) { //ishandler由子类实现，是个钩子方法，让子类实现自己的逻辑

                 this.detectHandlerMethods(beanName);

             }

         }

         this.handlerMethodsInitialized(this.getHandlerMethods());//初始化处理器对象，目前是钩子方法，但是也没有子类实现这个方法

     }

     protected boolean isHandler(Class<?> beanType) { //非常简单， 就是看这个类有没有Controller或者RequestMapping注解，有一个就行

         return AnnotationUtils.findAnnotation(beanType, Controller.class) != null || AnnotationUtils.findAnnotation(beanType, RequestMapping.class) != null;

     }

     protected void detectHandlerMethods(Object handler) { //开始注册handler

         Class<?> handlerType = handler instanceof String ? this.getApplicationContext().getType((String)handler) : handler.getClass();

         final Class<?> userType = ClassUtils.getUserClass(handlerType);
　　　　　　//这块是获取handelr的所有方法，但是有一个过滤器，就是把有匹配条件的的method获取到

         Set<Method> methods = HandlerMethodSelector.selectMethods(userType, new MethodFilter() {

             public boolean matches(Method method) {

                 return AbstractHandlerMethodMapping.this.getMappingForMethod(method, userType) != null;//getMappingForMethod钩子方法，子类实现

             }

         });

         Iterator i$ = methods.iterator();

         //遍历method 进行注册。

         while(i$.hasNext()) {

             Method method = (Method)i$.next();

             T mapping = this.getMappingForMethod(method, userType);

             this.registerHandlerMethod(handler, method, mapping);

         }

     }

     protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {

         RequestMappingInfo info = null; //获取方法上的RequestMapping注解信息

         RequestMapping methodAnnotation = (RequestMapping)AnnotationUtils.findAnnotation(method, RequestMapping.class);

         if (methodAnnotation != null) {

             RequestCondition<?> methodCondition = this.getCustomMethodCondition(method);

             info = this.createRequestMappingInfo(methodAnnotation, methodCondition); 构造匹配条件
　　　　　　　　 // 获取类上的面RequestHandlerMapping注解信息

             RequestMapping typeAnnotation = (RequestMapping)AnnotationUtils.findAnnotation(handlerType, RequestMapping.class);

             if (typeAnnotation != null) {

                 RequestCondition<?> typeCondition = this.getCustomTypeCondition(handlerType);

                 info = this.createRequestMappingInfo(typeAnnotation, typeCondition).combine(info); 构造匹配条件，同方法的进行合并

             }

         }

         return info;

     }

 public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping implements InitializingBean {

     //这块实际上是两个map保存的，泛型实际上就是RequestMappingInfo,这个就是匹配条件 HanlderMethod是封装了处理器全部信息的封装类

     private final Map<T, HandlerMethod> handlerMethods = new LinkedHashMap(); //存的是 key：匹配条件 value: 处理器

     private final MultiValueMap<String, T> urlMap = new LinkedMultiValueMap(); //key: url value: 匹配条件

     protected void registerHandlerMethod(Object handler, Method method, T mapping) {

         HandlerMethod handlerMethod;

         if (handler instanceof String) {

             String beanName = (String)handler;

             handlerMethod = new HandlerMethod(beanName, this.getApplicationContext(), method);

         } else {

             handlerMethod = new HandlerMethod(handler, method);

         }

         HandlerMethod oldHandlerMethod = (HandlerMethod)this.handlerMethods.get(mapping);

         if (oldHandlerMethod != null && !oldHandlerMethod.equals(handlerMethod)) { //不允许存在一个mapping对应多个handlerMethod

             throw new IllegalStateException("Ambiguous mapping found. Cannot map '" + handlerMethod.getBean() + "' bean method \n" + handlerMethod + "\nto " + mapping + ": There is already '" + oldHandlerMethod.getBean() + "' bean method\n" + oldHandlerMethod + " mapped.");

         } else {

             this.handlerMethods.put(mapping, handlerMethod); //存放第一个映射集合

             if (this.logger.isInfoEnabled()) {

                 this.logger.info("Mapped \"" + mapping + "\" onto " + handlerMethod);

             }

             Set<String> patterns = this.getMappingPathPatterns(mapping); //获取方法的URL

             Iterator i$ = patterns.iterator();

             while(i$.hasNext()) {

                 String pattern = (String)i$.next();

                 if (!this.getPathMatcher().isPattern(pattern)) { //依次放入第二个映射集合

                     this.urlMap.add(pattern, mapping);

                 }

             }

         }

     }