SpringMVC源码解析- HandlerAdapter初始化

HandlerAdapter初始化时,主要是进行注解解析器初始化注册;返回值处理类初始化;全局注解@ControllerAdvice内容读取并缓存.

目录:

　　注解解析器初始化注册:@ModelAttribute(往model中添加属性)

　　注解解析器初始化注册:@InitBinder(用于注册校验器,参数编辑器等)　　

　　返回值处理returnValueHandlers初始化

　　全局的@ControllerAdvice注解使用类的@ModelAttribute 和 @InitBinder信息读取并缓存

注:具体解析器的分析还是看后续文章吧,要不文章跟裹脚布似的.

注解@ModelAttritue解析器初始化并注册

我们先看下@ModelAttribute注解的使用吧:

　　1. 在注解中定义属性名,方法返回值

　　2. 通过model直接设置

　　3.  暂时没搞定

     // 在注解中定义属性名,方法返回值
     @ModelAttribute("clazzName")
     public String setModel() {
         return this.getClass().getName();
     }
     // 通过model直接设置
     @ModelAttribute
     public void setModel1(Model model){
         model.addAttribute("movie", "who");
     }
     // 暂时没搞定
     @ModelAttribute()
     public String setModel2(){
         return "actor";
     }

新建解析器时的逻辑:

　　1 如果没有配置,直接读取默认实现

　　　　这边默认实现多达24种+自定义实现,主要分为4类解析器:基于注解,基于类型,自定义,号称解析全部

　　2 通过Composite封装,并注册

　　　　解析策略实在太多,这边封装一个HandlerMethodArgumentResolverComposite,迭代解析器委托处理(有点责任链的味道)

先看初始化解析器,并注册的代码:

 package org.springframework.web.servlet.mvc.method.annotation;
 public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter implements BeanFactoryAware,
         InitializingBean {
     public void afterPropertiesSet() {
         if (this.argumentResolvers == null) {
             List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
             this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
         }
         // ...
     }
     private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
         List<HandlerMethodArgumentResolver> resolvers = new ArrayList<HandlerMethodArgumentResolver>();

         // Annotation-based argument resolution 基于注解的解析器
         resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
         resolvers.add(new RequestParamMapMethodArgumentResolver());
         resolvers.add(new PathVariableMethodArgumentResolver());
         resolvers.add(new PathVariableMapMethodArgumentResolver());
         resolvers.add(new MatrixVariableMethodArgumentResolver());
         resolvers.add(new MatrixVariableMapMethodArgumentResolver());
         resolvers.add(new ServletModelAttributeMethodProcessor(false));
         resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters()));
         resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters()));
         resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));
         resolvers.add(new RequestHeaderMapMethodArgumentResolver());
         resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));
         resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));

         // Type-based argument resolution 基于类型的解析器
         resolvers.add(new ServletRequestMethodArgumentResolver());
         resolvers.add(new ServletResponseMethodArgumentResolver());
         resolvers.add(new HttpEntityMethodProcessor(getMessageConverters()));
         resolvers.add(new RedirectAttributesMethodArgumentResolver());
         resolvers.add(new ModelMethodProcessor());
         resolvers.add(new MapMethodProcessor());
         resolvers.add(new ErrorsMethodArgumentResolver());
         resolvers.add(new SessionStatusMethodArgumentResolver());
         resolvers.add(new UriComponentsBuilderMethodArgumentResolver());

         // Custom arguments 自定义解析器
         if (getCustomArgumentResolvers() != null) {
             resolvers.addAll(getCustomArgumentResolvers());
         }

         // Catch-all 全能的解析器
         resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
         resolvers.add(new ServletModelAttributeMethodProcessor(true));

         return resolvers;
     }
 }

然后是HandlerMethodArgumentResolverComposite迭代具体解析器委托处理的代码:

GOF对责任链意图的定义是:

　　使多个对象都有机会iu处理请求,从而避免请求的发送者和接受者直接的耦合关系.将这些对象连成一条链,并沿这条链传递该请求,直到有一个对象处理它为止.

　　从百度百科盗了个类图,来类比下:

上面是标准的责任链,下面是HandlerMethodReturnValueHandler部分类图

 package org.springframework.web.method.support;
 public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgumentResolver {
     public Object resolveArgument(
             MethodParameter parameter, ModelAndViewContainer mavContainer,
             NativeWebRequest webRequest, WebDataBinderFactory binderFactory)
             throws Exception {

         HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
         return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
     }
     public boolean supportsParameter(MethodParameter parameter) {
         return getArgumentResolver(parameter) != null;
     }
     private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
         HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
         if (result == null) {
             for (HandlerMethodArgumentResolver methodArgumentResolver : this.argumentResolvers) {
                 if (methodArgumentResolver.supportsParameter(parameter)) {
                     result = methodArgumentResolver;
                     this.argumentResolverCache.put(parameter, result);
                     break;
                 }
             }
         }
         return result;
     }
     // ...
 }

注解@InitBinder解析器初始化

