RequestMappingHandlerMapping的工作原理

拼搏现实的明天。 2022-08-31 04:54 158阅读 0赞

**目录**

接口是如何注册的

AbstractHandlerMethodMapping类

MappingRegistry类

请求时如何到达对应的方法的

--------------------

使用SpringMVC开发的人都知道最常用的定义接口的方式就是借助于@Controller和@RequestMapping等注解实现。而RequestMappingHandlerMapping类就是用于扫描注解和生成URL映射，处理请求时的URL映射匹配等关键功能的。

## 接口是如何注册的 ##

RequestMappingHandlerMapping通过继承AbstractHandlerMethodMapping抽象类间接的实现了InitializingBean接口，在启动时，会执行afterPropertiesSet方法。在afterPropertiesSet方法中，初始化了config对象，以及调用父类AbstractHandlerMethodMapping的afterPropertiesSet，父类方法afterPropertiesSet 逻辑是 initHandlerMethods，也就是**父类AbstractHandlerMethodMapping 的 initHandlerMethods方法是SpringMvc初始化寻找Controller以及映射加载的核心逻辑**。

@Override
        public void afterPropertiesSet() {
            this.config = new RequestMappingInfo.BuilderConfiguration();
            this.config.setPathHelper(getUrlPathHelper());
            this.config.setPathMatcher(getPathMatcher());
            this.config.setSuffixPatternMatch(this.useSuffixPatternMatch);
            this.config.setTrailingSlashMatch(this.useTrailingSlashMatch);
            this.config.setRegisteredSuffixPatternMatch(this.useRegisteredSuffixPatternMatch);
            this.config.setContentNegotiationManager(getContentNegotiationManager());
    　　　　　//调用父类 afterPropertiesSet 方法，这是SpringMvc映射关系加载的核心；
            super.afterPropertiesSet();
        }
    
        //AbstractHandlerMethodMapping#afterPropertiesSet()方法代码
    	@Override
    	public void afterPropertiesSet() {
    		initHandlerMethods();
    	}

### **AbstractHandlerMethodMapping类** ###

这个类是RequestMappingHandlerMapping类的父类。具体看下**AbstractHandlerMethodMapping\#initHandlerMethods(**)方法代码，这里为了看起来代码逻辑清晰就把一些内部方法拆解开了

1和2处的代码是关键，通过isHandler方法判断然后通过detectHandlerMethods方法执行方法注册的处理逻辑，这个方法就是处理Controller中得各个接口方法的。

protected void initHandlerMethods() {
            if (logger.isDebugEnabled()) {
                logger.debug("Looking for request mappings in application context: " + getApplicationContext());
            }
            String[] beanNames = (this.detectHandlerMethodsInAncestorContexts ?
                    BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
                    getApplicationContext().getBeanNamesForType(Object.class));   
    　　　　　　// detectHandlerMethodsInAncestorContexts 默认为false,代表不会检测SpringMvc父容器中的bean的映射关系    
    　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
            for (String beanName : beanNames) {　　　　　　　　　　　　　　　　　　　　　
        //遍历容器中的beanName, 代理的对象跳过，获取当前bean的类型，调用isHandler判断是否是处理器(handler\controller)
                if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
                    Class<?> beanType = null;
                    try {
                        beanType = getApplicationContext().getType(beanName);
                    }
                    catch (Throwable ex) {
                        // An unresolvable bean type, probably from a lazy bean - let's ignore it.
                        if (logger.isDebugEnabled()) {
                            logger.debug("Could not resolve target class for bean with name '" + beanName + "'", ex);
                        }
                    }
                    // 1----------如果是RequestMappingHandlerMapping,此处调用的是RequestMappingHandlerMapping类的isHandler方法判断是否是controller
                    if (beanType != null && isHandler(beanType)) {　
                    // 2------如果isHandler为True,加载Controller和请求映射关系 
                        detectHandlerMethods(beanName);　
                    }
                }
            }
            handlerMethodsInitialized(getHandlerMethods());　// 该方法是个空实现
        }

