说在前面
前期回顾
sharding-jdbc源码解析 更新完毕
spring源码解析 更新完毕
spring-mvc源码解析 更新完毕
spring-tx源码解析 更新完毕
spring-boot源码解析 更新完毕
rocketmq源码解析 更新完毕
dubbbo源码解析 更新完毕
netty源码解析 更新完毕
spring源码架构更新完毕
springmvc源码架构更新中
springboot源码架构计划中
github https://github.com/tianheframe
sharding-jdbc源码解析 更新完毕
rocketmq源码解析 更新完毕
seata 源码解析 更新完毕
dubbo 源码解析 更新完毕
netty 源码解析 更新完毕
源码解析
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter AbstractHandlerMethodAdapter，它支持HandlerMethods及其方法参数和返回类型签名(通过@RequestMapping定义)。可以通过setCustomArgumentResolvers和setCustomReturnValueHandlers添加对定制参数和返回值类型的支持。或者，要重新配置所有参数和返回值类型，可以使用setArgumentResolvers和setReturnValueHandlers。
实现了org.springframework.beans.factory.BeanFactoryAware、org.springframework.beans.factory.InitializingBean接口。
public static final MethodFilter INIT_BINDER_METHODS = new MethodFilter() { @Override public boolean matches(Method method) { return (AnnotationUtils.findAnnotation(method, InitBinder.class) != null); } };方法过滤器匹配@InitBinder方法。
public static final MethodFilter MODEL_ATTRIBUTE_METHODS = new MethodFilter() { @Override public boolean matches(Method method) { return (AnnotationUtils.findAnnotation(method, RequestMapping.class) == null && AnnotationUtils.findAnnotation(method, ModelAttribute.class) != null); } };方法过滤器匹配@ModelAttribute方法。
private List customArgumentResolvers;customArgumentResolvers
private HandlerMethodArgumentResolverComposite argumentResolvers;argumentResolvers
private HandlerMethodArgumentResolverComposite initBinderArgumentResolvers;initBinderArgumentResolvers
private List customReturnValueHandlers;customReturnValueHandlers
private HandlerMethodReturnValueHandlerComposite returnValueHandlers;returnValueHandlers
private List modelAndViewResolvers;modelAndViewResolvers
private List>> messageConverters;messageConverters
private List<Object> requestResponseBodyAdvice = new ArrayList<Object>();requestResponseBodyAdvice
private AsyncTaskExecutor taskExecutor = new SimpleAsyncTaskExecutor("MvcAsync");taskExecutor
private Long asyncRequestTimeout;asyncRequestTimeout
private CallableProcessingInterceptor[] callableInterceptors = new CallableProcessingInterceptor[0];callableInterceptors
private DeferredResultProcessingInterceptor[] deferredResultInterceptors = new DeferredResultProcessingInterceptor[0];deferredResultInterceptors
private ConfigurableBeanFactory beanFactory;beanFactory
public RequestMappingHandlerAdapter() {// 创建StringHttpMessageConverter StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter(); stringHttpMessageConverter.setWriteAcceptCharset(false); // see SPR-7316// 添加转换器 this.messageConverters = new ArrayList>(4); this.messageConverters.add(new ByteArrayHttpMessageConverter()); this.messageConverters.add(stringHttpMessageConverter); this.messageConverters.add(new SourceHttpMessageConverter());// 添加xml和json转换器 -》 this.messageConverters.add(new AllEncompassingFormHttpMessageConverter()); }添加xml和json转换器，org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter#AllEncompassingFormHttpMessageConverter
public AllEncompassingFormHttpMessageConverter() {// 添加默认xml和json真支持转换器 addPartConverter(new SourceHttpMessageConverter()); if (jaxb2Present && !jackson2XmlPresent) { addPartConverter(new Jaxb2RootElementHttpMessageConverter()); } if (jackson2Present) { addPartConverter(new MappingJackson2HttpMessageConverter()); } else if (gsonPresent) { addPartConverter(new GsonHttpMessageConverter()); } if (jackson2XmlPresent) { addPartConverter(new MappingJackson2XmlHttpMessageConverter()); } }@Override public void setBeanFactory(BeanFactory beanFactory) { if (beanFactory instanceof ConfigurableBeanFactory) { this.beanFactory = (ConfigurableBeanFactory) beanFactory; } }重写了org.springframework.beans.factory.BeanFactoryAware#setBeanFactory方法，设置ConfigurableBeanFactory
@Override public void afterPropertiesSet() { // Do this first, it may add ResponseBody advice beans 初始化ControllerAdvice缓存-》 initControllerAdviceCache(); if (this.argumentResolvers == null) {// 获取默认的方法参数解析器 -》 List resolvers = getDefaultArgumentResolvers(); this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers); } if (this.initBinderArgumentResolvers == null) {// 获取默认的@InitBinder参数绑定解析器 -》 List resolvers = getDefaultInitBinderArgumentResolvers(); this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers); } if (this.returnValueHandlers == null) {// 解析默认的返回值handler -》 List handlers = getDefaultReturnValueHandlers(); this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers); } }重写了org.springframework.beans.factory.InitializingBean#afterPropertiesSet方法，初始化ControllerAdvice缓存，获取默认的方法参数解析器，获取默认的@InitBinder参数绑定解析器，解析默认的返回值handler
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#initControllerAdviceCache 初始化ControllerAdvice缓存
private void initControllerAdviceCache() { if (getApplicationContext() == null) { return; } if (logger.isInfoEnabled()) { logger.info("Looking for @ControllerAdvice: " + getApplicationContext()); }// 从beanFactory中获取参数@ControllerAdvice的controller List beans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext()); AnnotationAwareOrderComparator.sort(beans); List requestResponseBodyAdviceBeans = new ArrayList(); for (ControllerAdviceBean bean : beans) {// 从controller中获取有@RequestMapping、@ModelAttribute注解的方法 Set attrMethods = MethodIntrospector.selectMethods(bean.getBeanType(), MODEL_ATTRIBUTE_METHODS); if (!attrMethods.isEmpty()) { this.modelAttributeAdviceCache.put(bean, attrMethods); if (logger.isInfoEnabled()) { logger.info("Detected @ModelAttribute methods in " + bean); } }// 查找controller中有@InitBinder注解的方法 Set binderMethods = MethodIntrospector.selectMethods(bean.getBeanType(), INIT_BINDER_METHODS); if (!binderMethods.isEmpty()) { this.initBinderAdviceCache.put(bean, binderMethods); if (logger.isInfoEnabled()) { logger.info("Detected @InitBinder methods in " + bean); } } if (RequestBodyAdvice.class.isAssignableFrom(bean.getBeanType())) { requestResponseBodyAdviceBeans.add(bean); if (logger.isInfoEnabled()) { logger.info("Detected RequestBodyAdvice bean in " + bean); } } if (ResponseBodyAdvice.class.isAssignableFrom(bean.getBeanType())) { requestResponseBodyAdviceBeans.add(bean); if (logger.isInfoEnabled()) { logger.info("Detected ResponseBodyAdvice bean in " + bean); } } } if (!requestResponseBodyAdviceBeans.isEmpty()) { this.requestResponseBodyAdvice.addAll(0, requestResponseBodyAdviceBeans); } }org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#getDefaultArgumentResolvers 返回要使用的参数解析器列表，包括内置解析器和通过setCustomArgumentResolvers提供的自定义解析器。
private ListgetDefaultArgumentResolvers() { List resolvers = new ArrayList(); // Annotation-based argument resolution// 基于@RequestParam的参数解析器 resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));// 基于@RequestParam map参数解析器 resolvers.add(new RequestParamMapMethodArgumentResolver());// 基于@PathVariable的参数解析器 resolvers.add(new PathVariableMethodArgumentResolver());// 基于@PathVariable map的参数解析器 resolvers.add(new PathVariableMapMethodArgumentResolver());// 基于@MatrixVariable 矩阵参数解析器 resolvers.add(new MatrixVariableMethodArgumentResolver());// 基于@MatrixVariable 矩阵map参数解析器 resolvers.add(new MatrixVariableMapMethodArgumentResolver());// 基于从model解析参数的参数解析器 resolvers.add(new ServletModelAttributeMethodProcessor(false));// 基于@RequestBody、@ResponseBody的参数解析器 resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));// 基于@RequestParam 参数解析器 resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters(), this.requestResponseBodyAdvice));// 基于@RequestHeader 参数解析器 resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));// 基于@RequestHeader map参数解析器 resolvers.add(new RequestHeaderMapMethodArgumentResolver());// 基于从cookie中解析参数的参数解析器 resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));// 基于@Value 表达式参数解析器 resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));// 基于@SessionAttribute 参数解析器 resolvers.add(new SessionAttributeMethodArgumentResolver());// 基于@RequestAttribute 参数解析器 resolvers.add(new RequestAttributeMethodArgumentResolver()); // Type-based argument resolution// 基于servletRequest的参数解析器 resolvers.add(new ServletRequestMethodArgumentResolver());// 基于servletResponse的参数解析器 resolvers.add(new ServletResponseMethodArgumentResolver());// 基于httpEntity参数解析器 resolvers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));// 基于重定向参数绑定解析器 resolvers.add(new RedirectAttributesMethodArgumentResolver());// 基于从model中解析参数的参数解析器 resolvers.add(new ModelMethodProcessor());// 基于map的参数解析器 resolvers.add(new MapMethodProcessor());// 错误方法参数解析器 resolvers.add(new ErrorsMethodArgumentResolver());// 基于session状态方法参数解析器 resolvers.add(new SessionStatusMethodArgumentResolver());// 基于url参数解析器 resolvers.add(new UriComponentsBuilderMethodArgumentResolver()); // Custom arguments 自定义参数解析器 if (getCustomArgumentResolvers() != null) { resolvers.addAll(getCustomArgumentResolvers()); } // Catch-all// 基于@RequestParam参数解析器，用默认值 resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));// 基于servlet model中解析参数的参数解析器，使用默认值 resolvers.add(new ServletModelAttributeMethodProcessor(true)); return resolvers; }org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#getDefaultInitBinderArgumentResolvers 返回用于@InitBinder方法(包括内置和自定义解析器)的参数解析器列表。
private ListgetDefaultInitBinderArgumentResolvers() { List resolvers = new ArrayList(); // Annotation-based argument resolution// 基于@RequestParam的参数解析器 resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));// 基于@RequestParam map的参数解析器 resolvers.add(new RequestParamMapMethodArgumentResolver());// 基于@PathVariable 的参数解析器 resolvers.add(new PathVariableMethodArgumentResolver());// 基于@PathVariable map的参数解析器 resolvers.add(new PathVariableMapMethodArgumentResolver());// 基于@MatrixVariable 矩阵参数解析器 resolvers.add(new MatrixVariableMethodArgumentResolver());// 基于@MatrixVariable map矩阵参数解析器 resolvers.add(new MatrixVariableMapMethodArgumentResolver());// 基于@Value 表达式参数解析器 resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));// 基于@SessionAttribute参数解析器 resolvers.add(new SessionAttributeMethodArgumentResolver());// 基于@RequestAttribute 参数解析器 resolvers.add(new RequestAttributeMethodArgumentResolver()); // Type-based argument resolution// 基于servletRequest参数解析器 resolvers.add(new ServletRequestMethodArgumentResolver());// 基于servletResponse参数解析器 resolvers.add(new ServletResponseMethodArgumentResolver()); // Custom arguments if (getCustomArgumentResolvers() != null) { resolvers.addAll(getCustomArgumentResolvers()); } // Catch-all// 基于@RequestParam 参数解析器，使用默认值 resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true)); return resolvers; }org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#getDefaultReturnValueHandlers 返回要使用的返回值处理程序列表，包括通过setReturnValueHandlers提供的内置和自定义处理程序。
private ListgetDefaultReturnValueHandlers() { List handlers = new ArrayList(); // Single-purpose return value types// 方法返回值是ModelAndView的返回值解析器 handlers.add(new ModelAndViewMethodReturnValueHandler());// 方法返回值是model的返回值解析器 handlers.add(new ModelMethodProcessor());// 方法是返回值是view的返回值解析器 handlers.add(new ViewMethodReturnValueHandler());// 方法返回值是responseEntity的返回值解析器 handlers.add(new ResponseBodyEmitterReturnValueHandler(getMessageConverters()));// 方法返回值是流的返回值解析器 handlers.add(new StreamingResponseBodyReturnValueHandler());// 方法返回值是httpEntity的方法返回值解析器 handlers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.contentNegotiationManager, this.requestResponseBodyAdvice));// 方法返回值是httpHeaders的方法返回值解析器 handlers.add(new HttpHeadersReturnValueHandler());// 方法返回值是callable的方法返回值解析器 handlers.add(new CallableMethodReturnValueHandler());// 方法返回值是DeferredResult的方法返回值解析器 handlers.add(new DeferredResultMethodReturnValueHandler());// 方法返回值是WebAsyncTask的方法返回值解析器 handlers.add(new AsyncTaskMethodReturnValueHandler(this.beanFactory)); // Annotation-based return value types// 方法上有@ModelAttribute注解的返回值解析器 handlers.add(new ModelAttributeMethodProcessor(false));// 基于@RequestBody、@ResponseBody的返回值解析器 handlers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.contentNegotiationManager, this.requestResponseBodyAdvice)); // Multi-purpose return value types// 基于视图名字的返回值解析器 handlers.add(new ViewNameMethodReturnValueHandler());// 基于map的返回值解析器 handlers.add(new MapMethodProcessor()); // Custom return value types 自定义返回值解析器 if (getCustomReturnValueHandlers() != null) { handlers.addAll(getCustomReturnValueHandlers()); } // Catch-all// 基于modelAndView的返回值解析器 if (!CollectionUtils.isEmpty(getModelAndViewResolvers())) { handlers.add(new ModelAndViewResolverMethodReturnValueHandler(getModelAndViewResolvers())); } else {// 方法上有@ModelAttribute注解的返回值解析器，使用默认值 handlers.add(new ModelAttributeMethodProcessor(true)); } return handlers; }@Override protected boolean supportsInternal(HandlerMethod handlerMethod) { return true; }总是返回true，因为任何方法参数和返回值类型都将以某种方式处理。任何HandlerMethodArgumentResolver都无法识别的方法参数，如果它是简单类型，则被解释为请求参数，否则被解释为模型属性。任何HandlerMethodReturnValueHandler都不能识别的返回值将被解释为模型属性。
@Override protected ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception { ModelAndView mav;// 检查请求 -》 checkRequest(request); // Execute invokeHandlerMethod in synchronized block if required. 是否同步执行 if (this.synchronizeOnSession) { HttpSession session = request.getSession(false); if (session != null) { Object mutex = WebUtils.getSessionMutex(session); synchronized (mutex) {// 执行handler的业务方法 @RequestMapping标准的方法 -》 mav = invokeHandlerMethod(request, response, handlerMethod); } } else { // No HttpSession available -> no mutex necessary mav = invokeHandlerMethod(request, response, handlerMethod); } } else { // No synchronization on session demanded at all... mav = invokeHandlerMethod(request, response, handlerMethod); }// 响应消息头是否包含缓存 if (!response.containsHeader(HEADER_CACHE_CONTROL)) { if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {// 缓存设置 applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers); } else {// 准备响应 prepareResponse(response); } } return mav; }检查请求方法是否支持，执行handler的业务方法 @RequestMapping标准的方法，处理缓存返回ModelAndView。
org.springframework.web.servlet.support.WebContentGenerator#checkRequest 检查给定的请求是否支持方法和所需的会话(如果有的话)。
protected final void checkRequest(HttpServletRequest request) throws ServletException { // Check whether we should support the request method.检查我们是否应该支持请求方法。 String method = request.getMethod();// 请求方法不支持 if (this.supportedMethods != null && !this.supportedMethods.contains(method)) { throw new HttpRequestMethodNotSupportedException(method, this.supportedMethods); } // Check whether a session is required. 检查session if (this.requireSession && request.getSession(false) == null) { throw new HttpSessionRequiredException("Pre-existing session required but none found"); } }org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#invokeHandlerMethod 如果需要视图解析，则调用RequestMapping处理程序方法来准备ModelAndView。
protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception { ServletWebRequest webRequest = new ServletWebRequest(request, response); try {// 根据业务handler方法获取web数据绑定工厂 -》 WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);// 获取ModelFactory -》 ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory); ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);// 设置执行方法的参数解析器 invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);// 设置执行方法的返回值解析器 invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers); invocableMethod.setDataBinderFactory(binderFactory); invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);// 创建modelAndView容器 ModelAndViewContainer mavContainer = new ModelAndViewContainer(); mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));// 初始化model -》 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()) { Object result = asyncManager.getConcurrentResult(); mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0]; asyncManager.clearConcurrentResult(); if (logger.isDebugEnabled()) { logger.debug("Found concurrent result value [" + result + "]"); } invocableMethod = invocableMethod.wrapConcurrentResult(result); }// 执行方法 -》 invocableMethod.invokeAndHandle(webRequest, mavContainer);// 如果是异步请求，同步返回null if (asyncManager.isConcurrentHandlingStarted()) { return null; }// 返回ModelAndView -》 return getModelAndView(mavContainer, modelFactory, webRequest); } finally {// 请求完成-》 webRequest.requestCompleted(); } }org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#getDataBinderFactory 根据业务handler方法获取web数据绑定工厂
private WebDataBinderFactory getDataBinderFactory(HandlerMethod handlerMethod) throws Exception {// 获取业务方法的handler类型 Class> handlerType = handlerMethod.getBeanType();// 根据业务handler类型获取方法 Set methods = this.initBinderCache.get(handlerType); if (methods == null) {// 查询业务handler的方法有@InitBinder注解的方法 methods = MethodIntrospector.selectMethods(handlerType, INIT_BINDER_METHODS); this.initBinderCache.put(handlerType, methods); } List initBinderMethods = new ArrayList(); // Global methods first for (Entry> entry : this.initBinderAdviceCache.entrySet()) {// 检查业务handler上面是否有@ControllerAdvice注解 if (entry.getKey().isApplicableToBeanType(handlerType)) { Object bean = entry.getKey().resolveBean(); for (Method method : entry.getValue()) {// 创建InitBinderMethod -》 initBinderMethods.add(createInitBinderMethod(bean, method)); } } } for (Method method : methods) { Object bean = handlerMethod.getBean(); initBinderMethods.add(createInitBinderMethod(bean, method)); } return createDataBinderFactory(initBinderMethods); }org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#createInitBinderMethod 创建initBinder方法
private InvocableHandlerMethod createInitBinderMethod(Object bean, Method method) { InvocableHandlerMethod binderMethod = new InvocableHandlerMethod(bean, method);// 设置initBinder的参数解析器 binderMethod.setHandlerMethodArgumentResolvers(this.initBinderArgumentResolvers); binderMethod.setDataBinderFactory(new DefaultDataBinderFactory(this.webBindingInitializer)); binderMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer); return binderMethod; }org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#createDataBinderFactory 创建新InitBinderDataBinderFactory实例的模板方法。默认实现创建一个ServletRequestDataBinderFactory。这可以为自定义ServletRequestDataBinder子类重写。
protected InitBinderDataBinderFactory createDataBinderFactory(List binderMethods) throws Exception { return new ServletRequestDataBinderFactory(binderMethods, getWebBindingInitializer()); }返回org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#invokeHandlerMethod
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#getModelFactory 创建ModelFactory
private ModelFactory getModelFactory(HandlerMethod handlerMethod, WebDataBinderFactory binderFactory) {// 获取有@SessionAttribute注解的handler -》 SessionAttributesHandler sessionAttrHandler = getSessionAttributesHandler(handlerMethod); Class> handlerType = handlerMethod.getBeanType(); Set methods = this.modelAttributeCache.get(handlerType); if (methods == null) {// 获取handler中有@RequestMapping、@ModelAttribute的方法 methods = MethodIntrospector.selectMethods(handlerType, MODEL_ATTRIBUTE_METHODS); this.modelAttributeCache.put(handlerType, methods); } List attrMethods = new ArrayList(); // Global methods first for (Entry> entry : this.modelAttributeAdviceCache.entrySet()) {// 如果handler上有@ControllerAdvice -》 if (entry.getKey().isApplicableToBeanType(handlerType)) { Object bean = entry.getKey().resolveBean(); for (Method method : entry.getValue()) {// 创建ModelAttributeMethod -》 attrMethods.add(createModelAttributeMethod(binderFactory, bean, method)); } } } for (Method method : methods) { Object bean = handlerMethod.getBean(); attrMethods.add(createModelAttributeMethod(binderFactory, bean, method)); } return new ModelFactory(attrMethods, binderFactory, sessionAttrHandler); }org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#getSessionAttributesHandler 获取SessionAttributesHandler
private SessionAttributesHandler getSessionAttributesHandler(HandlerMethod handlerMethod) { Class> handlerType = handlerMethod.getBeanType();// 从缓存中获取SessionAttributesHandler SessionAttributesHandler sessionAttrHandler = this.sessionAttributesHandlerCache.get(handlerType); if (sessionAttrHandler == null) { synchronized (this.sessionAttributesHandlerCache) { sessionAttrHandler = this.sessionAttributesHandlerCache.get(handlerType); if (sessionAttrHandler == null) { sessionAttrHandler = new SessionAttributesHandler(handlerType, sessionAttributeStore); this.sessionAttributesHandlerCache.put(handlerType, sessionAttrHandler); } } } return sessionAttrHandler; }org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#createModelAttributeMethod 创建InvocableHandlerMethod
private InvocableHandlerMethod createModelAttributeMethod(WebDataBinderFactory factory, Object bean, Method method) { InvocableHandlerMethod attrMethod = new InvocableHandlerMethod(bean, method);// 设置参数解析器 attrMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers); attrMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer); attrMethod.setDataBinderFactory(factory); return attrMethod; }org.springframework.web.method.annotation.ModelFactory#ModelFactory 创建ModelFactory
public ModelFactory(List handlerMethods, WebDataBinderFactory binderFactory, SessionAttributesHandler attributeHandler) { if (handlerMethods != null) { for (InvocableHandlerMethod handlerMethod : handlerMethods) { this.modelMethods.add(new ModelMethod(handlerMethod)); } } this.dataBinderFactory = binderFactory; this.sessionAttributesHandler = attributeHandler; }返回org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#invokeHandlerMethod
org.springframework.web.method.annotation.ModelFactory#initModel 初始化model
public void initModel(NativeWebRequest request, ModelAndViewContainer container, HandlerMethod handlerMethod) throws Exception {// 从session中获取属性值 -》 Map sessionAttributes = this.sessionAttributesHandler.retrieveAttributes(request);// 合并session参数 -》 container.mergeAttributes(sessionAttributes);// 执行有@ModelAttribute的方法 -》 invokeModelAttributeMethods(request, container);// 查找handle方法上@ModelAttribute的参数 -》 for (String name : findSessionAttributeArguments(handlerMethod)) { if (!container.containsAttribute(name)) { Object value = this.sessionAttributesHandler.retrieveAttribute(request, name); if (value == null) { throw new HttpSessionRequiredException("Expected session attribute '" + name + "'", name); } container.addAttribute(name, value); } } }org.springframework.web.method.annotation.ModelFactory#invokeModelAttributeMethods 执行有@ModelAttribute的方法
private void invokeModelAttributeMethods(NativeWebRequest request, ModelAndViewContainer container) throws Exception { while (!this.modelMethods.isEmpty()) { InvocableHandlerMethod modelMethod = getNextModelMethod(container).getHandlerMethod(); ModelAttribute ann = modelMethod.getMethodAnnotation(ModelAttribute.class); if (container.containsAttribute(ann.name())) { if (!ann.binding()) { container.setBindingDisabled(ann.name()); } continue; }// 执行请求 -》 Object returnValue = modelMethod.invokeForRequest(request, container); if (!modelMethod.isVoid()){// 根据返回值和返回值类型获取返回值解析器 -》 String returnValueName = getNameForReturnValue(returnValue, modelMethod.getReturnType()); if (!ann.binding()) { container.setBindingDisabled(returnValueName); }// modelAndView容器不包含这个返回值就添加 if (!container.containsAttribute(returnValueName)) { container.addAttribute(returnValueName, returnValue); } } } }org.springframework.web.method.support.InvocableHandlerMethod#invokeForRequest 在给定请求的上下文中解析方法的参数值后调用该方法。
参数值通常通过HandlerMethodArgumentResolvers解析。但是providedArgs参数可以提供直接使用的参数值，即没有参数解析。提供的参数值示例包括WebDataBinder、SessionStatus或抛出异常实例。在参数解析器之前检查参数值。
public Object invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {// 解析请求参数值 -》 Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs); if (logger.isTraceEnabled()) { logger.trace("Invoking '" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) + "' with arguments " + Arrays.toString(args)); }// 执行方法 Object returnValue = doInvoke(args); if (logger.isTraceEnabled()) { logger.trace("Method [" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) + "] returned [" + returnValue + "]"); } return returnValue; }org.springframework.web.method.annotation.ModelFactory#getNameForReturnValue 为给定的返回值派生模型属性名，依据:方法ModelAttribute注释值，声明的返回类型(如果它比对象更具体)，实际返回值类型
public static String getNameForReturnValue(Object returnValue, MethodParameter returnType) {// 获取返回值类型上的@ModelAttribute ModelAttribute ann = returnType.getMethodAnnotation(ModelAttribute.class); if (ann != null && StringUtils.hasText(ann.value())) { return ann.value(); } else { Method method = returnType.getMethod(); Class> containingClass = returnType.getContainingClass(); Class> resolvedType = GenericTypeResolver.resolveReturnType(method, containingClass); return Conventions.getVariableNameForReturnType(method, resolvedType, returnValue); } }返回org.springframework.web.method.annotation.ModelFactory#initModel
org.springframework.web.method.annotation.ModelFactory#findSessionAttributeArguments
private List<String> findSessionAttributeArguments(HandlerMethod handlerMethod) { List<String> result = new ArrayList<String>(); for (MethodParameter parameter : handlerMethod.getMethodParameters()) { if (parameter.hasParameterAnnotation(ModelAttribute.class)) {// 获取@ModelAttribute配置的参数名称 -》 String name = getNameForParameter(parameter); Class> paramType = parameter.getParameterType(); if (this.sessionAttributesHandler.isHandlerSessionAttribute(name, paramType)) { result.add(name); } } } return result; }返回org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#invokeHandlerMethod
public static AsyncWebRequest createAsyncWebRequest(HttpServletRequest request, HttpServletResponse response) { return (startAsyncAvailable ? AsyncWebRequestFactory.createStandardAsyncWebRequest(request, response) : new NoSupportAsyncWebRequest(request, response)); }org.springframework.web.context.request.async.WebAsyncUtils#createAsyncWebRequest 创建AsyncWebRequest实例。默认情况下，在Servlet 3.0(或更高)环境中运行时会创建一个StandardServletAsyncWebRequest实例——作为回退，将返回NoSupportAsyncWebRequest实例。
org.springframework.web.context.request.async.WebAsyncUtils.AsyncWebRequestFactory#createStandardAsyncWebRequest
public static AsyncWebRequest createStandardAsyncWebRequest(HttpServletRequest request, HttpServletResponse response) { return new StandardServletAsyncWebRequest(request, response); }org.springframework.web.context.request.async.WebAsyncUtils#getAsyncManager(javax.servlet.ServletRequest) 获取当前请求的WebAsyncManager，如果没有找到，则创建它并将其与请求关联。
public static WebAsyncManager getAsyncManager(ServletRequest servletRequest) { WebAsyncManager asyncManager = null;// 从request中获取请求管理器 Object asyncManagerAttr = servletRequest.getAttribute(WEB_ASYNC_MANAGER_ATTRIBUTE); if (asyncManagerAttr instanceof WebAsyncManager) { asyncManager = (WebAsyncManager) asyncManagerAttr; }// 如果没有就创建后绑定到request中 if (asyncManager == null) { asyncManager = new WebAsyncManager(); servletRequest.setAttribute(WEB_ASYNC_MANAGER_ATTRIBUTE, asyncManager); } return asyncManager; }返回org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#invokeHandlerMethod
org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod#invokeAndHandle 调用该方法并通过配置的HandlerMethodReturnValueHandlers处理返回值。
public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {// 执行请求-》 Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);// 设置响应状态码 -》 setResponseStatus(webRequest); if (returnValue == null) { if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) { mavContainer.setRequestHandled(true); return; } } else if (StringUtils.hasText(getResponseStatusReason())) { mavContainer.setRequestHandled(true); return; } mavContainer.setRequestHandled(false); try {// 执行returnHandler -》 this.returnValueHandlers.handleReturnValue( returnValue, getReturnValueType(returnValue), mavContainer, webRequest); } catch (Exception ex) { if (logger.isTraceEnabled()) { logger.trace(getReturnValueHandlingErrorMessage("Error handling return value", returnValue), ex); } throw ex; } }org.springframework.web.method.support.InvocableHandlerMethod#invokeForRequest 在给定请求的上下文中解析方法的参数值后调用该方法。
参数值通常通过HandlerMethodArgumentResolvers解析。但是providedArgs参数可以提供直接使用的参数值，即没有参数解析。提供的参数值示例包括WebDataBinder、SessionStatus或抛出异常实例。在参数解析器之前检查参数值。
public Object invokeForRequest(NativeWebRequest request, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {// 解析请求参数值 -》 Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs); if (logger.isTraceEnabled()) { logger.trace("Invoking '" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) + "' with arguments " + Arrays.toString(args)); }// 执行方法 Object returnValue = doInvoke(args); if (logger.isTraceEnabled()) { logger.trace("Method [" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) + "] returned [" + returnValue + "]"); } return returnValue; }org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod#setResponseStatus 按@ResponseStatus参数设置response status
private void setResponseStatus(ServletWebRequest webRequest) throws IOException { HttpStatus status = getResponseStatus(); if (status == null) { return; } String reason = getResponseStatusReason(); if (StringUtils.hasText(reason)) { webRequest.getResponse().sendError(status.value(), reason); } else { webRequest.getResponse().setStatus(status.value()); } // To be picked up by RedirectView webRequest.getRequest().setAttribute(View.RESPONSE_STATUS_ATTRIBUTE, status); }org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite#handleReturnValue 遍历已注册的HandlerMethodReturnValueHandlers并调用支持它的处理程序。
@Override public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {// 根据返回值和返回值类型找到handler -》 HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType); if (handler == null) { throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName()); }// 根据returnHandler方法执行的结果包装最后要返回视图的值 handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest); }org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite#selectHandler 选择HandlerMethodReturnValueHandler
private HandlerMethodReturnValueHandler selectHandler(Object value, MethodParameter returnType) {// 是否是异步返回值 boolean isAsyncValue = isAsyncReturnValue(value, returnType); for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) { if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) { continue; } if (handler.supportsReturnType(returnType)) { return handler; } } return null; }返回org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#invokeHandlerMethod
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#getModelAndView 创建ModelAndView
private ModelAndView getModelAndView(ModelAndViewContainer mavContainer, ModelFactory modelFactory, NativeWebRequest webRequest) throws Exception {// 更新model -》 modelFactory.updateModel(webRequest, mavContainer); if (mavContainer.isRequestHandled()) { return null; } ModelMap model = mavContainer.getModel();// 创建modelAndView对象 ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, mavContainer.getStatus());// 是不是string的view视图 if (!mavContainer.isViewReference()) { mav.setView((View) mavContainer.getView()); } if (model instanceof RedirectAttributes) { Map flashAttributes = ((RedirectAttributes) model).getFlashAttributes(); HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class); RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes); } return mav; }org.springframework.web.method.annotation.ModelFactory#updateModel 将列出为@SessionAttributes的模型属性提升到会话。必要时添加BindingResult属性。
public void updateModel(NativeWebRequest request, ModelAndViewContainer container) throws Exception { ModelMap defaultModel = container.getDefaultModel(); if (container.getSessionStatus().isComplete()){ this.sessionAttributesHandler.cleanupAttributes(request); } else { this.sessionAttributesHandler.storeAttributes(request, defaultModel); } if (!container.isRequestHandled() && container.getModel() == defaultModel) {// 更新绑定结果-》 updateBindingResult(request, defaultModel); } }org.springframework.web.method.annotation.ModelFactory#updateBindingResult
private void updateBindingResult(NativeWebRequest request, ModelMap model) throws Exception { List keyNames = new ArrayList(model.keySet()); for (String name : keyNames) { Object value = model.get(name); if (isBindingCandidate(name, value)) { String bindingResultKey = BindingResult.MODEL_KEY_PREFIX + name; if (!model.containsAttribute(bindingResultKey)) {// 创建数据绑定器-》 WebDataBinder dataBinder = this.dataBinderFactory.createBinder(request, value, name); model.put(bindingResultKey, dataBinder.getBindingResult()); } } } }org.springframework.web.context.request.AbstractRequestAttributes#requestCompleted 发出请求已完成的信号。执行所有请求销毁回调并更新在请求处理期间已访问的会话属性。
public void requestCompleted() {// 执行请求回调 executeRequestDestructionCallbacks();// 更新session绑定参数 模板方法 updateAccessedSessionAttributes(); this.requestActive = false; }说在最后
本次解析仅代表个人观点，仅供参考。
扫码进入技术微信群
钉钉技术群
qq技术群
1249
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