先看@InitBinder注解的使用吧:

     /**
      * 使用WebDataBinder实现日期校验
      * @param dataBinder
      */
     @InitBinder
     public void dateFormat(WebDataBinder dataBinder){
         SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
         dateFormat.setLenient(false);
         dataBinder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat,false));
     }

这边的代码逻辑其实跟@ModelAttribute解析器初始化的逻辑是一样的,就不具体分析,只是这边初始化使用的解析器是不一样的.至于差异的原因,暂时还不知道,哪位有兴趣可以帮忙科普科普.

 package org.springframework.web.servlet.mvc.method.annotation;
 public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter implements BeanFactoryAware,
         InitializingBean {
     private List<HandlerMethodArgumentResolver> getDefaultInitBinderArgumentResolvers() {
         List<HandlerMethodArgumentResolver> resolvers = new ArrayList<HandlerMethodArgumentResolver>();

         // Annotation-based argument resolution 基于注解的解析器
         resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
         resolvers.add(new RequestParamMapMethodArgumentResolver());
         resolvers.add(new PathVariableMethodArgumentResolver());
         resolvers.add(new PathVariableMapMethodArgumentResolver());
         resolvers.add(new MatrixVariableMethodArgumentResolver());
         resolvers.add(new MatrixVariableMapMethodArgumentResolver());
         resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));

         // Type-based argument resolution 基于类型的解析器
         resolvers.add(new ServletRequestMethodArgumentResolver());
         resolvers.add(new ServletResponseMethodArgumentResolver());

         // Custom arguments 自定义解析器
         if (getCustomArgumentResolvers() != null) {
             resolvers.addAll(getCustomArgumentResolvers());
         }

         // Catch-all 全能的解析器
         resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));

         return resolvers;
     }
     // ...
 }

返回值处理returnValueHandlers初始化

用于将handler处理器的返回值封装成ModelAndView.

这边的处理逻辑跟@ModelAttribute注解解析器的初始化高度雷同,我们还是看看使用的HandlerMethodReturnValueHandler接口

接口的定义方式也是高度雷同,一个api问是否支持,一个api进行具体处理.

 package org.springframework.web.method.support;
 public interface HandlerMethodReturnValueHandler {
     boolean supportsReturnType(MethodParameter returnType);
     void handleReturnValue(Object returnValue,
                            MethodParameter returnType,
                            ModelAndViewContainer mavContainer,
                            NativeWebRequest webRequest) throws Exception;

 }

分类貌似也有一定的相似.

 package org.springframework.web.servlet.mvc.method.annotation;
 public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter implements BeanFactoryAware,
         InitializingBean {
     private List<HandlerMethodReturnValueHandler> getDefaultReturnValueHandlers() {
         List<HandlerMethodReturnValueHandler> handlers = new ArrayList<HandlerMethodReturnValueHandler>();

         // Single-purpose return value types 单一目的
         handlers.add(new ModelAndViewMethodReturnValueHandler());
         handlers.add(new ModelMethodProcessor());
         handlers.add(new ViewMethodReturnValueHandler());
         handlers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.contentNegotiationManager));
         handlers.add(new CallableMethodReturnValueHandler());
         handlers.add(new DeferredResultMethodReturnValueHandler());
         handlers.add(new AsyncTaskMethodReturnValueHandler(this.beanFactory));

         // Annotation-based return value types 基于注解
         handlers.add(new ModelAttributeMethodProcessor(false));
         handlers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.contentNegotiationManager));

         // Multi-purpose return value types 多目的
         handlers.add(new ViewNameMethodReturnValueHandler());
         handlers.add(new MapMethodProcessor());

         // Custom return value types 自定义
         if (getCustomReturnValueHandlers() != null) {
             handlers.addAll(getCustomReturnValueHandlers());
         }

         // Catch-all    又是全能
         if (!CollectionUtils.isEmpty(getModelAndViewResolvers())) {
             handlers.add(new ModelAndViewResolverMethodReturnValueHandler(getModelAndViewResolvers()));
         }
         else {
             handlers.add(new ModelAttributeMethodProcessor(true));
         }

         return handlers;
     }
 }

全局的@ControllerAdvice注解使用类的@ModelAttribute 和 @InitBinder信息读取并缓存

@ControllerAdvice注解主要是为了解决以下的场景问题:

　　如果@ModelAttribute或@InitBinder注解如果需要在很多地方使用,怎么办?

　　使用集成的话,由于java的单继承会限制父类,不够灵活.

使用时只需要如下添加注解就可以

 @ControllerAdvice()
 public class AdviceController {
     // ...
 }

源码解析时,是通过InitializingBean的afterPropertiesSet调用initControllerAdviceCache初始化的解析器.

