SpringMVC源码分析----HandlerAdapter

你的名字 2022-05-16 09:37 215阅读 0赞

***HandlerAdapter的结构图：***

![70][]

如上所示：总共五个实现类，有一个还被摒弃了，除了RequestMappingHandlerAdapter适配器，其他都很简单，只需要调用各自的方法就可以了。HttpReqeustHandlerAdapter、SimpleServletHandlerAdapter和SimpleControllerHandlerAdapter分别适配HttpRequestHandler、Servlet和Controller类型的Handler。方法很简单，源码举例一个其他类似。如下：

public class SimpleControllerHandlerAdapter implements HandlerAdapter {
        public SimpleControllerHandlerAdapter() {
        }
    
        public boolean supports(Object handler) {
            return handler instanceof Controller;
        }
    
        @Nullable
        public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            return ((Controller)handler).handleRequest(request, response);
        }
    
        public long getLastModified(HttpServletRequest request, Object handler) {
            return handler instanceof LastModified ? ((LastModified)handler).getLastModified(request) : -1L;
        }
    }

## 一、RequestMappingHandlerAdapter概述 ##

主要分析RequestMappingAdapter类，RequestMappingAdapter继承AbstractHandlerMethodAdapter，后者分别调用三个模板方法由子类实现，其中supportsInternal还多加了一个判断Handler是否是HandlerMethod类型。源码：

public abstract class AbstractHandlerMethodAdapter extends WebContentGenerator implements HandlerAdapter, Ordered {
        private int order = 2147483647;
    
        public AbstractHandlerMethodAdapter() {
            super(false);
        }
    
        public void setOrder(int order) {
            this.order = order;
        }
    
        public int getOrder() {
            return this.order;
        }
    
        public final boolean supports(Object handler) {
                //这里多加了是否是HandlerMethod方法，其他都使用模板方法
            return handler instanceof HandlerMethod && this.supportsInternal((HandlerMethod)handler); 
        }
    
        protected abstract boolean supportsInternal(HandlerMethod var1);
    
        @Nullable
        public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            return this.handleInternal(request, response, (HandlerMethod)handler);
        }
    
        @Nullable
        protected abstract ModelAndView handleInternal(HttpServletRequest var1, HttpServletResponse var2, HandlerMethod var3) throws Exception;
    
        public final long getLastModified(HttpServletRequest request, Object handler) {
            return this.getLastModifiedInternal(request, (HandlerMethod)handler);
        }
    
        protected abstract long getLastModifiedInternal(HttpServletRequest var1, HandlerMethod var2);
    }

接下来就看RequestMappingHandlerAdapter，这个可以说是SpringMVC中最复杂的组件它的supportsInternal直接返回true，只需要满足父类中的HandlerMethod类型的要求就可以了。getLastModifiedInternal直接返回-1；最重要的就是handlerInternal方法了，就是这个方法实际使用Handler处理请求。具体步骤有如下三步：

*  ***备好处理器所需要的参数（这个最难，参数的不确定性）***
 *  ***使用处理器处理请求  （这个比较简单，直接用反射调用handleMethod处理就可以了）***
 *  ***处理返回值，也就是将不同类型的返回值统一处理成ModelAndView类***

## **1.备好处理器所需要的参数** ##

**      1.1.备好参数需要考虑的问题：**

*  *1）都有哪些参数需要绑定？*

解答：除了方法确定的参数，还有两个方法的参数需要绑定，那就是当前处理器相对应注释了@ModelAttribute和注释了@InitBinder的方法

*  *2）参数的值的来源？*

解答：有六个参数的来源：

request中相关的参数，主要包括url中的参数、post中过来的参数，以及请求头包含的值；

cookie中的参数

session中给的参数

设置到FlashMap中的参数，这种参数用于redirect的参数传递

SessionAttribute传递的参数，这类参数通过@SessionAttribute注释传递

通过相应的注释了@ModelAttribute的方法设置的参数

*  *3）具体进行绑定的方法？*

**  1.2 参数具体的解析**