RequestMappingHandlerMapping类的isHandler方法逻辑

> **判断有没有标注@Controller或者@RequestMapping注解，如果有就返回true。**

protected boolean isHandler(Class<?> beanType) {
            return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
                    AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));
        }

解析Controller注册接口方法的核心逻辑在detectHandlerMethods方法中。

> 1.  通过 **MethodIntrospector.selectMethods**方法拿到当前Controller类下的所有的方法存储为Map<Method, T>类型的 methods对象里。
> 2.  遍历methods，调用**registerHandlerMethod**方法，通过**MappingRegistry\#register方法**把Controller类下符合要求的接口方法注册到MappingRegistry类型的全局对象中。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NTY5MTgz_size_16_color_FFFFFF_t_70][]

**registerHandlerMethod方法调用的是MappingRegistry类的register方法**

protected void registerHandlerMethod(Object handler, Method method, T mapping) {
    		this.mappingRegistry.register(mapping, handler, method);
    	}

### MappingRegistry类 ###

*  **MappingRegistry\#register方法是加锁的**

> register方法中解析controller的逻辑中就涉及到HandlerMapping类的问题，例如默认的是RequestMappingHandlerMapping，但是如果我们想要要做一些自定义的实现，比如加版本号实现接口版本控制，那就需要继承默认的重写isHandler，getCustomTypeCondition和getCustomMethodCondition方法，实现自定义的Condition逻辑，，这几个方法的自定义逻辑会在解析controller的方法这一步通过默认的RequestMappingHandlerMapping中得getMappingForMethod方法逻辑中调用到，具体在RequestMappingHandlerMapping\#createRequestMappingInfo方法中根据Method的类型选择调用getCustomTypeCondition方法或者getCustomMethodCondition方法获取到自定义逻辑中的Condition信息

class MappingRegistry {
    
    		private final Map<T, MappingRegistration<T>> registry = new HashMap<>();
    
    		private final Map<T, HandlerMethod> mappingLookup = new LinkedHashMap<>();
    
            //这个Map放的就是请求URL和方法名的对应关系。
    		private final MultiValueMap<String, T> urlLookup = new LinkedMultiValueMap<>();
    
    		private final Map<String, List<HandlerMethod>> nameLookup = new ConcurrentHashMap<>();
    
    		private final Map<HandlerMethod, CorsConfiguration> corsLookup = new ConcurrentHashMap<>();
    
