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 }