参数解析使用HandlerMethodArgumentResolver类型的组件完成的，不同类型的使用不同的ArgumentResolver来解析。有的Resolver内部使用了WebDataBinder，可以通过注释了@InitBinder的方法来初始化，注释了@InitBinder的方法也需要绑定参数，而且也是不确定的，所以@InitBinder注释的方法也需要ArgumentResolver来解析参数，使用的和Handler不同的一套ArgumentResolver，另外注释了ModelAttribute的方法也需要绑定参数，使用的和Handler使用的是同一套ArgumentResolver。

## 二、RequestMappingHandlerAdapter之器 ##

主要是在方法afterProperties中，RequestMappingAdapter实现了InitializaingBean接口，所以在初始化这个bean时，会调用这个方法，这个方法主要初始化了argumentResolver,initBinderArgumentResolvers,returnVAlueHandlers以及@ControllerAdvice注释的类相关的modelAttributeAdviceCache、initBinderAdviceCache和responseBodyAdvice这六个属性。

知识集锦：

*  argumentResolvers：用于处理器方法和注释了@ModelAttribute的方法设置参数
 *  initBinderArgumentResolvers：用于给注释了@initBinder的方法设置参数
 *  returnValueHandlers:用于将处理器的返回值处理为ModelAndView的类型
 *  modelAttributeAdviceCache和initBinderAdviceCache：分别用于缓存@ControllerAdvice注释的类里面注释了@ModelAttribute和@InitBinder方法，也就是全局的@ModelAttribute和InitBinder方法。
 *  requestResponseBodyAdvice:用来保存前面介绍过的实现了RequestBodyAdvice和ResponseBodyAdvice接口，可以修改接受到参数的类和返回的ResponseBody的类。

源码分析：

public void afterPropertiesSet() {
            //初始化注释了@ControllerAdvice的类的三个属性
            this.initControllerAdviceCache();
            List handlers;
            if (this.argumentResolvers == null) {
                //初始化argumentResolvers 
                handlers = this.getDefaultArgumentResolvers();
                this.argumentResolvers = (new HandlerMethodArgumentResolverComposite()).addResolvers(handlers);
            }
    
            if (this.initBinderArgumentResolvers == null) {
                //初始化initBinderArgumentResolvers 
                handlers = this.getDefaultInitBinderArgumentResolvers();
                this.initBinderArgumentResolvers = (new HandlerMethodArgumentResolverComposite()).addResolvers(handlers);
            }
    
            if (this.returnValueHandlers == null) {
                 //初始化returnValueHandlers 
                handlers = this.getDefaultReturnValueHandlers();
                this.returnValueHandlers = (new HandlerMethodReturnValueHandlerComposite()).addHandlers(handlers);
            }
    
        }
        
        //获取注释了@ControllerAdvice全局的属性
        private void initControllerAdviceCache() {
            if (this.getApplicationContext() != null) {
                if (this.logger.isInfoEnabled()) {
                    this.logger.info("Looking for @ControllerAdvice: " + this.getApplicationContext());
                }
                //获取到所有注释了@ControllerAdvice的bean
                List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(this.getApplicationContext());
                //根据order排序
                AnnotationAwareOrderComparator.sort(adviceBeans);
                List<Object> requestResponseBodyAdviceBeans = new ArrayList();
                Iterator var3 = adviceBeans.iterator();
    
                while(var3.hasNext()) {
                    ControllerAdviceBean adviceBean = (ControllerAdviceBean)var3.next();
                    Class<?> beanType = adviceBean.getBeanType();
                    if (beanType == null) {
                        throw new IllegalStateException("Unresolvable type for ControllerAdviceBean: " + adviceBean);
                    }
                    //查找注释了@ModelAttribute而且没有注释@RequestMapping的方法
                    Set<Method> attrMethods = MethodIntrospector.selectMethods(beanType, MODEL_ATTRIBUTE_METHODS);
                    if (!attrMethods.isEmpty()) {
                        this.modelAttributeAdviceCache.put(adviceBean, attrMethods);
                        if (this.logger.isInfoEnabled()) {
                            this.logger.info("Detected @ModelAttribute methods in " + adviceBean);
                        }
                    }
                    //查找注释了@InitBinder的方法
                    Set<Method> binderMethods = MethodIntrospector.selectMethods(beanType, INIT_BINDER_METHODS);
                    if (!binderMethods.isEmpty()) {
                        this.initBinderAdviceCache.put(adviceBean, binderMethods);
                        if (this.logger.isInfoEnabled()) {
                            this.logger.info("Detected @InitBinder methods in " + adviceBean);
                        }
                    }
                    //查找实现了RequestBodyAdvice接口的类
                    if (RequestBodyAdvice.class.isAssignableFrom(beanType)) {
                        requestResponseBodyAdviceBeans.add(adviceBean);
                        if (this.logger.isInfoEnabled()) {
                            this.logger.info("Detected RequestBodyAdvice bean in " + adviceBean);
                        }
                    }
                    //查找实现了ResponseBodyAdvice接口的类
                    if (ResponseBodyAdvice.class.isAssignableFrom(beanType)) {
                        requestResponseBodyAdviceBeans.add(adviceBean);
                        if (this.logger.isInfoEnabled()) {
                            this.logger.info("Detected ResponseBodyAdvice bean in " + adviceBean);
                        }
                    }
                }
                //将查找的RequestBodyAdvice和ResponseBodyAdvice接口的类添加到requestResponseBodyAdvice属性中    
                if (!requestResponseBodyAdviceBeans.isEmpty()) {
                    this.requestResponseBodyAdvice.addAll(0, requestResponseBodyAdviceBeans);
                }
    
            }
        }

