Spring MVC 请求方法处理

发表于

在前面的文章中有说明：<mvc:annotation-driven />在spring 3.1之后会注册了RequestMappingHandlerMapping和RequestMappingHandlerAdapter，本文详细介绍具体的实现。

在xml文件中配置mvc:annotation-driven，有一个专门的类BeanDefinitionParser来解析处理这个东西。 它只有一个方法： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public interface BeanDefinitionParser {  
  
    /** 
     * Parse the specified {@link Element} and register the resulting 
     * {@link BeanDefinition BeanDefinition(s)} with the 
     * {@link org.springframework.beans.factory.xml.ParserContext#getRegistry() BeanDefinitionRegistry} 
     * embedded in the supplied {@link ParserContext}. 
     * <p>Implementations must return the primary {@link BeanDefinition} that results 
     * from the parse if they will ever be used in a nested fashion (for example as 
     * an inner tag in a {@code <property/>} tag). Implementations may return 
     * {@code null} if they will <strong>not</strong> be used in a nested fashion. 
     * @param element the element that is to be parsed into one or more {@link BeanDefinition BeanDefinitions} 
     * @param parserContext the object encapsulating the current state of the parsing process; 
     * provides access to a {@link org.springframework.beans.factory.support.BeanDefinitionRegistry} 
     * @return the primary {@link BeanDefinition} 
     */  
    BeanDefinition parse(Element element, ParserContext parserContext);  
}

用来专门处理<beans></beans>里面的配置元素。然后找到这样的一个实现类AnnotationDrivenBeanDefinitionParser

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
/** 
 * 这里清清楚楚写着该类是专门处理 <mvc:annotation-driven/>标签的 
 * A {@link BeanDefinitionParser} that provides the configuration for the 
 * {@code <annotation-driven/>} MVC namespace  element. 
 * 
 * 这里说明了注册的HandlerMapping 
 * <p>This class registers the following {@link HandlerMapping}s:</p> 
 * <ul> 
 *  <li>{@link RequestMappingHandlerMapping} 
 *  ordered at 0 for mapping requests to annotated controller methods. 
 *  <li>{@link BeanNameUrlHandlerMapping} 
 *  ordered at 2 to map URL paths to controller bean names. 
 * </ul> 
 * 
 * <p><strong>Note:</strong> Additional HandlerMappings may be registered 
 * as a result of using the {@code <view-controller>} or the 
 * {@code <resources>} MVC namespace elements. 
 * 
 * 这里说明了注册的HandlerAdapter 
 * <p>This class registers the following {@link HandlerAdapter}s: 
 * <ul> 
 *  <li>{@link RequestMappingHandlerAdapter} 
 *  for processing requests with annotated controller methods. 
 *  <li>{@link HttpRequestHandlerAdapter} 
 *  for processing requests with {@link HttpRequestHandler}s. 
 *  <li>{@link SimpleControllerHandlerAdapter} 
 *  for processing requests with interface-based {@link Controller}s. 
 * </ul> 
 * 
 * <p>This class registers the following {@link HandlerExceptionResolver}s: 
 * <ul> 
 *  <li>{@link ExceptionHandlerExceptionResolver} for handling exceptions 
 *  through @{@link ExceptionHandler} methods. 
 *  <li>{@link ResponseStatusExceptionResolver} for exceptions annotated 
 *  with @{@link ResponseStatus}. 
 *  <li>{@link DefaultHandlerExceptionResolver} for resolving known Spring 
 *  exception types 
 * </ul> 
 * 
 * <p>Both the {@link RequestMappingHandlerAdapter} and the 
 * {@link ExceptionHandlerExceptionResolver} are configured with instances of 
 * the following by default: 
 * <ul> 
 *  <li>A {@link ContentNegotiationManager} 
 *  <li>A {@link DefaultFormattingConversionService} 
 *  <li>A {@link org.springframework.validation.beanvalidation.LocalValidatorFactoryBean} 
 *  if a JSR-303 implementation is available on the classpath 
 *  <li>A range of {@link HttpMessageConverter}s depending on what 3rd party 
 *  libraries are available on the classpath. 
 * </ul> 
 * 
 * @author Keith Donald 
 * @author Juergen Hoeller 
 * @author Arjen Poutsma 
 * @author Rossen Stoyanchev 
 * @author Brian Clozel 
 * @since 3.0 
 */  
