SpringMVC工作原理之：HandlerMapping

一、HandlerMapping

作用是根据当前请求的找到对应的 Handler，并将 Handler（执行程序）与一堆 HandlerInterceptor（拦截器）封装到 HandlerExecutionChain 对象中。在 HandlerMapping 接口的内部只有一个方法，如下：

• HandlerExecutionChain getHandler(HttpServletRequest request);

HandlerMapping 是由 DispatcherServlet 调用，DispatcherServlet 会从容器中取出所有 HandlerMapping 实例并遍历，让 HandlerMapping 实例根据自己实现类的方式去尝试查找 Handler。

Handler 有可能是一个 HandlerMethod（封装了 Controller 中的方法）对象，也有可能是一个 Controller 对象、 HttpRequestHandler 对象或 Servlet 对象，而这个 Handler 具体是什么对象，也是与所使用的 HandlerMapping 实现类有关。如下图所示，可以看到 HandlerMapping 实现类有两个分支，分别继承自 AbstractHandlerMethodMapping（得到 HandlerMethod）和 AbstractUrlHandlerMapping（得到 HttpRequestHandler、Controller 或 Servlet），它们又统一继承于 AbstractHandlerMapping。

先来看一下 AbstractHandlerMapping，它实现了 HandlerMapping 接口中的 getHandler() 方法，源码如下所示

可以看到在这个方法中又调用了 getHandlerInternal() 方法获取到了 Handler 对象，而 Handler 对象具体内容是由它的子类去定义的。下面就来一看下 AbstractHandlerMapping 的两个分支子类

1 AbstractUrlHandlerMapping

AbstractUrlHandlerMapping 这个分支获取的 Handler 的类型实际就是一个 Controller 类，所以一个 Controller 只能对应一个请求（或者像 Struts2 那样定位到方法，使同一个业务的方法放在同一个类里），源码如下所示

1.1 AbstractUrlHandlerMapping 实现类及使用

1.2 Controller 类

使用 AbstractUrlHandlerMapping 的实现类时，需要让控制层的类实现 Controller 接口（一般继承 AbstractController 即可），另外还有一些已经实现了的 Controller 类，如下图所示。但是不论是自己实现 Controller 接口还是使用系统已经实现的类，都只能处理一个请求（除了 MultiActionController 可以通过参数的方式让一个类可以处理多个请求）。

ServletWrappingController：将某个 Servlet 包装为 Controller，所有到 ServletWrappingController 的请求实际上是由它内部所包装的这个 Servlet 实例来处理的，这样可以将这个 Servlet 隐藏起来

2 AbstractHandlerMethodMapping

AbstractHandlerMethodMapping 这个分支获取的 Handler 的类型是 HandlerMethod，即这个 Handler 是一个方法，它保存了方法的信息（如Method），这样一个 Controller 就可以处理多个请求了，源码如下所示

上述代码中 lookupHandlerMethod() 方法主要工作是在 Map handlerMethods 中找到 HandlerMethod，这里的 T 是 HandlerMappingInfo，它封装了 @RequestMapping 注解中的信息。那 HandlerMethod 是怎么创建的（即怎么把 Controller 的方法变成了它），继续看一下源码找到 initHandlerMethods() 方法，这个方法是在这个类创建后调用的，如下所示是它的源码

	
	protected void initHandlerMethods() {
		if (logger.isDebugEnabled()) {
			logger.debug("Looking for request mappings in application context: " + getApplicationContext());
		}

        // 从容器中获取所有 Bean 的名称，detectHandlerMethodsInAncestorContexts 默认false，不从父容器中查找
        //即默认只查找 SpringMVC 的 IOC 容器，不查找它的父容器 Spring 的 IOC 容器
		String[] beanNames = (this.detectHandlerMethodsInAncestorContexts ?				BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :getApplicationContext().getBeanNamesForType(Object.class));

		for (String beanName : beanNames) {
            // 这里的 isHandler()方法由子类实现，判断是否拥有 @Controller 注解或 @RequestMapping 注解
			if (isHandler(getApplicationContext().getType(beanName))){
                // 利用反射得到 Bean 中的 Method 并包装成 HandlerMethod，然后放入 Map 中
				detectHandlerMethods(beanName);
			}
		}
		handlerMethodsInitialized(getHandlerMethods());
	}

看完上述代码后，可以知道是在 detectHandlerMethods() 方法中将 Bean 的方法转换为 HandlerMethod 对象，具体实现如下

protected void detectHandlerMethods(final Object handler) {
        // 获取这个 Bean 的 Class 对象
		Class handlerType =
				(handler instanceof String ? getApplicationContext().getType((String) handler) : handler.getClass());

		//避免重复调用 getMappingForMethod()，getMappingForMethod() 将重新构建 RequestMappingInfo 实例
		final Map mappings = new IdentityHashMap();
        // 获取被代理前的原始类型
		final Class userType = ClassUtils.getUserClass(handlerType);
        // 获取 Method  
		Set methods = HandlerMethodSelector.selectMethods(userType, new MethodFilter() {
			public boolean matches(Method method) {
                // 根据 Method 和它的 @RequestMapping 注解，创建 RequestMappingInfo 对象。
                // 这里的 T 就是 RequestMappingInfo，它封装了 @RequestMapping 信息
				T mapping = getMappingForMethod(method, userType);
				if (mapping != null) {
					mappings.put(method, mapping);
					return true;
				}
				else {
					return false;
				}
			}
		});

		for (Method method : methods) {
            // 注册 Method 和它的映射，RequestMappingInfo 储存着映射信息
			registerHandlerMethod(handler, method, mappings.get(method));
		}
	}

 

最后在 registerHandlerMethod() 方法中，将 RequestMappingInfo 作为 key，把 Method 包装成 HandlerMethod 作为 value 添加到了 Map handlerMethods 中。

protected void registerHandlerMethod(Object handler, Method method, T mapping) {
		HandlerMethod newHandlerMethod = createHandlerMethod(handler, method);
		HandlerMethod oldHandlerMethod = this.handlerMethods.get(mapping);
		if (oldHandlerMethod != null && !oldHandlerMethod.equals(newHandlerMethod)) {
			throw new IllegalStateException("Ambiguous mapping found. Cannot map '" + newHandlerMethod.getBean() +
					"' bean method \n" + newHandlerMethod + "\nto " + mapping + ": There is already '" +
					oldHandlerMethod.getBean() + "' bean method\n" + oldHandlerMethod + " mapped.");
		}

		this.handlerMethods.put(mapping, newHandlerMethod);
		if (logger.isInfoEnabled()) {
			logger.info("Mapped \"" + mapping + "\" onto " + newHandlerMethod);
		}

		Set patterns = getMappingPathPatterns(mapping);
		for (String pattern : patterns) {
			if (!getPathMatcher().isPattern(pattern)) {
				this.urlMap.add(pattern, mapping);
			}
		}
	}