另外有三个getDefaultXXX方法，在和我三个方法都是十分相似的，看一个即可，如getDEfaultArgumentResolver，这个是用来设置ArgumentResolver属性，这是一个非常核心的属性。

源码：

private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
            List<HandlerMethodArgumentResolver> resolvers = new ArrayList();
    
            //添加按注释解析参数的解析器，例如@RequestParam，@PathVariable等
            resolvers.add(new RequestParamMethodArgumentResolver(this.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(this.getMessageConverters(), this.requestResponseBodyAdvice));
            resolvers.add(new RequestPartMethodArgumentResolver(this.getMessageConverters(), this.requestResponseBodyAdvice));
            resolvers.add(new RequestHeaderMethodArgumentResolver(this.getBeanFactory()));
            resolvers.add(new RequestHeaderMapMethodArgumentResolver());
            resolvers.add(new ServletCookieValueMethodArgumentResolver(this.getBeanFactory()));
            resolvers.add(new ExpressionValueMethodArgumentResolver(this.getBeanFactory()));
    
            添加按类型解析的解析器
            resolvers.add(new SessionAttributeMethodArgumentResolver());
            resolvers.add(new RequestAttributeMethodArgumentResolver());
            resolvers.add(new ServletRequestMethodArgumentResolver());
            resolvers.add(new ServletResponseMethodArgumentResolver());
            resolvers.add(new HttpEntityMethodProcessor(this.getMessageConverters(), this.requestResponseBodyAdvice));
            resolvers.add(new RedirectAttributesMethodArgumentResolver());
            resolvers.add(new ModelMethodProcessor());
            resolvers.add(new MapMethodProcessor());
            resolvers.add(new ErrorsMethodArgumentResolver());
            resolvers.add(new SessionStatusMethodArgumentResolver());
            resolvers.add(new UriComponentsBuilderMethodArgumentResolver());
    
            //添加自定义参数解析器，主要用于解析自定义的类型，这个一般都用不上
            if (this.getCustomArgumentResolvers() != null) {
                resolvers.addAll(this.getCustomArgumentResolvers());
            }
            
            //这两个解析器可以解析所有类型的参数
            resolvers.add(new RequestParamMethodArgumentResolver(this.getBeanFactory(), true));
            resolvers.add(new ServletModelAttributeMethodProcessor(true));
            return resolvers;
        }

## 二、RequestMappingHandlerAdapter之用 ##

RequestMappingHandlerAdapter的入口方法是handlerInternal，源码如下：

protected ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse 
        response, HandlerMethod handlerMethod) throws Exception {
            this.checkRequest(request);
            ModelAndView mav;
            if (this.synchronizeOnSession) {
                HttpSession session = request.getSession(false);
                if (session != null) {
                    Object mutex = WebUtils.getSessionMutex(session);
                    synchronized(mutex) {
                        mav = this.invokeHandlerMethod(request, response, handlerMethod);
                    }
                } else {
                    mav = this.invokeHandlerMethod(request, response, handlerMethod);
                }
            } else {
                mav = this.invokeHandlerMethod(request, response, handlerMethod);
            }
    
            if (!response.containsHeader("Cache-Control")) {
                //判断是否有@SessionAttribute注释的参数
                if (this.getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
                    this.applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
                } else {
                    this.prepareResponse(response);
                }
            }
    
            return mav;
        }