class AnnotationDrivenBeanDefinitionParser implements BeanDefinitionParser {  
          //先省略，请详细看下文
}

解析过程的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@Override  
    public BeanDefinition parse(Element element, ParserContext parserContext) {  
        Object source = parserContext.extractSource(element);  
  
        //省略... 
       
        RootBeanDefinition handlerMappingDef = new RootBeanDefinition(RequestMappingHandlerMapping.class);  
          
        RootBeanDefinition handlerAdapterDef = new RootBeanDefinition(RequestMappingHandlerAdapter.class);  
          
        //省略...
      
        // 注册了RequestMappingHandlerMapping
        parserContext.registerComponent(new BeanComponentDefinition(handlerMappingDef, methodMappingName));
        // 注册了RequestMappingHandlerAdapter
		parserContext.registerComponent(new BeanComponentDefinition(handlerAdapterDef, handlerAdapterName));
      
        // Ensure BeanNameUrlHandlerMapping (SPR-8289) and default HandlerAdapters are not "turned off"  
        MvcNamespaceUtils.registerDefaultComponents(parserContext, source);  
  
        parserContext.popAndRegisterContainingComponent();  
  
        return null;  
    }

默认注册组件MvcNamespaceUtils.registerDefaultComponents的如下： 

1
2
3
4
5
public static void registerDefaultComponents(ParserContext parserContext, Object source) {  
        registerBeanNameUrlHandlerMapping(parserContext, source);  
        registerHttpRequestHandlerAdapter(parserContext, source);  
        registerSimpleControllerHandlerAdapter(parserContext, source);  
    }

至此所注册的HandlerMapping和HandlerAdapter都找到了。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?xml version="1.0" encoding="UTF-8" ?>  
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:util="http://www.springframework.org/schema/util" xmlns:context="http://www.springframework.org/schema/context"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans-3.1.xsd  
    http://www.springframework.org/schema/mvc  
    http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd  
    http://www.springframework.org/schema/util  
    http://www.springframework.org/schema/util/spring-util-2.0.xsd  
    http://www.springframework.org/schema/context   
    http://www.springframework.org/schema/context/spring-context-3.2.xsd">  
          
    <mvc:annotation-driven/>  
  
  </beans>

开启了<mvc:annotation-driven/>，同时注册了两个bean。有RequestMappingHandlerMapping和RequestMappingHandlerAdapter作为支持，这里简单说明下：RequestMappingHandlerMapping它会判断一个bean是否含有@Controller标签或者@RequestMapping，如果有其一则会将该bean纳入作为它的处理对象，之后会进一步处理该类上含有@RequestMapping注解的方法。这样做主要是由于@RequestMapping可以配置在类上（作为基础地址），也可以配置在方法上，我们有时候会在类上配置@RequestMapping，有时候又不会，所以只要类注解含有@Controller或者含有@RequestMapping，RequestMappingHandlerMapping都会将他们纳入自己的handler管辖范围。所以仅仅在方法中含有@RequestMapping注解是不被处理的，必须在类上加入@RequestMapping或者@Controller，所以@Controller又不是必须的。

1
2
3
4
5
6
7
8
9
10
@Controller  
public class StringAction {  
      
    @ResponseBody  
    @RequestMapping(value="/string",method=RequestMethod.GET)  
    public String testMessageConverter(String name) throws UnsupportedEncodingException{  
        System.out.println(name);  
        return name;  
    }  
}

