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) { 18                 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 }