在MVC请求流程中,获取到HandlerAdapter适配器后,会执行handler处理器(Controller控制器)的相关逻辑,通过适配器的handle()方法,完成目标Controller处理器的调用。在源码(七):HandlerAdapter适配器获取中提到,以HandlerAdapter为RequestMappingHandlerAdapter类型的为例,执行handler处理器(Controller控制器)的相关处理。
1、核心流程图
HandlerAdapter处理器适配器调用目标Controller控制器的方法逻辑的核心流程图:
2、核心流程伪代码
AbstractHandlerMethodAdapter#handle() 核心伪代码
1 // 处理目标handler处理器中的逻辑 2 public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) 3 throws Exception { 4 5 return handleInternal(request, response, (HandlerMethod) handler); 6 }
RequestMappingHandlerAdapter#handleInternal 核心伪代码
1 protected ModelAndView handleInternal(HttpServletRequest request, 2 HttpServletResponse response, HandlerMethod handlerMethod) throws Exception { 3 4 // 执行Controller控制器的目标方法 5 ModelAndView mav = invokeHandlerMethod(request, response, handlerMethod); 6 7 // 返回执行结果ModeAndView 8 return mav; 9 }
RequestMappingHandlerAdapter#invokeHandlerMethod 核心伪代码
1 // 调用处理器的目标方法 2 protected ModelAndView invokeHandlerMethod(HttpServletRequest request, 3 HttpServletResponse response, HandlerMethod handlerMethod) throws Exception { 4 5 // 使用request和response创建ServletWebRequest对象 6 ServletWebRequest webRequest = new ServletWebRequest(request, response); 7 try { 8 // 创建WebDataBinderFactory对象,此对象用来创建WebDataBinder对象,进行参数绑定, 9 WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod); 10 11 // 创建ModelFactory对象,此对象主要用来处理model 12 // 主要是两个功能,1是在处理器具体处理之前对model进行初始化,2是在处理完请求后对model参数进行更新 13 ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory); 14 15 // 创建ServletInvocableHandlerMethod对象,并设置其相关属性,实际的请求处理就是通过此对象来完成的,参数绑定、处理请求以及返回值处理都在此处完成 16 ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod); 17 // 设置参数处理器 18 if (this.argumentResolvers != null) { 19 invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers); 20 } 21 // 设置返回值处理器 22 if (this.returnValueHandlers != null) { 23 invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers); 24 } 25 // 设置参数绑定工厂对象 26 invocableMethod.setDataBinderFactory(binderFactory); 27 // 设置参数名称发现器 28 invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer); 29 30 // 创建ModelAndViewContainer对象,用于保存model和View对象 31 ModelAndViewContainer mavContainer = new ModelAndViewContainer(); 32 // 将flashmap中的数据设置到model中 33 mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request)); 34 // 使用modelFactory将sessionAttributes和注释了@ModelAttribute的方法的参数设置到model中 35 modelFactory.initModel(webRequest, mavContainer, invocableMethod); 36 // 根据配置对ignoreDefaultModelOnRedirect进行设置 37 mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect); 38 39 // 创建AsyncWebRequest异步请求对象 40 AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response); 41 asyncWebRequest.setTimeout(this.asyncRequestTimeout); 42 43 // 创建WebAsyncManager异步请求管理器对象 44 WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request); 45 asyncManager.setTaskExecutor(this.taskExecutor); 46 asyncManager.setAsyncWebRequest(asyncWebRequest); 47 asyncManager.registerCallableInterceptors(this.callableInterceptors); 48 asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors); 49 50 // 如果当前异步请求已经处理并得到结果,则将返回的结果放到mavContainer对象中,然后将invocable对象进行包装转换,转成需要的执行对象然后开始执行 51 if (asyncManager.hasConcurrentResult()) { 52 Object result = asyncManager.getConcurrentResult(); 53 mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0]; 54 asyncManager.clearConcurrentResult(); 55 LogFormatUtils.traceDebug(logger, traceOn -> { 56 String formatted = LogFormatUtils.formatValue(result, !traceOn); 57 return "Resume with async result [" + formatted + "]"; 58 }); 59 // 转换具体的invocable执行对象 60 invocableMethod = invocableMethod.wrapConcurrentResult(result); 61 } 62 63 // 执行调用 64 invocableMethod.invokeAndHandle(webRequest, mavContainer); 65 if (asyncManager.isConcurrentHandlingStarted()) { 66 return null; 67 } 68 69 // 处理完请求后的后置处理 70 // 1、调用ModelFactory的updateModel方法更新model,包括设置SessionAttribute和给Model设置BinderResult 71 // 2、根据mavContainer创建了ModelAndView 72 // 3、如果mavContainer里的model是RedirectAttributes类型,则将其设置到FlashMap 73 return getModelAndView(mavContainer, modelFactory, webRequest); 74 } 75 finally { 76 // 标记请求完成 77 webRequest.requestCompleted(); 78 } 79 }
1、根据request、response创建ServletWebRequest对象
2、创建WebDataBinderFactory对象
创建WebDataBinderFactory对象,用于处理@InitBinder注解修饰的方法。
RequestMappingHandlerAdapter#getDataBinderFactory() 核心伪代码
1 // @InitBinder修饰方法缓存 2 private final Map<Class<?>, Set<Method>> initBinderCache = new ConcurrentHashMap<>(64); 3 4 // @InitBinder修饰方法过滤器 5 public static final MethodFilter INIT_BINDER_METHODS = method -> 6 AnnotatedElementUtils.hasAnnotation(method, InitBinder.class); 7 8 private WebDataBinderFactory getDataBinderFactory(HandlerMethod handlerMethod) throws Exception { 9 // 获取当前handler的Class对象(Controller控制器的Class对象) 10 Class<?> handlerType = handlerMethod.getBeanType(); 11 // 检查当前Handler中的initBinder方法是否已经存在于缓存中 12 Set<Method> methods = this.initBinderCache.get(handlerType); 13 // 如果没有找到则查找并设置到缓冲中 14 if (methods == null) { 15 // 将当前Controller中所有被@InitBinder注解修饰的方法都获取到 16 methods = MethodIntrospector.selectMethods(handlerType, INIT_BINDER_METHODS); 17 this.initBinderCache.put(handlerType, methods); 18 } 19 // 定义保存InitBinder方法的变量 20 List<InvocableHandlerMethod> initBinderMethods = new ArrayList<>(); 21 // 将所有符合条件的全局InitBinder方法添加到initBinderMethods 22 // 获取@ControllerAdvice注解修饰的类中被@InitBinder注解修饰的方法 23 this.initBinderAdviceCache.forEach((controllerAdviceBean, methodSet) -> { 24 if (controllerAdviceBean.isApplicableToBeanType(handlerType)) { 25 Object bean = controllerAdviceBean.resolveBean(); 26 for (Method method : methodSet) { 27 initBinderMethods.add(createInitBinderMethod(bean, method)); 28 } 29 } 30 }); 31 // 将当前handler中的initBinder方法添加到initBinderMethods 32 for (Method method : methods) { 33 // 创建当前方法对应的bean对象 34 Object bean = handlerMethod.getBean(); 35 // 将method适配为可执行的invocableHandlerMethod 36 initBinderMethods.add(createInitBinderMethod(bean, method)); 37 } 38 // 创建DataBinderFactory并返回 39 return createDataBinderFactory(initBinderMethods); 40 }
1、获取当前Controller中被@InitBinder修饰的方法。优先从initBinderCache缓存中获取,若缓存中不存在,则在当前Controller中查询,并将查询到的结果保存在methods集合中,并设置进initBinderCache缓存中。
2、获取全局(被@ControllerAdvice注解修饰的类)被@InitBinder注解修饰的方法,并将目标方法用InvocableHandlerMethod类型的对象封装,保存在initBinderMethods集合中。
3、遍历Controller中被被@InitBinder修饰的方法集合methods,将目标方法用InvocableHandlerMethod类型的对象封装,添加进initBinderMethods集合中。
4、创建WebDataBinderFactory类型的对象,将initBinderMethods集合设置到InitBinderDataBinderFactory的binderMethods属性中,返回WebDataBinderFactory类型的对象。
3、创建ModelFactory对象
创建WebDataBinderFactory对象,用于处理@ModelAttribute注解修饰的方法。RequestMappingHandlerAdapter#getModelFactory() 核心伪代码
1 // 被@ModelAttribute注解修饰的方法缓存 2 private final Map<Class<?>, Set<Method>> modelAttributeCache = new ConcurrentHashMap<>(64); 3 4 // 被@ModelAttribute修饰,未被@RequestMapping修饰的方法过滤器 5 public static final MethodFilter MODEL_ATTRIBUTE_METHODS = method -> 6 (!AnnotatedElementUtils.hasAnnotation(method, RequestMapping.class) && 7 AnnotatedElementUtils.hasAnnotation(method, ModelAttribute.class)); 8 9 // 被@ContollerAdvice注解修饰的类中,ModelAttribute方法 10 private final Map<ControllerAdviceBean, Set<Method>> modelAttributeAdviceCache = new LinkedHashMap<>(); 11 12 // 获取ModelFactory对象 13 private ModelFactory getModelFactory(HandlerMethod handlerMethod, WebDataBinderFactory binderFactory) { 14 // 获取sessionAttributesHandler 15 SessionAttributesHandler sessionAttrHandler = getSessionAttributesHandler(handlerMethod); 16 // 获取处理器类的类型 17 Class<?> handlerType = handlerMethod.getBeanType(); 18 // 从缓存中获取处理器类中注释了@ModelAttribute而且没有注释@RequestMapping的类 19 Set<Method> methods = this.modelAttributeCache.get(handlerType); 20 // 缓存中不存在 21 if (methods == null) { 22 // 从当前Controller中获取被@ModelAttribute注解修饰,未被@RequestMapping注解修饰的方法 23 methods = MethodIntrospector.selectMethods(handlerType, MODEL_ATTRIBUTE_METHODS); 24 // 将方法设置进modelAttributeCache缓存中 25 this.modelAttributeCache.put(handlerType, methods); 26 } 27 // 定义保存ModelAttribute方法的变量 28 29 List<InvocableHandlerMethod> attrMethods = new ArrayList<>(); 30 31 // 先添加全局@ControllerAdvice的@ModelAttribute方法 32 this.modelAttributeAdviceCache.forEach((controllerAdviceBean, methodSet) -> { 33 if (controllerAdviceBean.isApplicableToBeanType(handlerType)) { 34 Object bean = controllerAdviceBean.resolveBean(); 35 // 将ModelAttribut方法用InvocableHandlerMethod类型对象封装,并添加进attrMethods中 36 for (Method method : methodSet) { 37 attrMethods.add(createModelAttributeMethod(binderFactory, bean, method)); 38 } 39 } 40 }); 41 // 再添加当前处理器Controller定义的@ModelAttribute方法 42 for (Method method : methods) { 43 Object bean = handlerMethod.getBean(); 44 attrMethods.add(createModelAttributeMethod(binderFactory, bean, method)); 45 } 46 // 新建ModelFactory对象 47 // 此处需要三个参数,第一个是被@ModelAttribute的方法,第二个是WebDataBinderFactory,第三个是SessionAttributeHandler 48 return new ModelFactory(attrMethods, binderFactory, sessionAttrHandler); 49 }
1、获取当前Controller中被@ModelAttribute修饰,未被@RequestMapping修饰的方法。优先从modelAttributeCache缓存中获取,若缓存中不存在,则在当前Controller中查询,并将查询到的结果保存在methods集合中,并设置进modelAttributeCache缓存中。
2、获取全局(被@ControllerAdvice注解修饰的类)被@ModelAttribute注解修饰的方法,并将目标方法用InvocableHandlerMethod类型的对象封装,保存在attrMethods集合中。
3、遍历Controller中被@ModelAttribute修饰的方法集合methods,将目标方法用InvocableHandlerMethod类型的对象封装,添加进attrMethods集合中。
4、创建ModelFactory类型的对象,将attrMethods集合设置到ModeFaactory的modelMethods属性中,返回ModeFaactory类型的对象。
4、创建ServletInvocableHandlerMethod对象并完成属性设置
创建ServletInvocableHandlerMethod对象,用于调用Controller控制器中的目标方法逻辑。
4.1、创建ServletInvocableHandlerMethod对象
RequestMappingHandlerAdapter#createInvocableHandlerMethod() 核心伪代码
1 // 创建ServletInvocableHandlerMethod对象包装handlerMethod 2 protected ServletInvocableHandlerMethod createInvocableHandlerMethod(HandlerMethod handlerMethod) { 3 return new ServletInvocableHandlerMethod(handlerMethod); 4 }
4.2、属性设置
1 // 设置参数处理器 2 if (this.argumentResolvers != null) { 3 invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers); 4 } 5 // 设置返回值处理器 6 if (this.returnValueHandlers != null) { 7 invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers); 8 } 9 // 设置参数绑定工厂对象 10 invocableMethod.setDataBinderFactory(binderFactory); 11 // 设置参数名称发现器 12 invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
1、属性初始化
参数解析器argumentResolvers、返回值处理器returnValueHandlers的初始化过程与源码(六):Handler处理器获取中AbstractHandlerMethodMapping#mappingRegistry属性的初始化过程类似。
在MVC容器启动,创建MVC容器中单例的bean对象,创建RequestMappingHandlerAdapter的bean实例过程中,在getBean() -> doGetBean() -> createBean() -> doCreateBean() -> initializeBean() -> invokeInitMethods() -> RequestMappingHandlerAdapter#afterPropertiesSet()。
RequestMappingHandlerAdapter#afterPropertiesSet(),调用bean的afterPropertiesSet方法。
1 public void afterPropertiesSet() { 2 // 初始化ControllerAdvice缓存 3 initControllerAdviceCache(); 4 // 初始化参数处理器 - argumentResolvers 5 if (this.argumentResolvers == null) { 6 // 获取默认的参数处理器 7 List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers(); 8 this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers); 9 } 10 // 初始化InitBinder方法参数处理器 - initBinderArgumentResolvers 11 if (this.initBinderArgumentResolvers == null) { 12 // 获取默认的InitBinder方法参数处理器 13 List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers(); 14 this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers); 15 } 16 // 初始化返回值处理器 - returnValueHandlers 17 if (this.returnValueHandlers == null) { 18 // 获取默认的返回值处理器 19 List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers(); 20 this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers); 21 } 22 }
1.1、参数处理器
初始化参数值处理器,,并将获取到的参数值处理器设置进HandlerMethodArgumentResolverComposite的argumentResolvers属性中,MVC容器中实现的默认参数值处理器如下:
获取默认返回值处理器器 RequestMappingHandlerAdapter#getDefaultArgumentResolvers() 核心伪代码
1 private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() { 2 List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(30); 3 4 // 基于注解的参数处理器 5 resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false)); 6 resolvers.add(new RequestParamMapMethodArgumentResolver()); 7 resolvers.add(new PathVariableMethodArgumentResolver()); 8 resolvers.add(new PathVariableMapMethodArgumentResolver()); 9 resolvers.add(new MatrixVariableMethodArgumentResolver()); 10 resolvers.add(new MatrixVariableMapMethodArgumentResolver()); 11 resolvers.add(new ServletModelAttributeMethodProcessor(false)); 12 resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice)); 13 resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters(), this.requestResponseBodyAdvice)); 14 resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory())); 15 resolvers.add(new RequestHeaderMapMethodArgumentResolver()); 16 resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory())); 17 resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory())); 18 resolvers.add(new SessionAttributeMethodArgumentResolver()); 19 resolvers.add(new RequestAttributeMethodArgumentResolver()); 20 21 // 基于类型的参数处理器 22 resolvers.add(new ServletRequestMethodArgumentResolver()); 23 resolvers.add(new ServletResponseMethodArgumentResolver()); 24 resolvers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice)); 25 resolvers.add(new RedirectAttributesMethodArgumentResolver()); 26 resolvers.add(new ModelMethodProcessor()); 27 resolvers.add(new MapMethodProcessor()); 28 resolvers.add(new ErrorsMethodArgumentResolver()); 29 resolvers.add(new SessionStatusMethodArgumentResolver()); 30 resolvers.add(new UriComponentsBuilderMethodArgumentResolver()); 31 32 // 自定义参数解析器 33 if (getCustomArgumentResolvers() != null) { 34 resolvers.addAll(getCustomArgumentResolvers()); 35 } 36 37 // Catch-all 38 resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true)); 39 resolvers.add(new ServletModelAttributeMethodProcessor(true)); 40 41 return resolvers; 42 }
参数处理器的顶级接口HandlerMethodArgumentResolver包含两个核心方法:supportsParameter()、resolveArgument()
supportsParameter():判断是否支持参数解析方法;resolveArgument():具体的参数解析方法。
1 // 参数处理器接口 2 public interface HandlerMethodArgumentResolver { 3 4 // 当前参数处理器是否支持MethodParameter参数的解析 5 boolean supportsParameter(MethodParameter parameter); 6 7 // 从request请求中解析MethodParameter变成参数值并返回 8 Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, 9 NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception; 10 11 }
MVC容器中默认提供26种参数解析器:
1.2、返回值处理器
初始化返回值处理器,并将获取到的返回值处理器设置进HandlerMethodReturnValueHandlerComposite的returnValueHandlers属性中,MVC容器中实现的默认返回值处理器如下:
获取默认返回值处理器器 RequestMappingHandlerAdapter#getDefaultReturnValueHandlers() 核心伪代码
1 // 获取默认的返回值处理器 2 private List<HandlerMethodReturnValueHandler> getDefaultReturnValueHandlers() { 3 // 保存返回值处理器集合 4 List<HandlerMethodReturnValueHandler> handlers = new ArrayList<>(20); 5 6 // 单一返回值处理器 7 handlers.add(new ModelAndViewMethodReturnValueHandler()); 8 handlers.add(new ModelMethodProcessor()); 9 handlers.add(new ViewMethodReturnValueHandler()); 10 handlers.add(new ResponseBodyEmitterReturnValueHandler(getMessageConverters(), 11 this.reactiveAdapterRegistry, this.taskExecutor, this.contentNegotiationManager)); 12 handlers.add(new StreamingResponseBodyReturnValueHandler()); 13 handlers.add(new HttpEntityMethodProcessor(getMessageConverters(), 14 this.contentNegotiationManager, this.requestResponseBodyAdvice)); 15 handlers.add(new HttpHeadersReturnValueHandler()); 16 handlers.add(new CallableMethodReturnValueHandler()); 17 handlers.add(new DeferredResultMethodReturnValueHandler()); 18 handlers.add(new AsyncTaskMethodReturnValueHandler(this.beanFactory)); 19 20 // 基于注解的返回值类型处理器 21 handlers.add(new ModelAttributeMethodProcessor(false)); 22 handlers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), 23 this.contentNegotiationManager, this.requestResponseBodyAdvice)); 24 25 // 多返回值处理器 26 handlers.add(new ViewNameMethodReturnValueHandler()); 27 handlers.add(new MapMethodProcessor()); 28 29 // 自定义返回值处理器 30 if (getCustomReturnValueHandlers() != null) { 31 handlers.addAll(getCustomReturnValueHandlers()); 32 } 33 34 // Catch-all 35 if (!CollectionUtils.isEmpty(getModelAndViewResolvers())) { 36 handlers.add(new ModelAndViewResolverMethodReturnValueHandler(getModelAndViewResolvers())); 37 } 38 else { 39 handlers.add(new ModelAttributeMethodProcessor(true)); 40 } 41 42 return handlers; 43 }
返回值处理器的顶级接口HandlerMethodReturnValueHandler包含两个核心方法:supportsReturnType()、handleReturnValue()
supportsReturnType():判断是否支持参数解析方法;handleReturnValue():具体的参数解析方法。1 // 返回值处理器接口 2 public interface HandlerMethodReturnValueHandler { 3 4 // 是否支持当前返回值类型的处理 5 boolean supportsReturnType(MethodParameter returnType); 6 7 // 返回值参数解析 8 void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, 9 ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception; 10 11 }
MVC容器中默认提供15种参数解析器
2、设置参数处理器
将RequestMappingHandlerAdapter中的参数处理器属性argumentResolvers设置到ServletInvocableHandlerMethod父类InvocableHandlerMethod中的resolvers属性中。 InvocableHandlerMethod#setHandlerMethodArgumentResolvers() 核心代码:1 // 设置参数处理器到ServletInvocableHandlerMethod的父类InvocableHandlerMethod中的resolvers属性 2 public void setHandlerMethodArgumentResolvers(HandlerMethodArgumentResolverComposite argumentResolvers) { 3 this.resolvers = argumentResolvers; 4 }
3、设置返回值处理器
将RequestMappingHandlerAdapter中的返回值处理器器属性returnValueHandlers设置到ServletInvocableHandlerMethod类型的对象中。
ServletInvocableHandlerMethod#returnValueHandlers() 核心代码:
1 // 设置返回值处理器到returnValueHandlers属性 2 public void setHandlerMethodReturnValueHandlers(HandlerMethodReturnValueHandlerComposite returnValueHandlers) { 3 this.returnValueHandlers = returnValueHandlers; 4 }
4、设置@InitBinder处理工厂
将获取到的WebDataBinderFactory设置到ServletInvocableHandlerMethod父类InvocableHandlerMethod中的dataBinderFactory属性中。
InvocableHandlerMethod#setDataBinderFactory() 核心代码:
1 // 设置@InitBinder处理工厂到ServletInvocableHandlerMethod的父类InvocableHandlerMethod中的dataBinderFactory属性 2 public void setDataBinderFactory(WebDataBinderFactory dataBinderFactory) { 3 this.dataBinderFactory = dataBinderFactory; 4 }
5、设置名称发现器
参数名称发现器parameterNameDiscoverer是RequestMappingHandlerAdapter中的属性,属性详情如下:
// 创建参数名称发现器 private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
在DefaultParameterNameDiscoverer构造函数中添加了名称发现器:KotlinReflectionParameterNameDiscoverer、StandardReflectionParameterNameDiscoverer、LocalVariableTableParameterNameDiscoverer
1 public DefaultParameterNameDiscoverer() { 2 if (KotlinDetector.isKotlinReflectPresent() && !GraalDetector.inImageCode()) { 3 addDiscoverer(new KotlinReflectionParameterNameDiscoverer()); 4 } 5 addDiscoverer(new StandardReflectionParameterNameDiscoverer()); 6 addDiscoverer(new LocalVariableTableParameterNameDiscoverer()); 7 }
5、创建ModelAndViewContainer对象并完成属性设置
ModelAndViewContainer对象的view和model属性:
1 public class ModelAndViewContainer { 2 3 // 是否不使用defaultModel属性标识 4 private boolean ignoreDefaultModelOnRedirect = false; 5 6 // ModelAndViewContainer的view属性 7 private Object view; 8 9 // ModelAndViewContainer的默认Model属性 10 private final ModelMap defaultModel = new BindingAwareModelMap(); 11 12 // ModelAndViewContainer的Model属性 13 private ModelMap redirectModel; 14 }
初始创建mavContainer对象,view属性和model属性为空,在执行完成handler处理器后,对view和model属性进行填充。
ModelAndViewContainer的model属性,BindingAwareModelMap类图如下,在实际填充ModelAndViewContainer的model属性,主要调用父类ExtendedModelMap、ModeMap中的方法,详细填充过程后续会进行分析。
6、调用handler执行器
调用handler执行器主要有三个步骤:请求参数解析、返回值结果解析、ModelAndViewContainer的Model属性、View属性填充。
ServletInvocableHandlerMethod #invokeAndHandle() 核心伪代码
1 // 调用处理Handler处理器 2 public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, 3 Object... providedArgs) throws Exception { 4 5 // 调用父类的invokeForRequest执行请求 6 Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs); 7 8 // 处理@ResponseStatus注解 9 setResponseStatus(webRequest); 10 // ... 11 // RequestHandled为false 即请求完成 12 mavContainer.setRequestHandled(false); 13 14 // 使用returnValueHandlers处理返回值 15 this.returnValueHandlers.handleReturnValue( 16 returnValue, getReturnValueType(returnValue), mavContainer, webRequest); 17 }
1、调用父类执行请求并获取返回结果
InvocableHandlerMethod#invokeForRequest 核心伪代码1 public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, 2 Object... providedArgs) throws Exception { 3 4 // 准备方法所需要的参数 5 Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs); 6 7 // 真正调用的method 8 return doInvoke(args); 9 }
1.1、获取方法参数getMethodArgumentValues
InvocableHandlerMethod#getMethodArgumentValues() 核心伪代码
1 protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, 2 Object... providedArgs) throws Exception { 3 4 // 获取方法的参数,HandlerMethod中的parameters属性 5 MethodParameter[] parameters = getMethodParameters(); 6 // 参数若为空,返回空参数数组 7 if (ObjectUtils.isEmpty(parameters)) { 8 return EMPTY_ARGS; 9 } 10 11 // 用于保存解析出参数的值 12 Object[] args = new Object[parameters.length]; 13 for (int i = 0; i < parameters.length; i++) { 14 MethodParameter parameter = parameters[i]; 15 // 给parameter设置参数名解析器 16 parameter.initParameterNameDiscovery(this.parameterNameDiscoverer); 17 // 如果相应类型的参数已经在providedArgs中提供了,则直接设置到parameter 18 args[i] = findProvidedArgument(parameter, providedArgs); 19 if (args[i] != null) { 20 continue; 21 } 22 // 若参数解析器无法解析参数,抛出异常 23 if (!this.resolvers.supportsParameter(parameter)) { 24 throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver")); 25 } 26 27 // 使用argumentResolvers参数解析器解析参数 28 args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory); 29 30 } 31 return args; 32 }
1、方法为无参数方法,返回空参数数组
获取HandlerMethod中的parameters属性,在源码(六):Handler处理器获取中,有具体的HandlerMethod的获取过程,此处不再赘述。
2、方法为有参方法,解析参数
遍历方法参数,判断参数解析器集合中是否支持参数解析,若解析器集合不支持当前参数的解析,抛出异常,流程结束;若解析器集合支持当前参数的解析,调用参数解析器的resolveArgument()方法实现方法参数的解析,并将解析的结果放入args集合返回。
1.2、doInvoke -> 调用Controller控制器的指定方法
在执行完Controller控制器的处理逻辑后,已经填充了ModelAndViewContainer的defaultModel属性。
1、ModelAndViewContainer的model属性填充
下面我们来看看ModelAndViewContainer的defaultModel的Model属性是如何被填充的,分析hello()方法,唯一可添加model属性的步骤在model.addAttribute()方法。 ExtendedModelMap#addAttribute() 核心伪代码:1 // 设置ModleAndViewContainer的model属性 2 public ExtendedModelMap addAttribute(String attributeName, @Nullable Object attributeValue) { 3 // 添加属性 4 super.addAttribute(attributeName, attributeValue); 5 return this; 6 }
传入参数如下:
ModelMap#addAttribute() 核心伪代码
1 public ModelMap addAttribute(String attributeName, @Nullable Object attributeValue) { 2 // 设置属性名称、属性值 3 put(attributeName, attributeValue); 4 return this; 5 }
BindingAwareModelMap#put()
1 // 填充ModelAndViewContainer的Model属性 2 public Object put(String key, @Nullable Object value) { 3 // 清空重复的属性值、属性名称 4 removeBindingResultIfNecessary(key, value);、 5 // 填充属性 6 return super.put(key, value); 7 }
2、Controller控制器返回结果
回到Controller控制器执行流程,获取返回结果userlist字符串。
2、返回结果的处理
处理Controller控制器返回结果,HandlerMethodReturnValueHandlerComposite#handleReturnValue 核心伪代码
1 // 处理Controller控制器返回结果 2 public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, 3 ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception { 4 // 获取返回值处理器 5 HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType); 6 // 未匹配到返回值处理器,抛出异常 7 if (handler == null) { 8 throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName()); 9 } 10 // 调用处理器处理返回值 11 handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest); 12 }
1、匹配返回值处理器
匹配返回值处理器,HandlerMethodReturnValueHandlerComposite#selectHandler() 核心伪代码1 // 获取返回值处理器 2 private HandlerMethodReturnValueHandler selectHandler(@Nullable Object value, MethodParameter returnType) { 3 // 异步处理返回值标识 4 boolean isAsyncValue = isAsyncReturnValue(value, returnType); 5 // 遍历返回值处理器 6 for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) { 7 // 若异步处理返回值标识为true并且当前返回值处理器不为AsyncHandlerMethodReturnValueHandler异步返回值处理器,跳过 8 if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) { 9 continue; 10 } 11 // 当前返回值处理器是否能处理Controller控制器返回结果 12 if (handler.supportsReturnType(returnType)) { 13 // 返回目标返回值处理器 14 return handler; 15 } 16 } 17 // 无匹配的返回值处理器,返回null 18 return null; 19 }
1、遍历MVC默认实现的返回值处理器
debug调试,获取返回值处理器ViewNameMethodReturnValueHandler,ViewNameMethodReturnValueHandler实现了返回值处理器的顶级接口HandlerMethodReturnValueHandler。
![](/i/l/?n=23&i=blog/1680081/202302/1680081-20230216202441435-2093960939.png)
下面来看看ViewNameMethodReturnValueHandler对核心方法supportsReturnType()的实现, ViewNameMethodReturnValueHandler#supportsReturnType() 核心代码:
1 // 是否能处理返回值 2 public boolean supportsReturnType(MethodParameter returnType) { 3 // 获取返回值的类型 Class对象 4 Class<?> paramType = returnType.getParameterType();、 5 // ViewNameMethodReturnValueHandler可处理的返回值类型为void、CharSequence 6 return (void.class == paramType || CharSequence.class.isAssignableFrom(paramType)); 7 }
本次演示案例Contoller返回值为"userlist"为String类型,String实现了CharSequence接口,因此返回值处理器ViewNameMethodReturnValueHandler可处理String类型的返回结果。
2、调用处理器处理返回值
ViewNameMethodReturnValueHandler对核心方法supportsReturnType()的实现已经分析,下面来看看ViewNameMethodReturnValueHandler对返回值处理的核心方法handleReturnValue()的实现。
ViewNameMethodReturnValueHandler#handleReturnValue() 核心代码
1 // 处理器处理返回值结果 2 public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, 3 ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception { 4 // 返回值类型为CharSequence类型 5 if (returnValue instanceof CharSequence) { 6 // 获取视图名称 7 String viewName = returnValue.toString(); 8 // 将视图名称设置进mavContainer对象的view属性 9 mavContainer.setViewName(viewName); 10 // 若为重定向视图,是指重定向标识为true 11 if (isRedirectViewName(viewName)) { 12 mavContainer.setRedirectModelScenario(true); 13 } 14 } 15 // 若返回值不为null。抛出异常 16 else if (returnValue != null) { 17 throw new UnsupportedOperationException("Unexpected return type: " + 18 returnType.getParameterType().getName() + " in method: " + returnType.getMethod()); 19 } 20 }
1、返回值类型为CharSequence,即字符串类型,获取返回视图名称,并将视图设置进ModelAndViewContainer中的view属性;
2、若重定向视图,则将重定向表示设置为true。3、总结
调用Controller控制的目标方法,将返回数据设置在ModelAndViewContainer的model属性中,将返回视图设置在在ModelAndViewContainer的view属性中。7、获取ModelAndView对象
获取ModelAndView对象,RequestMappingHandlerAdapter#getModelAndView() 核心伪代码1 // 获取ModelAndView对象 2 private ModelAndView getModelAndView(ModelAndViewContainer mavContainer, 3 ModelFactory modelFactory, NativeWebRequest webRequest) throws Exception { 4 5 // 更新model(设置sessionAttributes和给model设置BindingResult) 6 modelFactory.updateModel(webRequest, mavContainer); 7 // 若 mavContainer 已处理,则返回 null 8 if (mavContainer.isRequestHandled()) { 9 return null; 10 } 11 // 若 mavContainer未处理,基于mavContainer生成ModelAndView对象 12 ModelMap model = mavContainer.getModel(); 13 // 创建 ModelAndView 对象,并设置相关属性 14 ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, mavContainer.getStatus()); 15 16 // 如果mavContainer里的view不是string类型,强转为View类型,则设置到mv中 17 if (!mavContainer.isViewReference()) { 18 mav.setView((View) mavContainer.getView()); 19 } 20 // 重定向的处理 21 if (model instanceof RedirectAttributes) { 22 Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes(); 23 HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class); 24 if (request != null) { 25 RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes); 26 } 27 } 28 // 返回ModelAndView对象 29 return mav; 30 }
1、更新Model属性处理
ModelFactory#updateModel() 核心代码:
1 // Session属性处理器 2 private final SessionAttributesHandler sessionAttributesHandler; 3 4 // 更新Model属性 5 public void updateModel(NativeWebRequest request, ModelAndViewContainer container) throws Exception { 6 // 获取ModelAndViewContainer的Model属性 7 ModelMap defaultModel = container.getDefaultModel(); 8 // 判断ModelAndViewContainer中的SessionStatus是否为已完成 9 if (container.getSessionStatus().isComplete()){ 10 // 清理WebRequest请求中的attribute属性 11 this.sessionAttributesHandler.cleanupAttributes(request); 12 } 13 else { 14 // 将model属性设置到WebRequest请求 15 this.sessionAttributesHandler.storeAttributes(request, defaultModel); 16 } 17 // 请求是否未处理完成,ModelAndViewContainer中的model为默认的Model类型 18 if (!container.isRequestHandled() && container.getModel() == defaultModel) { 19 // 将数据绑定结果设置到Model属性中 20 updateBindingResult(request, defaultModel); 21 } 22 }
1.1、判断ModelAndViewContainer中的Session属性处理标识是否为已完成,若为已完成,则清除WebReqquest中的Session属性;若未完成,则将ModelAndViewContainer中的mode属性设置到WebRequest请求中。
1.2、Request请求未处理器完成,ModelAndViewContainer中的model为默认的Model类型,将数据绑定的结果设置到Model属性中。
2、ModelAndViewContainer请求处理判断
2.1、ModelAndViewContainer已处理,返回null
2.2、ModelAndViewContainer未处理
创建ModelAndView对象,并用ModelAndViewContainer对象中的Model属性、View属性初始化创建的ModelAndView对象。
1 // ModelAndView构造器 2 public ModelAndView(@Nullable String viewName, @Nullable Map<String, ?> model, @Nullable HttpStatus status) { 3 // 设置view视图 4 this.view = viewName; 5 // 设置model属性 6 if (model != null) { 7 getModelMap().addAllAttributes(model); 8 } 9 // 设置status状态 10 this.status = status; 11 }
如果mavContainer里的view不是string类型,强转为View类型,则设置到mv中;若mavContainer里的view是RedirectAttributes类型,获取重定向的属性值flashAttributes设置到WebRequest对象的attributes中,填充WebRequest对象。
3、Controller执行完成,返回ModelAndView对象
标签:SpringMVC,add,mavContainer,Controller,源码,处理器,返回值,new,属性 From: https://www.cnblogs.com/RunningSnails/p/17128123.html