@Controller使得StringAction这个handler纳入RequestMappingHandlerMapping管理，RequestMappingHandlerMapping会将这个handler和handler中的每一个含有@RequestMapping的方法都会构建成一个HandlerMethod对象，该类的构造函数为HandlerMethod(Object bean, Method method)，经过这样的包装之后将构造的HandlerMethod对象作为新的handler，然后进行选择适配器，进行方法调用，当RequestMappingHandlerAdapter判断是否support一个类时，就是依据当前的handle是否是HandlerMethod类型。若是则由RequestMappingHandlerAdapter来调度执行该handler（handler为HandlerMethod类型）的中的method方法。以上就是整个大体的流程。

  1. 第一步要弄清RequestMappingHandlerMapping在初始化时是如何寻找它所管辖的bean。

RequestMappingHandlerMapping的父类AbstractHandlerMethodMapping在初始化时，会调用这样的一个方法initHandlerMethods，在该方法中，遍历所有的bean然后判断他们是不是含有@Controller或者@RequestMapping注解： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
  /**
 * Detects handler methods at initialization.
 */
public void afterPropertiesSet() {
	initHandlerMethods();
}
  /**
 * Scan beans in the ApplicationContext, detect and register handler methods.
 * @see #isHandler(Class)
 * @see #getMappingForMethod(Method, Class)
 * @see #handlerMethodsInitialized(Map)
 */
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));
	for (String beanName : beanNames) {
		if (isHandler(getApplicationContext().getType(beanName))){
			detectHandlerMethods(beanName);
		}
	}
	handlerMethodsInitialized(getHandlerMethods());
}

其中的isHandler(由子类RequestMappingHandlerMapping实现)的判断方法代码如下： 

1
2
3
4
protected boolean isHandler(Class<?> beanType) {
		return ((AnnotationUtils.findAnnotation(beanType, Controller.class) != null) ||
				(AnnotationUtils.findAnnotation(beanType, RequestMapping.class) != null));
	}

如果handler含有了上述注解的其中之一，就会进一步处理该handler的方法中含有@RequestMapping的方法： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
  /**
    * 找到Controller中有@RequestMapping注解的方法
 * 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 ? getApplicationContext().getType((String) handler) : handler.getClass());
	// Avoid repeated calls to getMappingForMethod which would rebuild RequestMatchingInfo instances
	final Map<Method, T> mappings = new IdentityHashMap<Method, T>();
	final Class<?> userType = ClassUtils.getUserClass(handlerType);
	Set<Method> methods = HandlerMethodSelector.selectMethods(userType, new MethodFilter() {
		public boolean matches(Method method) {
			T mapping = getMappingForMethod(method, userType);
			if (mapping != null) {
				mappings.put(method, mapping);
				return true;
			}
			else {
				return false;
			}
		}
	});
	for (Method method : methods) {
		registerHandlerMethod(handler, method, mappings.get(method));
	}
}

遍历这个handler类的所有方法，过滤条件就是这个内部类MethodFilter，其中的getMappingForMethod方法： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
  /**
 * Uses method and type-level @{@link RequestMapping} annotations to create
 * the RequestMappingInfo.
 * @return the created RequestMappingInfo, or {@code null} if the method
 * does not have a {@code @RequestMapping} annotation.
 * @see #getCustomMethodCondition(Method)
 * @see #getCustomTypeCondition(Class)
 */
@Override
protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
	RequestMappingInfo info = null;
	RequestMapping methodAnnotation = AnnotationUtils.findAnnotation(method, RequestMapping.class);
	if (methodAnnotation != null) {
		RequestCondition<?> methodCondition = getCustomMethodCondition(method);
		info = createRequestMappingInfo(methodAnnotation, methodCondition);
		RequestMapping typeAnnotation = AnnotationUtils.findAnnotation(handlerType, RequestMapping.class);
		if (typeAnnotation != null) {
			RequestCondition<?> typeCondition = getCustomTypeCondition(handlerType);
			info = createRequestMappingInfo(typeAnnotation, typeCondition).combine(info);
		}
	}
	return info;
}

如找到了含有RequestMapping注释的方法，则由这个注释的内容构建一个RequestMappingInfo对象： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
  /**
 * Created a RequestMappingInfo from a RequestMapping annotation.
 */
