RequestMappingHandlerMapping ,用于注解@Controller,@RequestMapping来定义controller.
1 @Controller
2 @RequestMapping(value = "books")
3 public class BookController {
4
5 @RequestMapping(value = "/{id}")
6 @ResponseBody
7 public String getBook(@PathVariable("id") String id) {
8 // ...
9 return id;
10 }
11 }
初始化时,3个类的大致分工如下:
AbstractHandlerMethodMapping定义整个算法流程;
RequestMappingInfoHandlerMapping提供匹配条件RequestMappingInfo的解析处理;
RequestMappingHandlerMapping根据@RequestMapping注解生成 RequestMappingInfo,同时提供isHandler实现
整个初始化工作由AbstractHandlerMethodMapping的initHandlerMethods主导.
1. 使用BeanFactoryUtils扫描应用下的Object或者直接从容器中获取Object
2. 迭代类,分别判断isHandler判断目标类是否Handler
2.1 RequestMappingHandlerMapping.isHandler根据@Controller或@RequestMapping注解判断(有任意一个)
3. 对handler解析出所有需要分发的方法detectHandlerMethods
3.1 获取原始的Class<?>
3.2 使用HandlerMethodSelector.selectMethods过滤具体handler method,预留getMappingForMethod模板方法给子类
RequestMappingHandlerMapping.getMappingForMethod根据类,方法上的RequestMapping注解生成匹配条件RequestMappingInfo
3.3 对过滤到的每个method进行注册registerHandlerMethod
a, 使用createHandlerMethod封装处理器为HandlerMethod
b, 判断之前是否已经匹配条件对应的处理器是否冲突(相同的匹配条件只能有一个对应的处理器)
c, 设置匹配条件到handler method的映射关系
d, 从匹配条件中解析出url,并注册到urlMap(url到匹配条件的映射),这边由RequestMappingInfoHandlerMapping.getMappingPathPatterns实现
4. 对HandlerMethod进行初始化handlerMethodsInitialized,其实现在什么都没做
在讲初始化之前,我们先来聊聊使用到的一些概念
1. 映射关系,url到匹配条件RequestMappingInfo,匹配条件到HandlerMethod
2. 特殊的MultiValueMap,特别在value是个List
3. 使用到注解@Controller,@RequestMapping
4. 封装处理器信息的HandlerMethod
5. 封装各类匹配条件的RequestMappingInfo(诸如pattern,http method,request parameter等)
6. RequestCondition记录匹配条件
1. 进行request分发前,需要在初始化时准备好映射关系,这边AbstractHandlerMethodMapping中有两个属性保存了映射关系
// AbstractHandlerMethodMapping
1 // 匹配条件到HandlerMethod的映射 2 private final Map<T, HandlerMethod> handlerMethods = new LinkedHashMap<T, HandlerMethod>(); 3 // url到匹配条件的映射 4 private final MultiValueMap<String, T> urlMap = new LinkedMultiValueMap<String, T>();
2. 这边的MultiValueMap其实挺简单,就是map的值是个list
1 public interface MultiValueMap<K, V> extends Map<K, List<V>> {
2 // ...
3 }
3. 我们再来看看这边使用到的两个注解:
// @Controller
1 // org.springframework.stereotype.Controller
2 @Target({ElementType.TYPE})
3 @Retention(RetentionPolicy.RUNTIME)
4 @Documented
5 @Component
6 public @interface Controller {
7
8 /**
9 * The value may indicate a suggestion for a logical component name,
10 * to be turned into a Spring bean in case of an autodetected component.
11 * @return the suggested component name, if any
12 */
13 String value() default "";
14
15 }
// @RequestMapping
1 // org.springframework.web.bind.annotation.RequestMapping
2 @Target({ElementType.METHOD, ElementType.TYPE})
3 @Retention(RetentionPolicy.RUNTIME)
4 @Documented
5 @Mapping
6 public @interface RequestMapping {
7
8 /**
9 * url路径,如/myPath/*.do
10 */
11 String[] value() default {};
12
13 /**
14 * HTTP request methods 如:GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE.
15 */
16 RequestMethod[] method() default {};
17
18 /**
19 * requeset parameter 有3种匹配方式,是否包含某个参数,参数值相等,参数值不等于某个值,如myParam!=myValue
20 */
21 String[] params() default {};
22
23 /**
24 * request的header
25 */
26 String[] headers() default {};
27
28 /**
29 * request的MediaType
30 */
31 String[] consumes() default {};
32
33 /**
34 * response的MediaType
35 */
36 String[] produces() default {};
37
38 }
39 }
4. HandlerMethod封装了处理器相关的全部信息,如类Object,方法Method,BeanFactory,参数MethodParameter[],原始方法Method
// HandlerMethod
1 // org.springframework.web.method.HandlerMethod 2 private final Object bean;// 因为final不可修改,所以下面每次需要修改信息时,都需要new一个 3 4 private final Method method; 5 6 private final BeanFactory beanFactory; 7 8 private final MethodParameter[] parameters; 9 10 private final Method bridgedMethod;
5. 这边匹配条件的范型只有一个实现,RequestMappingInfo.匹配条件里记录的是RequestCondition子类,用于诸如pattern,http method,request parameter等
// RequestMappingInfo
1 // javax.servlet.http.HttpServletRequest.RequestMappingInfo
2 public final class RequestMappingInfo implements RequestCondition<RequestMappingInfo> {
3
4 private final PatternsRequestCondition patternsCondition;
5
6 private final RequestMethodsRequestCondition methodsCondition;
7
8 private final ParamsRequestCondition paramsCondition;
9
10 private final HeadersRequestCondition headersCondition;
11
12 private final ConsumesRequestCondition consumesCondition;
13
14 private final ProducesRequestCondition producesCondition;
15
16 private final RequestConditionHolder customConditionHolder;
17 // ...
18
19 }
6. 最后再简单看看RequestCondition ,这边定义了3个方法
1 package org.springframework.web.servlet.mvc.condition;
2 public interface RequestCondition<T> {
3 /**
4 * 拼接条件
5 */
6 T combine(T other);
7
8 /**
9 * 查找匹配的条件,并返回
10 */
11 T getMatchingCondition(HttpServletRequest request);
12
13 /**
14 * 用于排序
15 */
16 int compareTo(T other, HttpServletRequest request);
17 }
看看继承体系吧,老套路,定义接口,然后模板方法实现主要逻辑,具体算法留给子类实现,还有正事要做,还是后期再细化吧.
正文
整个初始化工作由AbstractHandlerMethodMapping的initHandlerMethods主导.copy一段,省得回去比对看
1. 使用BeanFactoryUtils扫描应用下的Object或者直接从容器中获取Object
2. 迭代类,分别判断isHandler判断目标类是否Handler
2.1 RequestMappingHandlerMapping.isHandler根据@Controller或@RequestMapping注解判断(有任意一个)
3. 对handler解析出所有需要分发的方法detectHandlerMethods
3.1 获取原始的Class<?>
3.2 使用HandlerMethodSelector.selectMethods过滤具体handler method,预留getMappingForMethod模板方法给子类
RequestMappingHandlerMapping.getMappingForMethod根据类,方法上的RequestMapping注解生成匹配条件RequestMappingInfo
3.3 对过滤到的每个method进行注册registerHandlerMethod
a, 使用createHandlerMethod封装处理器为HandlerMethod
b, 判断之前是否已经匹配条件对应的处理器是否冲突(相同的匹配条件只能有一个对应的处理器)
c, 设置匹配条件到handler method的映射关系
d, 从匹配条件中解析出url,并注册到urlMap(url到匹配条件的映射),这边由RequestMappingInfoHandlerMapping.getMappingPathPatterns实现
4. 对HandlerMethod进行初始化handlerMethodsInitialized,其实现在什么都没做
// AbstractHandlerMethodMapping
1 /** 这个方法哪来的,具体看备注的InitializingBean
2 * Detects handler methods at initialization.
3 */
4 public void afterPropertiesSet() {
5 initHandlerMethods();
6 }
7
8 /**扫描ApplicationContext中的bean,然后筛选handler method 并注册
9 * Scan beans in the ApplicationContext, detect and register handler methods.
10 * @see #isHandler(Class)
11 * @see #getMappingForMethod(Method, Class)
12 * @see #handlerMethodsInitialized(Map)
13 */
14 protected void initHandlerMethods() {
15 if (logger.isDebugEnabled()) {
16 logger.debug("Looking for request mappings in application context: " + getApplicationContext());
17 }
18
19 String[] beanNames = (this.detectHandlerMethodsInAncestorContexts ?
20 BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
21 getApplicationContext().getBeanNamesForType(Object.class));
22
23 for (String beanName : beanNames) {
24 if (isHandler(getApplicationContext().getType(beanName))){
25 detectHandlerMethods(beanName);
26 }
27 }
28 handlerMethodsInitialized(getHandlerMethods());
29 }
预留给子类实现的判断handler,实际是由RequestMappingHandlerMapping实现
// AbstractHandlerMethodMapping
1 /** 2 * Whether the given type is a handler with handler methods. 3 * @param beanType the type of the bean being checked 4 * @return "true" if this a handler type, "false" otherwise. 5 */ 6 protected abstract boolean isHandler(Class<?> beanType);
// RequestMappingHandlerMapping
这边判断的逻辑很简单,类上使用Controller或RequestMapping其中至少一个注解就可以.
1 /**
2 * {@inheritDoc}
3 * Expects a handler to have a type-level @{@link Controller} annotation.
4 */
5 @Override
6 protected boolean isHandler(Class<?> beanType) {
7 return ((AnnotationUtils.findAnnotation(beanType, Controller.class) != null) ||
8 (AnnotationUtils.findAnnotation(beanType, RequestMapping.class) != null));
9 }
// AbstractHandlerMethodMapping
1 /**
2 * Look for handler methods in a handler.
3 * @param handler the bean name of a handler or a handler instance
4 */
5 protected void detectHandlerMethods(final Object handler) {
6 Class<?> handlerType = (handler instanceof String) ?
7 getApplicationContext().getType((String) handler) : handler.getClass();
8
9 final Class<?> userType = ClassUtils.getUserClass(handlerType);
10
11 Set<Method> methods = HandlerMethodSelector.selectMethods(userType, new MethodFilter() {
12 public boolean matches(Method method) {
13 return getMappingForMethod(method, userType) != null;
14 }
15 });
16
17 for (Method method : methods) {
18 T mapping = getMappingForMethod(method, userType);
19 registerHandlerMethod(handler, method, mapping);
20 }
21 }
// AbstractHandlerMethodMapping
这边具体的实现是由RequestMappingHandlerMapping实现,根据注解生产匹配关系,这边实现类是RequestMappingInfo,就是代码有点多,慢慢看
1 /**
2 * Provide the mapping for a handler method. A method for which no
3 * mapping can be provided is not a handler method.
4 * @param method the method to provide a mapping for
5 * @param handlerType the handler type, possibly a sub-type of the method‘s
6 * declaring class
7 * @return the mapping, or {@code null} if the method is not mapped
8 */
9 protected abstract T getMappingForMethod(Method method, Class<?> handlerType);
// RequestMappingHandlerMapping
1 /**
2 * Uses method and type-level @{@link RequestMapping} annotations to create
3 * the RequestMappingInfo.
4 *
5 * @return the created RequestMappingInfo, or {@code null} if the method
6 * does not have a {@code @RequestMapping} annotation.
7 *
8 * @see #getCustomMethodCondition(Method)
9 * @see #getCustomTypeCondition(Class)
10 */
11 @Override
12 protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
13 RequestMappingInfo info = null;
14 // 读取方法上的RequestMapping注解信息
15 RequestMapping methodAnnotation = AnnotationUtils.findAnnotation(method, RequestMapping.class);
16 if (methodAnnotation != null) {
17 // 读取自定义的条件,这边没有使用
18 RequestCondition<?> methodCondition = getCustomMethodCondition(method);
19 // 根据方法上的RequsetMapping注解和自定义条件,生成匹配条件.这边的匹配条件包括http method,request parameter,request header等
20 info = createRequestMappingInfo(methodAnnotation, methodCondition);
21 // 读取类上的RequestMapping注解信息
22 RequestMapping typeAnnotation = AnnotationUtils.findAnnotation(handlerType, RequestMapping.class);
23 if (typeAnnotation != null) {
24 RequestCondition<?> typeCondition = getCustomTypeCondition(handlerType);
25 // 生成类上的匹配条件,并合并方法上的
26 info = createRequestMappingInfo(typeAnnotation, typeCondition).combine(info);
27 }
28 }
29 return info;
30 }
// RequestMappingHandlerMapping
1 /**
2 * Created a RequestMappingInfo from a RequestMapping annotation.
3 */
4 private RequestMappingInfo createRequestMappingInfo(RequestMapping annotation, RequestCondition<?> customCondition) {
5 String[] patterns = resolveEmbeddedValuesInPatterns(annotation.value());
6 return new RequestMappingInfo(
7 new PatternsRequestCondition(patterns, getUrlPathHelper(), getPathMatcher(),
8 this.useSuffixPatternMatch, this.useTrailingSlashMatch, this.fileExtensions),
9 new RequestMethodsRequestCondition(annotation.method()),
10 new ParamsRequestCondition(annotation.params()),
11 new HeadersRequestCondition(annotation.headers()),
12 new ConsumesRequestCondition(annotation.consumes(), annotation.headers()),
13 new ProducesRequestCondition(annotation.produces(), annotation.headers(), getContentNegotiationManager()),
14 customCondition);
15 }
16
17 /**
18 * Resolve placeholder values in the given array of patterns.
19 * @return a new array with updated patterns
20 */
21 protected String[] resolveEmbeddedValuesInPatterns(String[] patterns) {
22 if (this.embeddedValueResolver == null) {
23 return patterns;
24 }
25 else {
26 String[] resolvedPatterns = new String[patterns.length];
27 for (int i=0; i < patterns.length; i++) {
28 resolvedPatterns[i] = this.embeddedValueResolver.resolveStringValue(patterns[i]);
29 }
30 return resolvedPatterns;
31 }
32 }
// AbstractHandlerMethodMapping
1 /**
2 * Register a handler method and its unique mapping.
3 * @param handler the bean name of the handler or the handler instance
4 * @param method the method to register
5 * @param mapping the mapping conditions associated with the handler method
6 * @throws IllegalStateException if another method was already registered
7 * under the same mapping
8 */
9 protected void registerHandlerMethod(Object handler, Method method, T mapping) {
10 HandlerMethod newHandlerMethod = createHandlerMethod(handler, method);
11 HandlerMethod oldHandlerMethod = handlerMethods.get(mapping);
12 if (oldHandlerMethod != null && !oldHandlerMethod.equals(newHandlerMethod)) {
13 throw new IllegalStateException("Ambiguous mapping found. Cannot map ‘" + newHandlerMethod.getBean()
14 + "‘ bean method \n" + newHandlerMethod + "\nto " + mapping + ": There is already ‘"
15 + oldHandlerMethod.getBean() + "‘ bean method\n" + oldHandlerMethod + " mapped.");
16 }
17
18 this.handlerMethods.put(mapping, newHandlerMethod);// 匹配条件requestMappingInfo 到处理器HandlerMethod
19 if (logger.isInfoEnabled()) {
20 logger.info("Mapped \"" + mapping + "\" onto " + newHandlerMethod);
21 }
22
23 Set<String> patterns = getMappingPathPatterns(mapping);
24 for (String pattern : patterns) {
25 if (!getPathMatcher().isPattern(pattern)) {
26 this.urlMap.add(pattern, mapping);// url到匹配条件RequestMappingInfo
27 }
28 }
29 }
// AbstractHandlerMethodMapping
1 /**
2 * Create the HandlerMethod instance.
3 * @param handler either a bean name or an actual handler instance
4 * @param method the target method
5 * @return the created HandlerMethod
6 */
7 protected HandlerMethod createHandlerMethod(Object handler, Method method) {
8 HandlerMethod handlerMethod;
9 if (handler instanceof String) {
10 String beanName = (String) handler;
11 handlerMethod = new HandlerMethod(beanName, getApplicationContext(), method);
12 }
13 else {
14 handlerMethod = new HandlerMethod(handler, method);
15 }
16 return handlerMethod;
17 }
// AbstractHandlerMethodMapping
1 /** 2 * Extract and return the URL paths contained in a mapping. 3 */ 4 protected abstract Set<String> getMappingPathPatterns(T mapping);
RequestMappingInfoHandlerMapping会实现这个模板方法
// RequestMappingInfoHandlerMapping
1 /**
2 * Get the URL path patterns associated with this {@link RequestMappingInfo}.
3 */
4 @Override
5 protected Set<String> getMappingPathPatterns(RequestMappingInfo info) {
6 return info.getPatternsCondition().getPatterns();
7 }
备注:
1. 这边的afterPropertiesSet是因为实现了InitializingBean接口
// org.springframework.beans.factory.InitializingBean
1 /**
2 * Interface to be implemented by beans that need to react once all their
3 * properties have been set by a BeanFactory: for example, to perform custom
4 * initialization, or merely to check that all mandatory properties have been set.
5 *
6 * <p>An alternative to implementing InitializingBean is specifying a custom
7 * init-method, for example in an XML bean definition.
8 * For a list of all bean lifecycle methods, see the BeanFactory javadocs.
9 *
10 * @author Rod Johnson
11 * @see BeanNameAware
12 * @see BeanFactoryAware
13 * @see BeanFactory
14 * @see org.springframework.beans.factory.support.RootBeanDefinition#getInitMethodName
15 * @see org.springframework.context.ApplicationContextAware
16 */
17 public interface InitializingBean {
18
19 /**
20 * Invoked by a BeanFactory after it has set all bean properties supplied
21 * (and satisfied BeanFactoryAware and ApplicationContextAware).
22 * <p>This method allows the bean instance to perform initialization only
23 * possible when all bean properties have been set and to throw an
24 * exception in the event of misconfiguration.
25 * @throws Exception in the event of misconfiguration (such
26 * as failure to set an essential property) or if initialization fails.
27 */
28 void afterPropertiesSet() throws Exception;
29
30 }