上面主要是invokeHandlerMethod方法和applyCacheSeconds，prepareResponse方法，

invokeHandlerMethod方法首先通过request和Response创建了ServletWebRequest类型的webRequest，在ArgumentResolver解析参数时使用的是webRequest。接着对WebDataBinderFactory、ModelFactory、ServletInvocableHandlerMethod这三个类的变量进行定义和初始化。源码：

protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
            ServletWebRequest webRequest = new ServletWebRequest(request, response);
    
            Object result;
            try {
                WebDataBinderFactory binderFactory = this.getDataBinderFactory(handlerMethod);
                ModelFactory modelFactory = this.getModelFactory(handlerMethod, binderFactory);
                ServletInvocableHandlerMethod invocableMethod = this.createInvocableHandlerMethod(handlerMethod);
                if (this.argumentResolvers != null) {
                    invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
                }
    
                if (this.returnValueHandlers != null) {
                    invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
                }
    
                invocableMethod.setDataBinderFactory(binderFactory);
                invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
                ModelAndViewContainer mavContainer = new ModelAndViewContainer();
                mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
                modelFactory.initModel(webRequest, mavContainer, invocableMethod);
                mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
                AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
                asyncWebRequest.setTimeout(this.asyncRequestTimeout);
                WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
                asyncManager.setTaskExecutor(this.taskExecutor);
                asyncManager.setAsyncWebRequest(asyncWebRequest);
                asyncManager.registerCallableInterceptors(this.callableInterceptors);
                asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);
                if (asyncManager.hasConcurrentResult()) {
                    result = asyncManager.getConcurrentResult();
                    mavContainer = (ModelAndViewContainer)asyncManager.getConcurrentResultContext()[0];
                    asyncManager.clearConcurrentResult();
                    if (this.logger.isDebugEnabled()) {
                        this.logger.debug("Found concurrent result value [" + result + "]");
                    }
    
                    invocableMethod = invocableMethod.wrapConcurrentResult(result);
                }
    
                invocableMethod.invokeAndHandle(webRequest, mavContainer, new Object[0]);
                if (!asyncManager.isConcurrentHandlingStarted()) {
                    ModelAndView var15 = this.getModelAndView(mavContainer, modelFactory, webRequest);
                    return var15;
                }
    
                result = null;
            } finally {
                webRequest.requestCompleted();
            }
    
            return (ModelAndView)result;
        }

知识集锦：

**WebDataBinderFactory**：用来创建WebDataBinder------用于参数绑定，主要功能是实现参数跟String之间的类型转换，ArgumentResolver在进行参数解析过程中会用到WebDataBinder，另外ModelFactory更新Model时也会用到它。WebDataBinderFactory的创建过程就是讲符合条件的注释了@InitBinder的方法找出来，并使用他们新建出ServletRequestDataBinderFactory类型的WebDataBinderFactory。这里的InitBinder包含在@ControllerAdvice中和处理器自己包含的两种情况。

**ModelFactory：用来处理Model的，主要包含两个功能：**

在处理器具体处理器之前对Model进行初始化（将原来的SEssionAttributes中的值设置到Model；执行相应注释了@ModelAttribute的方法并设置到Model中；处理器注释了@ModelAttribute的参数如果同时在SessionAttributes中也配置了，而且mavContainer中还没有值，则ongoing全部SessionAttribute中查找并设置进去）；

在处理完请求后对Model参数进行更新（先对SessionAttributes进行设置，设置跪着是如果处理器调用了SessionStatus\#setComplete浙江SessionAttribute清空）

**ServletInvocableHandlerMethod：它**继承HandlerMethod，并且可以直接执行，实际的请求就是通过它来处理的，参数绑定、处理请求以及返回值处理都是在它里面完成的。

[70]: /images/20220516/65484bfe02564e33b6102c0a7f56175d.png