protected RequestMappingInfo createRequestMappingInfo(RequestMapping annotation, RequestCondition<?> customCondition) {
	String[] patterns = resolveEmbeddedValuesInPatterns(annotation.value());
	return new RequestMappingInfo(
			new PatternsRequestCondition(patterns, getUrlPathHelper(), getPathMatcher(),
					this.useSuffixPatternMatch, this.useTrailingSlashMatch, this.fileExtensions),
			new RequestMethodsRequestCondition(annotation.method()),
			new ParamsRequestCondition(annotation.params()),
			new HeadersRequestCondition(annotation.headers()),
			new ConsumesRequestCondition(annotation.consumes(), annotation.headers()),
			new ProducesRequestCondition(annotation.produces(), annotation.headers(), getContentNegotiationManager()),
			customCondition);
}

就是拿RequestMapping注释的内容进一步封装进RequestMappingInfo对象中。对handler的所有方法过滤完成之后，就要遍历这些方法，以一定的方式存储起来。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
	 * Register a handler method and its unique mapping.
	 * @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) {
		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<String> patterns = getMappingPathPatterns(mapping);
		for (String pattern : patterns) {
			if (!getPathMatcher().isPattern(pattern)) {
				this.urlMap.add(pattern, mapping);
			}
		}
	}

这里的this.handlerMethods就包含了所有管辖的bean，key为RequestMappingInfo对象，value为handler和它中含有@RequestMapping注释的方法method构建的HandlerMethod。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/** 
     * Create the HandlerMethod instance. 
     * @param handler either a bean name or an actual handler instance 
     * @param method the target method 
     * @return the created HandlerMethod 
     */  
    protected HandlerMethod createHandlerMethod(Object handler, Method method) {  
        HandlerMethod handlerMethod;  
        if (handler instanceof String) {  
            String beanName = (String) handler;  
            handlerMethod = new HandlerMethod(beanName, getApplicationContext(), method);  
        }  
        else {  
            handlerMethod = new HandlerMethod(handler, method);  
        }  
        return handlerMethod;  
    }

至此，RequestMappingHandlerMapping的初始化注册工作就完成了。

请求http://localhost:8080/string?name=a`,RequestMappingHandlerMapping`会匹配到由`StringAction`对象和它的包含注释的方法`testMessageConverter`构建的`HandlerMethod`对象，该对象将作为handler，然后再遍历`HandlerAdapter`判断它们是否支持这个handler，`RequestMappingHandlerAdapter`的判断依据为是否是`HandlerMethod` 类型（在AbstractHandlerMethodAdapter类中）： 

1
2
3
4
5
6
7
8
   /**
	 * This implementation expects the handler to be an {@link HandlerMethod}.
	 * @param handler the handler instance to check
	 * @return whether or not this adapter can adapt the given handler
	 */
public final boolean supports(Object handler) {  
        return handler instanceof HandlerMethod && supportsInternal((HandlerMethod) handler);  
    }

然后将得到匹配，有了这个HandlerMethod对象，便可以通过RequestMappingHandlerAdapter来调度执行HandlerMethod其中的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
  ......省略
  	// Determine handler for the current request.
    mappedHandler = getHandler(processedRequest, false);
				if (mappedHandler == null || mappedHandler.getHandler() == null) {
					noHandlerFound(processedRequest, response);
					return;
				}
   // Determine handler adapter for the current request.
   HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
  ......省略
}

mappedHandler包含handle(这里是HandlerMethod)和一些HandlerInterceptor.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
  /**
 * Return the HandlerAdapter for this handler object.
 * @param handler the handler object to find an adapter for
 * @throws ServletException if no HandlerAdapter can be found for the handler. This is a fatal error.
 */
protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
	for (HandlerAdapter ha : this.handlerAdapters) {
		if (logger.isTraceEnabled()) {
			logger.trace("Testing handler adapter [" + ha + "]");
		}
           // 重点。。。。。
		if (ha.supports(handler)) {
			return ha;
		}
	}
	throw new ServletException("No adapter for handler [" + handler +
			"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

热评文章