    		private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
            //..............................................................
    
    		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 {
    				HandlerMethod handlerMethod = createHandlerMethod(handler, method);
                    //校验唯一性，一个RequestMappingInfo对应一个Handlermethod，如果根据RequestMappingInfo找到不同的hm 抛出异常
    				validateMethodMapping(handlerMethod, mapping);
    				this.mappingLookup.put(mapping, handlerMethod);
    
    				List<String> directUrls = getDirectUrls(mapping);
    				for (String url : directUrls) {
    					this.urlLookup.add(url, mapping);
    				}
    
    				String name = null;
    				if (getNamingStrategy() != null) {
    					name = getNamingStrategy().getName(handlerMethod, mapping);
                        //MappingRegistry的nameLookup保存着 name--HandlerMethod集合
    					addMappingName(name, handlerMethod);
    				}
    
    				CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
    				if (corsConfig != null) {
    					this.corsLookup.put(handlerMethod, corsConfig);
    				}
    MappingRegistry的registry保存着RequestMappingInfo--MappingRegistration，MappingRegistration几乎有映射的所有信息
    				this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
    			}
    			finally {
                    //可重入锁 写锁 释放锁
    				this.readWriteLock.writeLock().unlock();
    			}
    		}
    
    		private void validateMethodMapping(HandlerMethod handlerMethod, T mapping) {
    			// Assert that the supplied mapping is unique.
    			HandlerMethod existingHandlerMethod = this.mappingLookup.get(mapping);
    			if (existingHandlerMethod != null && !existingHandlerMethod.equals(handlerMethod)) {
    				throw new IllegalStateException(
    						"Ambiguous mapping. Cannot map '" + handlerMethod.getBean() + "' method \n" +
    						handlerMethod + "\nto " + mapping + ": There is already '" +
    						existingHandlerMethod.getBean() + "' bean method\n" + existingHandlerMethod + " mapped.");
    			}
    		}
    
    		private List<String> getDirectUrls(T mapping) {
    			List<String> urls = new ArrayList<>(1);
    			for (String path : getMappingPathPatterns(mapping)) {
    				if (!getPathMatcher().isPattern(path)) {
    					urls.add(path);
    				}
    			}
    			return urls;
    		}
    
    		private void addMappingName(String name, HandlerMethod handlerMethod) {
    			List<HandlerMethod> oldList = this.nameLookup.get(name);
    			if (oldList == null) {
    				oldList = Collections.emptyList();
    			}
    
    			for (HandlerMethod current : oldList) {
    				if (handlerMethod.equals(current)) {
    					return;
    				}
    			}
    
    			List<HandlerMethod> newList = new ArrayList<>(oldList.size() + 1);
    			newList.addAll(oldList);
    			newList.add(handlerMethod);
    			this.nameLookup.put(name, newList);
    		}
    
    		public void unregister(T mapping) {
    			this.readWriteLock.writeLock().lock();
    			try {
    				MappingRegistration<T> definition = this.registry.remove(mapping);
    				if (definition == null) {
    					return;
    				}
    
    				this.mappingLookup.remove(definition.getMapping());
    
    				for (String url : definition.getDirectUrls()) {
    					List<T> list = this.urlLookup.get(url);
    					if (list != null) {
    						list.remove(definition.getMapping());
    						if (list.isEmpty()) {
    							this.urlLookup.remove(url);
    						}
    					}
    				}
    
    				removeMappingName(definition);
    
    				this.corsLookup.remove(definition.getHandlerMethod());
    			}
    			finally {
    				this.readWriteLock.writeLock().unlock();
    			}
    		}
    
    		private void removeMappingName(MappingRegistration<T> definition) {
    			String name = definition.getMappingName();
    			if (name == null) {
    				return;
    			}
    			HandlerMethod handlerMethod = definition.getHandlerMethod();
    			List<HandlerMethod> oldList = this.nameLookup.get(name);
    			if (oldList == null) {
    				return;
    			}
    			if (oldList.size() <= 1) {
    				this.nameLookup.remove(name);
    				return;
    			}
    			List<HandlerMethod> newList = new ArrayList<>(oldList.size() - 1);
    			for (HandlerMethod current : oldList) {
    				if (!current.equals(handlerMethod)) {
    					newList.add(current);
    				}
    			}
    			this.nameLookup.put(name, newList);
    		}
    	}

## 请求时如何到达对应的方法的 ##

在DispatchServlet中，doDispatch方法会历各种HandlerMapping。当遍历到RequestMappingHandlerMapping时，RequestMappingHandlerMapping中的MappingRegistry中有一个urlLookup的map对象，key就是@RequestMapping注解定义的URL，Value就是对应的类和方法信息，所以在查找时以请求的地址lookupPath作为key就能拿到对应的类和方法信息，也就找到了这个请求对应的方法。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NTY5MTgz_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NTY5MTgz_size_16_color_FFFFFF_t_70 2][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NTY5MTgz_size_16_color_FFFFFF_t_70]: /images/20220829/41b1e1bc7f6243e98c485bedc86a6d32.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NTY5MTgz_size_16_color_FFFFFF_t_70 1]: /images/20220829/6a5f52b1db34474b854cb175cc456e33.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NTY5MTgz_size_16_color_FFFFFF_t_70 2]: /images/20220829/53c6d6ca86be487aa5ec414a74e01014.png