查找使用注解@ControllerAdivce的类时,通过spring迭代容器过滤容器中全部的类,找到使用ControllerAdvice.class的类并注册.

 package org.springframework.web.servlet.mvc.method.annotation;
 public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter implements BeanFactoryAware,
         InitializingBean {
     public void afterPropertiesSet() {
         // ...
         initControllerAdviceCache();
     }
     private void initControllerAdviceCache() {
         // ...
         // 扫描方式找到使用@ControllerAdvice的类
         List<ControllerAdviceBean> beans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
         Collections.sort(beans, new OrderComparator());

         for (ControllerAdviceBean bean : beans) {
             Set<Method> attrMethods = HandlerMethodSelector.selectMethods(bean.getBeanType(), MODEL_ATTRIBUTE_METHODS);
             if (!attrMethods.isEmpty()) {
                 this.modelAttributeAdviceCache.put(bean, attrMethods);
             }
             Set<Method> binderMethods = HandlerMethodSelector.selectMethods(bean.getBeanType(), INIT_BINDER_METHODS);
             if (!binderMethods.isEmpty()) {
                 this.initBinderAdviceCache.put(bean, binderMethods);
             }
         }
     }
 }

这边扫描获取类的方式跟之前的有所不同,我们可以细看下.

 1 package org.springframework.web.method;
 2 public class ControllerAdviceBean implements Ordered {
 3     /**
 4      * Find the names of beans annotated with
 5      * {@linkplain ControllerAdvice @ControllerAdvice} in the given
 6      * ApplicationContext and wrap them as {@code ControllerAdviceBean} instances.
 7      */
 8     public static List<ControllerAdviceBean> findAnnotatedBeans(ApplicationContext applicationContext) {
 9         List<ControllerAdviceBean> beans = new ArrayList<ControllerAdviceBean>();
10         for (String name : applicationContext.getBeanDefinitionNames()) {
11             if (applicationContext.findAnnotationOnBean(name, ControllerAdvice.class) != null) {
12                 beans.add(new ControllerAdviceBean(name, applicationContext));
13             }
14         }
15         return beans;
16     }
17 }

看下两个api在接口中定义:

　　1. getBeanDefinitionNames 返回容器中定义的全部bean 的 name

　　2. findAnnotationOnBean 查找类上定义的注解,包括父类与接口

 1 package org.springframework.beans.factory;
 2 public interface ListableBeanFactory extends BeanFactory {
 3     // ...
 4     /**
 5      * Return the names of all beans defined in this factory.
 6      * <p>Does not consider any hierarchy this factory may participate in,
 7      * and ignores any singleton beans that have been registered by
 8      * other means than bean definitions.
 9      * @return the names of all beans defined in this factory,
10      * or an empty array if none defined
11      */
12     String[] getBeanDefinitionNames();
13     /**
14      * Find a {@link Annotation} of {@code annotationType} on the specified
15      * bean, traversing its interfaces and super classes if no annotation can be
16      * found on the given class itself.
17      * @param beanName the name of the bean to look for annotations on
18      * @param annotationType the annotation class to look for
19      * @return the annotation of the given type found, or {@code null}
20      */
21     <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType);
22
23 }

顺便关心下@ControllerAdvice信息是如何保存的,就是对应的pojo ControllerAdviceBean:

这边只是记录bean,还没有添加添加根据类,包进行过滤匹配类的功能.

这边值得说的有3个:

　　1. 根据类是否实现Ordered接口,设置排序顺序

　　2. 扫描应用下使用ControllerAdvice注解的类就是上面说的api

　　3. 实现getBeanType获取类的类型 和resolveBean获取类实例 ,这个算是advice的行为吧.作为容器的行为吧.

 1 package org.springframework.web.method;
 2
 3 public class ControllerAdviceBean implements Ordered {
 4     // 使用注解的类
 5     private final Object bean;
 6     private final int order;
 7     private final BeanFactory beanFactory;
 8
 9     public ControllerAdviceBean(String beanName, BeanFactory beanFactory) {
10         // ...
11     }
12
13     public ControllerAdviceBean(Object bean) {
14         // ...
15     }
16
17     // 如果类实现Ordered,根据order的值设置排序
18     private static int initOrderFromBeanType(Class<?> beanType) {
19         Order annot = AnnotationUtils.findAnnotation(beanType, Order.class);
20         return (annot != null) ? annot.value() : Ordered.LOWEST_PRECEDENCE;
21     }
22
23     private static int initOrderFromBean(Object bean) {
24         return (bean instanceof Ordered) ? ((Ordered) bean).getOrder() : initOrderFromBeanType(bean.getClass());
25     }
26
27     /**
28      * 扫描应用下使用ControllerAdvice注解的类
29      */
30     public static List<ControllerAdviceBean> findAnnotatedBeans(ApplicationContext applicationContext) {
31         List<ControllerAdviceBean> beans = new ArrayList<ControllerAdviceBean>();
32         for (String name : applicationContext.getBeanDefinitionNames()) {
33             if (applicationContext.findAnnotationOnBean(name, ControllerAdvice.class) != null) {
34                 beans.add(new ControllerAdviceBean(name, applicationContext));
35             }
36         }
37         return beans;
38     }
39
40     public Class<?> getBeanType() {
41         Class<?> clazz = (this.bean instanceof String)
42                 ? this.beanFactory.getType((String) this.bean) : this.bean.getClass();
43
44         return ClassUtils.getUserClass(clazz);
45     }
46
47     public Object resolveBean() {
48         return (this.bean instanceof String) ? this.beanFactory.getBean((String) this.bean) : this.bean;
49     }
50     // ...
51 }