[{"type":"Heading1","children":[{"text":"目录"}],"slateId":"O-aEkZUZNElu30OEI_aE8"},{"type":"Paragraph","slateId":"oe3utYlykZVRgxQDB2NNC","children":[{"text":"0. 背景"}]},{"type":"Paragraph","slateId":"Zu1WFcI-17FZjOUdb3BAL","children":[{"text":"1.嵌入式Servlet容器（WebServer）的自动装配"}]},{"type":"Paragraph","slateId":"thdCwS34hOhhQxIylxSbG","children":[{"text":"2.DispatcherServlet的自动装配逻辑"}]},{"type":"Paragraph","slateId":"IhUSAMOIVZsEFpxZgA--Y","children":[{"text":"3.Spring WebMVC相关组件的自动装配"}]},{"type":"Paragraph","slateId":"B7ems0phcGeHRNRolYZEu","children":[{"text":"4.DispatcherServlet向WebServer注册过程："}]},{"type":"Paragraph","slateId":"1kaXEiI8a7Uvvfoirxds7","children":[{"text":"5.DispatcherServlet的初始化逻辑"}]},{"type":"Paragraph","slateId":"_OeFzoqrwhYIIdZ6ym-XD","children":[{"text":"6.DispatcherServlet的核心分发逻辑"}]},{"type":"Paragraph","slateId":"4cPo20EU0sU_vbEv5zVY_","children":[{"text":"7.如何找到请求对应的HandlerMethod？（HandlerMapping的处理逻辑）"}]},{"type":"Paragraph","slateId":"rxUrWpg3Ru2xPFrRip9Sb","children":[{"text":"8. HandlerMethod被找到后如何执行? 异步与同步的处理区别？"}]},{"type":"Paragraph","slateId":"a07oSobZRTl7glOrWthsb","children":[{"text":"（1）异步MVC模型"}]},{"type":"Paragraph","slateId":"Twd4RTBrlWa_95oKsIFO2","children":[{"text":"（2）同步MVC模型"}]},{"type":"Paragraph","slateId":"Ayls49LsoeEkkgvTJ1AFh","children":[{"text":""}]},{"type":"Heading1","slateId":"Tons2pURx-z02BcqnEclU","children":[{"text":"0. 背景"}]},{"type":"Paragraph","children":[{"text":"1.嵌入式 Servlet 容器（如 Tomcat）是“运行 Servlet 的服务器”，而 DispatcherServlet 是“运行在容器中的一个具体 Servlet 实例”。是“平台 vs 应用”的关系。"}],"slateId":"93WfrgN2LdBrDQfQFiQec"},{"type":"Paragraph","slateId":"Pk9WoKrJUakAfxjxEiaLE","children":[{"text":"2.在 RESTful 风格的 Spring MVC 应用中，通常不使用传统的视图解析器（如 InternalResourceViewResolver），而是直接返回数据（如 JSON、XML），由 HttpMessageConverter 机制负责序列化，跳过视图解析（View Resolution）阶段。"}]},{"type":"Paragraph","slateId":"JLVgSBQOZ3w4N-2CwP933","children":[{"text":"3.嵌入式容器（如 Jetty）是一个完整的 "},{"text":"Web 服务器","bold":true},{"text":"实现，它内部包含："}]},{"type":"Paragraph","slateId":"DbRKwyjYuwbfOAOh_SKiD","children":[{"text":" Connector（处理 TCP/HTTP）"}]},{"type":"Paragraph","slateId":"lVHerXMHkPjIqUVHL92AZ","children":[{"text":" Engine / Host / Context（虚拟主机和 Web 应用）"}]},{"type":"Paragraph","slateId":"7TJwh0myFrbmCfMkeX64x","children":[{"text":" Servlet 容器（Container）：负责加载和调用 Servlet"}]},{"type":"Paragraph","slateId":"UII9SEY6xwMlVVxRtp678","children":[{"text":" 它本身不是一个 Servlet，而是运行 Servlet 的环境。"}]},{"type":"Paragraph","slateId":"pdsKamLn9eIkGNp2mXp2V","children":[{"text":"4.对第三点的举例："}]},{"type":"Paragraph","slateId":"NjGJnzml24cyR_YMCNdlu","children":[{"text":" a. 当请求 GET /api/users到达 Jetty"}]},{"type":"Paragraph","slateId":"74CFIVYdDah1aSSXI0QnW","children":[{"text":" b. Jetty 发现路径 /api/users匹配 DispatcherServlet（DispatcherServlet向Jetty注册时，配置映射是 /）"}]},{"type":"Paragraph","slateId":"BMhqwEDqAUQTn4-u23N04","children":[{"text":" c. Jetty 调用：dispatcherServlet.service(request, response)"}]},{"type":"Paragraph","slateId":"k8uDXGuIndW7Zl0ZpAdcp","children":[{"text":" d. DispatcherServlet内部查找 @GetMapping(\"/api/users\")的方法并执行"}]},{"type":"Paragraph","slateId":"mSg_iJyhurTVGGTEErLkg","children":[{"text":"5. 🔁 请求流程：客户端 → Jetty（解析 Header/Body） → Servlet API（HttpServletRequest） → Spring MVC（DispatcherServlet） → Controller"}]},{"type":"Paragraph","slateId":"sYiQsq7uwS8xZwDwD_XjU","children":[{"text":"6.自动装配顺序为：Servlet容器 -> MVC的前端控制器（DispatchServlet） -> SpringMVC的组件（HttpMessageConverter、HandlerMapping）"}]},{"type":"Paragraph","slateId":"mpDo-AEzFKB45XDrWjjla","children":[{"text":""}]},{"type":"Heading1","slateId":"9ouwNwHcAyj6qTTqx9DJg","children":[{"text":"1.嵌入式Servlet容器（WebServer）的自动装配"}]},{"type":"Paragraph","children":[{"text":"嵌入式Servlet容器的自动配置取自yaml文件中的“server.*”"}],"slateId":"N5J7BS9LBFWTCr7ienqlV"},{"type":"Paragraph","slateId":"HJJYGVmqNust35WyV2jVk","children":[{"text":""}]},{"type":"Paragraph","slateId":"GCrHl8UlcAw9qRmyu2kf8","children":[{"text":"注入嵌入式Servlet容器的相关Bean："}]},{"type":"Paragraph","slateId":"aevoFdvEr7xDT9biWswTT","children":[{"text":"Servlet容器三大组件： Servlet、 Filter、 Listener"}]},{"type":"Paragraph","slateId":"87d7Pwl2OkKkZaith57gS","children":[{"text":"ServletWebServerFactoryAutoConfiguration.class : 负责自动装配嵌入式Servlet容器，如tomcat\\jetty\\undertow"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// @Import注解注入一个BPP，这个BPP的作用是：在所有bean初始化完成后，扫描所有WebServerFactoryCustomizer.class的bean,并调用他们的customize()方法\n// 如自定义一个Servlet配置器MyxxxWebServerFactoryCustomizer.class，实现customize()方法：在该方法中可以设置port等属性，来替换yaml中server.port的配置值\n@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,\n ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,\n ServletWebServerFactoryConfiguration.EmbeddedJetty.class,\n ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })\npublic class ServletWebServerFactoryAutoConfiguration {\n ...........\n \n public static class BeanPostProcessorsRegistrar implements ImportBeanDefinitionRegistrar, BeanFactoryAware {\n @Override\n public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {\n registerSyntheticBeanIfMissing(registry, \"webServerFactoryCustomizerBeanPostProcessor\",\n WebServerFactoryCustomizerBeanPostProcessor.class);\n registerSyntheticBeanIfMissing(registry, \"errorPageRegistrarBeanPostProcessor\",\n ErrorPageRegistrarBeanPostProcessor.class);\n }\n private void registerSyntheticBeanIfMissing(BeanDefinitionRegistry registry, String name, Class beanClass) {\n if (ObjectUtils.isEmpty(this.beanFactory.getBeanNamesForType(beanClass, true, false))) {\n RootBeanDefinition beanDefinition = new RootBeanDefinition(beanClass);\n beanDefinition.setSynthetic(true);\n registry.registerBeanDefinition(name, beanDefinition);\n }\n }\n }\n}\n\n// 根据xml导入jar包来决定注入哪个嵌入式容器的Bean\n// 如使用的是tomcat作为嵌入式容器，则tomcat-starter这个jar包将会导入Tomcat.class\n// @ConditionalOnClass({ Tomcat.class }) 会检查classpath下有没有Tomcat.class这个类，有则向ioc注入TomcatServletWebServerFactory.class的BeanDefinition\n\n@Configuration(proxyBeanMethods = false)\nclass ServletWebServerFactoryConfiguration {\n @Configuration(proxyBeanMethods = false)\n @ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class })\n @ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)\n static class EmbeddedTomcat {\n @Bean\n TomcatServletWebServerFactory tomcatServletWebServerFactory(\n ObjectProvider connectorCustomizers,\n ObjectProvider contextCustomizers,\n ObjectProvider> protocolHandlerCustomizers) {\n TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();\n .........\n return factory;\n }\n }\n /**\n * Nested configuration if Jetty is being used.\n */\n @Configuration(proxyBeanMethods = false)\n @ConditionalOnClass({ Servlet.class, Server.class, Loader.class, WebAppContext.class })\n @ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)\n static class EmbeddedJetty {\n @Bean\n JettyServletWebServerFactory jettyServletWebServerFactory(ObjectProvider serverCustomizers) {\n JettyServletWebServerFactory factory = new JettyServletWebServerFactory();\n .......\n return factory;\n }\n }\n /**\n * Nested configuration if Undertow is being used.\n */\n @Configuration(proxyBeanMethods = false)\n @ConditionalOnClass({ Servlet.class, Undertow.class, SslClientAuthMode.class })\n @ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)\n static class EmbeddedUndertow {\n @Bean\n UndertowServletWebServerFactory undertowServletWebServerFactory(\n ObjectProvider deploymentInfoCustomizers, ObjectProvider builderCustomizers) {\n UndertowServletWebServerFactory factory = new UndertowServletWebServerFactory();\n .......\n return factory;\n }\n @Bean\n UndertowServletWebServerFactoryCustomizer undertowServletWebServerFactoryCustomizer(\n ServerProperties serverProperties) {\n return new UndertowServletWebServerFactoryCustomizer(serverProperties);\n }\n }\n}"}],"slateId":"P7N1IxcEjuzlSBB8qbRoS"}],"slateId":"XxnjgmVn9rXRJOwJ-Friq"},{"type":"Heading1","slateId":"mib9qCGRL9qiNrz8XXaqY","children":[{"text":"2.DispatcherServlet的自动装配逻辑"}]},{"type":"Paragraph","children":[{"text":"DispatcherServlet的自动装配属性取自yaml文件中“spring.mvc.*”"}],"slateId":"h0gXjt9VOVIn_f2DwNHNv"},{"type":"Paragraph","slateId":"3726RmmAs4MChf4_a1vlz","children":[{"text":""}]},{"type":"Paragraph","slateId":"W9zmw_85Ro3krOHz6elbL","children":[{"text":"DispatcherServletAutoConfiguration.class:"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"@AutoConfiguration(after = ServletWebServerFactoryAutoConfiguration.class) //确保webServer（Servlet容器）已准备好： DispatcherServlet必须在ServletWebServiceFactory被装配后再进行自动装配\n@ConditionalOnWebApplication(type = Type.SERVLET)\n@ConditionalOnClass(DispatcherServlet.class) // 确保 spring-webmvc 在 classpath（否则无法创建 DispatcherServlet）\npublic class DispatcherServletAutoConfiguration {\n \n // 内部配置类：创建 DispatcherServlet Bean，并注入IOC容器中\n @Configuration(proxyBeanMethods = false)\n @Conditional(DefaultDispatcherServletCondition.class)\n @ConditionalOnClass(ServletRegistration.class)\n @EnableConfigurationProperties(WebMvcProperties.class)\n protected static class DispatcherServletConfiguration {\n @Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)\n public DispatcherServlet dispatcherServlet(WebMvcProperties webMvcProperties) {\n DispatcherServlet dispatcherServlet = new DispatcherServlet();\n ....... // 将从yaml的sping.mvc.*读取的配置写入DispatcherServlet\n return dispatcherServlet;\n }\n }\n \n // 内部配置类：向IOC注册一个ServletContextInitializer.class(DispatcherServletRegistrationBean是ServletContextInitializer接口的实现类)\n // 在ServletContext初始化完成后，由WebServer调用回调函数DispatcherServletRegistrationBean.register()，将DispatcherServlet注册到WebServer中（详见第四章节）\n @Configuration(proxyBeanMethods = false)\n @Conditional(DispatcherServletRegistrationCondition.class)\n @ConditionalOnClass(ServletRegistration.class)\n @EnableConfigurationProperties(WebMvcProperties.class)\n @Import(DispatcherServletConfiguration.class)\n protected static class DispatcherServletRegistrationConfiguration {\n @Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)\n @ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)\n public DispatcherServletRegistrationBean dispatcherServletRegistration(DispatcherServlet dispatcherServlet, WebMvcProperties webMvcProperties, ObjectProvider multipartConfig) {\n DispatcherServletRegistrationBean registration = new DispatcherServletRegistrationBean(dispatcherServlet,\n webMvcProperties.getServlet().getPath());\n registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);\n registration.setLoadOnStartup(webMvcProperties.getServlet().getLoadOnStartup());\n multipartConfig.ifAvailable(registration::setMultipartConfig);\n return registration;\n }\n }\n}"}],"slateId":"tcxkJHKc9-f5o_26i1RhS"}],"slateId":"_lS-ZtN45ufua_UOn-Uph"},{"type":"Heading1","slateId":"RXVy-7hSB14tluIKJfDpn","children":[{"text":"3.Spring WebMVC相关组件的自动装配"}]},{"type":"Paragraph","children":[{"text":"注入MVC相关的Bean，由"},{"text":"WebMvcAutoConfiguration.class","bold":true},{"text":"完成"}],"slateId":"2-C6XO9nWFJpIYwk9t4V7"},{"type":"OrderedList","children":[{"type":"ListItem","slateId":"mOLLtQKKEVwhHwVvsEedB","children":[{"text":"HttpMessageConverter: javaBean转化为restful接口的数据"}]},{"type":"ListItem","slateId":"5kKfy7reYMweAS-QKPD0c","children":[{"text":"MessageCodesResolver : 定义错误代码生成规则"}]},{"type":"ListItem","slateId":"p3euh7lcD2k9Abf_6brFV","children":[{"text":"ConfigurableWebBindingInitializer: 初始化WebDataBinder，binder的作用是将json参数绑定为一个JavaBean"}]},{"type":"ListItem","slateId":"Fyc4P6ZVv3oKftwLbfDgM","children":[{"text":"RequestMappingHandlerMapping"}]}],"slateId":"P1jl5Na9LuNMA6CwiWv5K"},{"type":"Paragraph","slateId":"gV8pXnPEdHq3SQGrgkejv","children":[{"text":"这里以RequestMappingHandlerMapping的自动装配为切入点解析代码："}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"@AutoConfiguration(.......)\npublic class WebMvcAutoConfiguration {\n ........... \n @Configuration(proxyBeanMethods = false)\n @EnableConfigurationProperties(WebProperties.class)\n public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration implements ResourceLoaderAware {\n .....\n }\n}\n\n// 有如下继承关系：EnableWebMvcConfiguration -extend-> DelegatingWebMvcConfiguration -extend-> WebMvcConfigurationSupport\n// 所以RequestMappingHandlerMapping的自动装配落到了WebMvcConfigurationSupport头上\npublic class WebMvcConfigurationSupport implements ApplicationContextAware, ServletContextAware {\n @Bean\n public RequestMappingHandlerMapping requestMappingHandlerMapping(\n @Qualifier(\"mvcContentNegotiationManager\") ContentNegotiationManager contentNegotiationManager,\n @Qualifier(\"mvcConversionService\") FormattingConversionService conversionService,\n @Qualifier(\"mvcResourceUrlProvider\") ResourceUrlProvider resourceUrlProvider) {\n \n // 创建RequestHandlerMapping实例\n RequestMappingHandlerMapping mapping = createRequestMappingHandlerMapping();\n mapping.setOrder(0);\n mapping.setContentNegotiationManager(contentNegotiationManager);\n\n initHandlerMapping(mapping, conversionService, resourceUrlProvider);\n .......\n return mapping;\n }\n}\n\nprivate void initHandlerMapping(@Nullable AbstractHandlerMapping mapping, FormattingConversionService conversionService, ResourceUrlProvider resourceUrlProvider) {\n if (mapping == null) {\n return;\n }\n ......\n // 获取所有已经注册的Interceptor，将他们的引用写入RequestHandlerMapping的成员变量，this.interceptors\n mapping.setInterceptors(getInterceptors(conversionService, resourceUrlProvider));\n mapping.setCorsConfigurations(getCorsConfigurations());\n}"}],"slateId":"NR5KyQ-tycspWe5Lk00OJ"}],"slateId":"W6SrtUWbZpAzXt2VJj9xP"},{"type":"Paragraph","slateId":"jCSVkNl9YttUNlhjGxkik","children":[{"text":"ps:","bold":true},{"text":" 这里只看到了注册Interceptor到RequestMappingInfoHandlerMapping中，那handlerMethod是何时注册的呢？"}]},{"type":"Paragraph","slateId":"8TbHkfrn_riTdO_dtJpHg","children":[{"text":"简述：","bold":true},{"text":"RequestMappingInfoHandlerMapping实现了InitializingBean接口，会在RequestMappingInfoHandlerMapping的bean初始化时（所有BPP执行postProcessBeforeInitialization（）完成后），调用回调函数afterPropertiesSet()去将从IOC中扫描到的HandlerMethod写入this.mappingRegistry中"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"RequestMappingInfoHandlerMapping -extend-> AbstractHandlerMethodMapping -extend-> AbstractHandlerMapping\n |-implement-> InitializingBean\n所以在RequestMappingHandlerMapping的Bean注入到IOC，并初始化依赖后，会调用回调方法\n\n// RequestMappingHandlerMapping.class\n@Override\npublic void afterPropertiesSet() {\n .......\n super.afterPropertiesSet();\n}\n\n// AbstractHandlerMethodMapping.class\n@Override\npublic void afterPropertiesSet() {\n initHandlerMethods();\n}\n\nprotected void initHandlerMethods() {\n // 从IOC中获取所有Bean，并依次遍历\n for (String beanName : getCandidateBeanNames()) {\n processCandidateBean(beanName);\n }\n}\n\nprotected void processCandidateBean(String beanName) {\n Class beanType = null;\n // 获取bean对应的java.lang.class对象\n beanType = obtainApplicationContext().getType(beanName);\n\n // 重点！！：isHandler()判断类是否带有@Controller注解\n if (beanType != null && isHandler(beanType)) {\n detectHandlerMethods(beanName);\n }\n}\n\n// 这里大量使用反射来获取类与类包含的方法\nprotected void detectHandlerMethods(Object handler) {\n Class handlerType = (handler instanceof String beanName ?\n obtainApplicationContext().getType(beanName) : handler.getClass());\n\n if (handlerType != null) {\n Class userType = ClassUtils.getUserClass(handlerType);\n \n // 遍历该类的所有方法（包括父类）\n // Method属于java.lang.reflect\n Map methods = MethodIntrospector.selectMethods(userType,\n (MethodIntrospector.MetadataLookup) method -> {\n \n // 判断是否是 @RequestMapping 方法\n return getMappingForMethod(method, userType); \n });\n \n methods.forEach((method, mapping) -> {\n Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);\n \n // 向RequestMappingHandlerMapping的成员变量this.mappingRegistry中注册HandlerMethod（也就是某个Controller中的某个RequestMapping方法）\n registerHandlerMethod(handler, invocableMethod, mapping);\n });\n }\n}\n"}],"slateId":"VDrAsYjaJ05hhQFhkaHLy"}],"slateId":"sqo6LIGxDk6giAsHj6L1k"},{"type":"Heading1","slateId":"ftmla0mjXUD5hvQ1QQ7B_","children":[{"text":"4.DispatcherServlet向WebServer注册过程："}]},{"type":"Paragraph","children":[{"text":"详细内容参考SpringBoot启动过程的 SpringApplication.run().refresh().onRefresh().createWebServer()"}],"slateId":"kHLOdyBQUtdmujU8IWKBM"},{"type":"Heading1","slateId":"W8TDxMI97nLQMi6sWTAdx","children":[{"text":"5.DispatcherServlet的初始化逻辑"}]},{"type":"Paragraph","children":[{"text":"要搞清DispatchServlet如何初始化？就需要先搞明白DispatchServlet是什么，实现了什么接口："}],"slateId":"QOt9k4n0FM5CSje45SDk6"},{"type":"Paragraph","slateId":"sW7e8aCOPzZlN6XgE3BaO","children":[{"text":" 1.Java EE（现 Jakarta EE）的 Servlet 规范（主流Servlet容器、或者说WebServer都遵从该规范，如Jetty、Tomcat）定义了处理 HTTP 请求的标准编程模型。其核心接口是 jakarta.servlet.Servlet（ "},{"text":"所有 Servlet 必须实现这个接口","bold":true},{"text":"）"}]},{"type":"Paragraph","slateId":"HcIZ3OEq_RUZ-IPYZlFCt","children":[{"text":" 2.同目录下有HttpServlet抽象类（实现了Servlet接口），是 Servlet 规范为 HTTP 协议提供的标准基类，是事实上的“统一 HTTP Servlet 抽象”。"}]},{"type":"Paragraph","slateId":"qp62_rUDrVfSDujH6KI1A","children":[{"text":" 3.任何基于 Servlet 的框架（Spring MVC、Struts、Jersey 等）最终都会注册一个或多个 HttpServlet 子类到容器中；"}]},{"type":"Paragraph","slateId":"UzFDvgSItyMWSoY6p0jvx","children":[{"text":" 例如："}]},{"type":"Paragraph","slateId":"WLj9GU6XPHXXhx6llPauI","children":[{"text":" Spring MVC → DispatcherServlet -extends-> FrameworkServlet -extends-> HttpServletBean -extends-> HttpServlet -implement-> Servlet"}]},{"type":"Paragraph","slateId":"kM0-6LutAx8ZNfXKSmMto","children":[{"text":""}]},{"type":"Paragraph","slateId":"2KEyCp2wDpusYCBnw_96R","children":[{"text":"谁触发初始化？初始化的入口函数是？：DispatcherServlet 作为一个标准的 Servlet，其初始化由 Servlet 容器（如 Tomcat）触发，调用其 init(ServletConfig config) 方法。"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// org.springframework.web.servlet.HttpServletBean\n@Override\npublic final void init() throws ServletException {\n ........\n // 调用子类扩展点\n initServletBean();\n}\n\n// org.springframework.web.servlet.FrameworkServlet\n@Override\nprotected final void initServletBean() throws ServletException {\n ................\n try {\n // 关键：初始化 WebApplicationContext\n this.webApplicationContext = initWebApplicationContext();\n }\n catch (ServletException | RuntimeException ex) {\n logger.error(\"Context initialization failed\", ex);\n throw ex;\n }\n ...........\n}\n\nprotected WebApplicationContext initWebApplicationContext() {\n WebApplicationContext wac;\n ...........\n // 触发 onRefresh（模板方法，由 DispatcherServlet 实现）\n if (!this.refreshEventReceived) {\n synchronized (this.onRefreshMonitor) {\n onRefresh(wac);\n }\n }\n .........\n return wac;\n}\n\n// org.springframework.web.servlet.DispatcherServlet\n@Override\nprotected void onRefresh(ApplicationContext context) {\n initStrategies(context);\n}\n// 该方法初始化所有 Spring MVC 的九大策略组件：\nprotected void initStrategies(ApplicationContext context) {\n initMultipartResolver(context);\n initLocaleResolver(context);\n initThemeResolver(context);\n initHandlerMappings(context); // 向DispatcherServlet中注册HandlerMapping组件\n initHandlerAdapters(context);\n initHandlerExceptionResolvers(context);\n initRequestToViewNameTranslator(context);\n initViewResolvers(context);\n initFlashMapManager(context);\n}"}],"slateId":"wBEpS67LwCBCIY5MLslI5"}],"slateId":"mbH1whnsAnHlNINoz3QT1"},{"type":"Paragraph","slateId":"yv2w_offXptAi0Hk_NOc7","children":[{"text":"✅ HandlerMapping 是用来查找和匹配 @Controller 中处理方法的“路由器”，处理 @RequestMapping、@GetMapping 等注解"}]},{"type":"Paragraph","slateId":"UwK2kBf-w9PCbLyD5w5Zx","children":[{"text":"这里展开最常用的HandlerMapping的初始化逻辑来讲："}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// org.springframework.web.servlet.DispatcherServlet\nprivate void initHandlerMappings(ApplicationContext context) {\n this.handlerMappings = null;\n\n if (this.detectAllHandlerMappings) { // 在Springboot框架下detectAllHandlerMappings始终为True\n // 1. 查找 ApplicationContext 中所有类型为 HandlerMapping 的 Bean（包括祖先上下文）\n Map matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);\n if (!matchingBeans.isEmpty()) {\n // 注册到DispatcherServlet的成员变量this.handlerMappings中\n this.handlerMappings = new ArrayList<>(matchingBeans.values());\n // 2. 按 @Order 或 Ordered 接口排序\n AnnotationAwareOrderComparator.sort(this.handlerMappings);\n }\n }\n else {\n ...............\n }\n }"}],"slateId":"_Cu5pUvWUtH-ic2JKp0ey"}],"slateId":"ObOWZ_vkLStwCz_3RpjaF"},{"type":"Paragraph","slateId":"RQdOF02v68jX0EBw_YZR9","children":[{"text":"在通常情况下，SpringBoot中主要的HandlerMapping是webmvc自动装配的RequestMappingHandlerMapping.class"}]},{"type":"Heading1","slateId":"A_yi9_B5xr73iQ3OKEZnH","children":[{"text":"6.DispatcherServlet的核心分发逻辑"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"HTTP Request\n │\n ▼\nDispatcherServlet.doDispatch()\n │\n ├── checkMultipart() → 文件上传处理\n │\n ├── getHandler() → RequestMappingHandlerMapping 匹配 @RequestMapping\n │ └── 返回 HandlerExecutionChain (HandlerMethod + 拦截器)\n │\n ├── getHandlerAdapter() → RequestMappingHandlerAdapter\n │\n ├── applyPreHandle() → 拦截器 preHandle (可中断)\n │\n ├── ha.handle() → \n │ ├── 参数解析 (@PathVariable, @RequestBody...)\n │ ├── 反射调用 Controller 方法\n │ └── 返回值处理 (@ResponseBody → 写 JSON)\n │\n ├── applyPostHandle() → 拦截器 postHandle\n │\n └── processDispatchResult()\n ├── 异常？→ HandlerExceptionResolver\n └── 视图？→ View.render() (REST API 跳过)\n │\n ▼\n HTTP Response"}],"slateId":"ZPiwrHmxwbcaGYntutPrt"}],"slateId":"C3mV1wtDDSs-Hl74zMLbe"},{"type":"Paragraph","slateId":"8Uhwl7limn3MeDcZuWmsg","children":[{"text":""}]},{"type":"Paragraph","slateId":"caAcns-xBSlGFz-BxH9uT","children":[{"text":"DispatcherServlet.doDispatch() 源码分析："}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {\n HttpServletRequest processedRequest = request;\n HandlerExecutionChain mappedHandler = null;\n boolean multipartRequestParsed = false;\n\n try {\n ModelAndView mv = null;\n Exception dispatchException = null;\n\n try {\n //1.[文件上传]如果是 multipart 请求，将processedRequest包装成 MultipartHttpServletRequest类型\n processedRequest = checkMultipart(request);\n multipartRequestParsed = (processedRequest != request);\n\n //2. 【核心】getHandler()会首先获取HandlerMapping\n // 然后HandlerMapping 根据 URL 找到对应的 Handler（即 @Controller 中的方法）与 Interceptor\n // 返回值mappedHandler是HandlerExecutionChain类型，其将所有Handler与Interceptor按顺序包装成责任链模式\n mappedHandler = getHandler(processedRequest);\n ......\n \n // 3. handler有不同的声明定义方案，这里使用适配器模式来统一所有handler的出入参\n // 通常情况下，Spring 的REST风格MVC场景下，RequestMappingInfoHandlerMapping找到的是Handler是 HandlerMethod类型\n // HandlerMethod对应的适配器，就是RequestMappingHandlerAdapter.class\n HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());\n\n //4. 【拦截器 preHandle】执行所有拦截器的 preHandle()\n // 如果其中任意一个 preHandle() 返回 false，后续拦截器的 preHandle 不再执行，且请求中断（不会进入 Controller），并开始倒序执行已通过拦截器的 afterCompletion。\n if (!mappedHandler.applyPreHandle(processedRequest, response)) {\n // 拦截器中断了请求，则立即返回\n return;\n }\n // 5. 【核心调用】真正调用 Controller 方法的地方！后面会展开解析如何调用的Controller 方法\n mv = ha.handle(processedRequest, response, mappedHandler.getHandler());\n \n // 6. 如果开启了异步（如 @Async, DeferredResult），提前返回\n if (asyncManager.isConcurrentHandlingStarted()) {\n // 异步请求会两次调用doDispatch()方法，第一次调用会走到这\n // 异步已启动 → 直接 return，不执行 applyDefaultViewName / processDispatchResult ,释放当前Servlet线程\n return;\n }\n // 7.【视图渲染】如果没有返回值（如 @ResponseBody），mv == null；否则渲染视图\n applyDefaultViewName(processedRequest, mv);\n mappedHandler.applyPostHandle(processedRequest, response, mv);\n }\n catch (Exception ex) {\n dispatchException = ex;\n }\n catch (Throwable err) {\n dispatchException = new ServletException(\"Handler dispatch failed: \" + err, err);\n }\n // 8. 异常处理 & 渲染(RestFul风格不涉及渲染这一步)\n 如果有异常 → 调用 HandlerExceptionResolver（如 @ControllerAdvice）；\n 如果无异常且 mv != null → 调用 View.render() 渲染页面；\n 如果 mv == null（如 @ResponseBody）→ 什么也不做（数据已在步骤 5 写入 response）。\n processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);\n }\n catch (Exception ex) {\n triggerAfterCompletion(processedRequest, response, mappedHandler, ex);\n }\n catch (Throwable err) {\n triggerAfterCompletion(processedRequest, response, mappedHandler,\n new ServletException(\"Handler processing failed: \" + err, err));\n }\n finally {\n ......\n // 【拦截器 afterCompletion】无论成功失败都执行\n }\n}\n\n// 上述第2步的展开\n protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {\n if (this.handlerMappings != null) {\n // 获取到第一个匹配的HandlerMapping后立即执行，然后中断遍历并返回\n for (HandlerMapping mapping : this.handlerMappings) {\n // 通常情况下，这里获取到的mapping，是RequestMappingHandlerMapping\n // HandlerMapping可以理解为一个注入到IOC容器的Bean，其注入IOC容器时，就已经按照规则扫描出所有HandlerMethod与路径的映射，并存储到实例变量this.mappingRegistry中；HandlerMapping.getHandler(request)就是拿Request的请求路径去匹配this.mappingRegistry中的HandlerMethod\n // 下文展开HandlerMapping.getHandler(request)的处理逻辑\n HandlerExecutionChain handler = mapping.getHandler(request);\n if (handler != null) {\n return handler;\n }\n }\n }\n return null;\n }"}],"slateId":"TBoa-Fs95I-kSLPIDStS_"}],"slateId":"1Q1p2zIeIGZoMQ_5WbkJu"},{"type":"Heading1","slateId":"9a-Gut-kjrofWy9cPr2E9","children":[{"text":"7.如何找到请求对应的HandlerMethod？（HandlerMapping的处理逻辑）"}]},{"type":"Paragraph","children":[{"text":"RequestMappingHandlerMapping.getHandler(request)"}],"slateId":"BsyUBAC28CtlAw-4qRjp3"},{"type":"Paragraph","slateId":"_bQpSc_OD8L5Frur0ecof","children":[{"text":" 该方法返回一个HandlerExecutionChain对象，其主要是包含了："}]},{"type":"Paragraph","slateId":"E9IiJf5i-O8yjBUx1Y9pd","children":[{"text":" 1.当前请求路径对应的 HandlerMethod handler"}]},{"type":"Paragraph","slateId":"6RSydXt9O4GLa_-30T-8E","children":[{"text":" 2.拦截器链 List interceptorList ：动态匹配这次请求需要执行的拦截器(根据拦截器注册时指定的匹配规则)"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// 有如下继承关系：\n// RequestMappingInfoHandlerMapping --extend--> AbstractHandlerMethodMapping --extend--> AbstractHandlerMapping --implement--> HandlerMapping\n\npublic interface HandlerMapping {\n HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;\n}\n\n// AbstractHandlerMapping.class\n// 基类AbstractHandlerMapping.class将getHandler()实现为模板方法\npublic final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {\n //1.【核心】这个抽象方法由子类实现，根据 request 找到具体的 Handler 对象\n Object handler = getHandlerInternal(request);\n if (handler != null) {\n //2. 兼容性：如果返回的是 String（如 Bean 名称），则从 ApplicationContext 获取实例\n if (handler instanceof String) {\n handler = obtainApplicationContext().getBean((String) handler);\n }\n \n //3.【关键！】构建执行链，并注入当前 HandlerMapping 的拦截器\n HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);\n return executionChain;\n }\n return null;\n}\n\n// 上述第3步：根据当前的请求路径，动态向HandlerExecutionChain加入此次请求处理的Interceptor\nprotected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {\n // ！！！this.adaptedInterceptor是Spring mvc的自动装配逻辑在注入RequestMappingInfoHandlerMapping的Bean时，从ioc容器中取出的所有拦截器bean的引用组成的List\n for (HandlerInterceptor interceptor : this.adaptedInterceptors) {\n if (interceptor instanceof MappedInterceptor mappedInterceptor) {\n if (mappedInterceptor.matches(request)) {\n chain.addInterceptor(mappedInterceptor.getInterceptor());\n }\n }\n else {\n chain.addInterceptor(interceptor);\n }\n }\n return chain;\n }\n\n\n// 上述第1步：匹配HandlerMethod\n// RequestMappingInfoHandlerMapping.class -extend-> AbstractHandlerMethodMapping.class\n// RequestMappingInfoHandlerMapping实现了模版方法中的抽象方法getHandlerInternal()\nprotected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {\n try {\n return super.getHandlerInternal(request);\n }\n }\n \n // AbstractHandlerMethodMapping.class\n //实际实现逻辑在RequestMappingInfoHandlerMapping的父类AbstractHandlerMethodMapping中，如下：\n protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {\n \n // 1. 使用 UrlPathHelper 解析原始 URI\n String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);\n \n // 2. 将路径存入 request 属性（供后续使用）\n request.setAttribute(LOOKUP_PATH, path);\n \n // 3.使用共享锁（读写锁）：ReentrantReadWriteLock 提高并发（适合读多写少场景）\n this.mappingRegistry.acquireReadLock();\n \n try {\n // 4. 重点：通过路径寻找HandlerMethod\n HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);\n return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);\n }\n finally {\n this.mappingRegistry.releaseReadLock();\n }\n }\n \n // ！！！this.mappingRegistry中的值由InitializingBean接口，会在RequestMappingInfoHandlerMapping的bean初始化时（所有BPP执行postProcessBeforeInitialization（）完成后），调用回调函数afterPropertiesSet()去将从IOC中扫描到的HandlerMethod写入this.mappingRegistry中\nprotected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {\n List matches = new ArrayList<>();\n \n //1：精确路径匹配（Direct Path Lookup）\n List directPathMatches = this.mappingRegistry.getMappingsByDirectPath(lookupPath);\n if (directPathMatches != null) {\n addMatchingMappings(directPathMatches, matches, request);\n }\n \n //2：全量模糊匹配（Fallback）\n // 如果第1步没找到（比如路径是 /api/users/123，而映射是 /api/users/{id}）则遍历所有已注册的 RequestMappingInfo对每个调用 getMatchingCondition(request) 做完整匹配\n // 性能代价高！即O(n)的时间复杂度；所以 Spring 强烈建议使用明确路径，避免过度依赖通配。\n if (matches.isEmpty()) {\n addMatchingMappings(this.mappingRegistry.getRegistrations().keySet(), matches, request);\n }\n \n //3: 处理匹配结果\n if (!matches.isEmpty()) {\n Match bestMatch = matches.get(0);\n \n if (matches.size() > 1) {\n // 排序：更具体的路径优先\n Comparator comparator = new MatchComparator(getMappingComparator(request));\n matches.sort(comparator);\n bestMatch = matches.get(0);\n }\n \n // 设置请求属性（供后续使用）\n request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, best))))));\n handleMatch(bestMatch.mapping, lookupPath, request);\n \n return bestMatch.getHandlerMethod();\n } else {\n // 无匹配 → 调用扩展点\n return handleNoMatch(this.mappingRegistry.getRegistrations().keySet(), lookupPath, request);\n }\n}\n\n// 做进一步深度检查\n// 只有全部条件满足，才视为“匹配”;注意：路径相同 ≠ 完全匹配！必须所有条件都通过。\n private void addMatchingMappings(Collection mappings, List matches, HttpServletRequest request) {\n for (T mapping : mappings) {\n // 该方法会检查：HTTP 方法（GET/POST）、consumes（Content-Type）、produces（Accept）、params、headers\n T match = getMatchingMapping(mapping, request);\n if (match != null) {\n matches.add(new Match(match, this.mappingRegistry.getRegistrations().get(mapping)));\n }\n }\n }"}],"slateId":"rLrBJIXawasD0LKVkxbCY"}],"slateId":"oSFG2MvdjHvARCMs-PC2-"},{"type":"Paragraph","slateId":"OQobaDv3ku4NQYinevZpE","children":[{"text":""}]},{"type":"Heading1","slateId":"9DYzg9asLDc0q2LGskUtg","children":[{"text":"8. HandlerMethod被找到后如何执行? 异步与同步的处理区别？"}]},{"type":"Paragraph","children":[{"text":"这一节是对doDispatch()方法的第5步的展开分析："}],"slateId":"75DcDrtBv9sbmrVz1PbJL"},{"type":"Paragraph","slateId":"I2OjpaC1ykzCHPh09I20J","children":[{"text":"即：RequestMappingHandlerAdapter.handle（）如何执行？"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// 有如下继承关系： RequestMappingHandlerAdapter -- extend--> AbstractHandlerMethodAdapter -- implement --> HandlerAdapter\n\npublic interface HandlerAdapter {\n @Nullable\n ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;\n}\n\npublic abstract class AbstractHandlerMethodAdapter extends WebContentGenerator implements HandlerAdapter, Ordered {\n @Override\n @Nullable\n public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {\n return handleInternal(request, response, (HandlerMethod) handler);\n }\n\n // 抽象方法：上述模版模式中的钩子，由RequestMappingHandlerAdapter来实现\n @Nullable\n protected abstract ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception;\n}"}],"slateId":"5XMkoQsojuHogKboh4mYN"}],"slateId":"44yihIsTVwyJ0ekLegkBN"},{"type":"Paragraph","slateId":"6qQEgSt9IbbB3ZwonWjX8","children":[{"text":"所以最终的调用会落到 RequestMappingHandlerAdapter.handleInternal()"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"protected ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {\n \n ModelAndView mav;\n checkRequest(request); // 检查请求方法是否支持（POST， GET ....)\n .....\n mav = invokeHandlerMethod(request, response, handlerMethod);\n return mav;\n}\n\n protected ModelAndView invokeHandlerMethod(HttpServletRequest request,\n HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {\n\n // 为了统一处理模型，同步\\异步请求都要执行获取AsyncManager的逻辑\n // AsyncManager用于存储当前异步请求的状态(每个请求都有一个独立的AsyncManager)：是否执行完成、返回值是什么、是否开始异步？\n WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);\n AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);\n asyncWebRequest.setTimeout(this.asyncRequestTimeout);\n\n asyncManager.setTaskExecutor(this.taskExecutor);\n asyncManager.setAsyncWebRequest(asyncWebRequest);\n asyncManager.registerCallableInterceptors(this.callableInterceptors);\n asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);\n\n // Obtain wrapped response to enforce lifecycle rule from Servlet spec, section 2.3.3.4\n response = asyncWebRequest.getNativeResponse(HttpServletResponse.class);\n\n ServletWebRequest webRequest = (asyncWebRequest instanceof ServletWebRequest ?\n (ServletWebRequest) asyncWebRequest : new ServletWebRequest(request, response));\n\n WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);\n ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);\n\n // 包装HandlerMapping，ServletInvocableHandlerMethod是实际执行Controller方法的对象\n ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);\n if (this.argumentResolvers != null) {\n // 注入了 Spring MVC 的核心组件argumentResolvers：解析方法参数（如 @RequestParam,@RequestBody）。\n invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);\n }\n if (this.returnValueHandlers != null) {\n // returnValueHandlers：处理方法返回值（ResponseEntity → HTTP 响应）。\n invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);\n }\n // 接下来的三行，与上述逻辑相似，即将SpringMVC相关组件的引用，注入给invocableMethod\n invocableMethod.setDataBinderFactory(binderFactory);\n invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);\n invocableMethod.setMethodValidator(this.methodValidator);\n\n // 处理视图与模型，restful类型的请求这里不会实际执行\n ModelAndViewContainer mavContainer = new ModelAndViewContainer();\n mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));\n modelFactory.initModel(webRequest, mavContainer, invocableMethod);\n mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);\n\n // 异步请求第二次进入DispatchServlet时才会进入这个逻辑（同步请求、异步请求的第一次调用不会进入该逻辑）\n if (asyncManager.hasConcurrentResult()) {\n Object result = asyncManager.getConcurrentResult();\n Object[] resultContext = asyncManager.getConcurrentResultContext();\n Assert.state(resultContext != null && resultContext.length > 0, \"Missing result context\");\n mavContainer = (ModelAndViewContainer) resultContext[0];\n asyncManager.clearConcurrentResult();\n \n // 替换当前invocableMethod，换成一个特殊的invocableMethod；\n // 这样下面的invokeAndHandle()就不会去真正调用当前请求对应的HandlerMethod，而是直接返回异步结果\n invocableMethod = invocableMethod.wrapConcurrentResult(result);\n }\n\n // 重点：真正调用HandlerMethod的地方\n // 同步调用，异步请求的的第一次调用、异步请求的的第二次调用（但invocableMethod引用指向的值已被替换）会步入下述代码逻辑：去调用请求URL对应的HandlerMethod\n invocableMethod.invokeAndHandle(webRequest, mavContainer);\n // 如果是异步请求的第一次调用，走到这就返回了\n // 如果 Controller 方法启动了异步处理（例如返回 Callable、DeferredResult），则立即返回 null，表示不进行视图渲染\n if (asyncManager.isConcurrentHandlingStarted()) {\n return null;\n }\n \n // Restful的请求，这里会返回null\n return getModelAndView(mavContainer, modelFactory, webRequest);\n }\n\n // 返回一个HandlerMethod的实现类，直接返回入参值，这样设计是为了规范化MVC的请求处理流程\n ServletInvocableHandlerMethod wrapConcurrentResult(@Nullable Object result) {\n return new ConcurrentResultHandlerMethod(result, new ConcurrentResultMethodParameter(result));\n }\n\n\n// 重点：ServletInvocableHandlerMethod.invokeAndHandle()\n// 执行handlerMethod，并根据返回值，选择适合的ReturnValueHandler（这里也体现了异步与同步处理逻辑的区别）\n public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {\n // Step 1: 解析方法参数（使用 argumentResolvers） \n Object[] args = getMethodArgumentValues(webRequest, mavContainer, providedArgs); \n\n // Step 2: 判断是否需要验证（@Valid 等） \n if (this.methodValidator != null) {\n validate(args);\n }\n \n // Step 3: 【真正调用 Controller 方法】\n Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);\n setResponseStatus(webRequest);\n .........\n try {\n // Step 4: ！！！！关键：\n // 这行代码从已经注册的HandlerMethodReturnValueHandler中选择出适合当前returnValue的HandlerMethodReturnValueHandler\n // 并调用HandlerMethodReturnValueHandler.handleReturnValue()\n // 注意：异步调用的第二次请求不会走到这\n this.returnValueHandlers.handleReturnValue(returnValue, getReturnValueType(returnValue), mavContainer, webRequest);\n }\n }\n \n // 使用反射调用Controller的方法\n // ServletInvocableHandlerMethod.invokeForRequest()\n protected Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {\n Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);\n return doInvoke(args); // 最终调用 method.invoke(bean, args) 即： return getBridgedMethod().invoke(getBean(), args);\n }"}],"slateId":"Zzc5I51NTiR0KqWty7m5A"}],"slateId":"AvRzFO2o_DckfY6XUebMm"},{"type":"Heading2","slateId":"4fOjBQG3B-ylg3PZwroWy","children":[{"text":"（1）异步MVC模型"}]},{"type":"Paragraph","slateId":"77x-DcgZ6ji4fuX-0tbhY","children":[{"text":"若果是异步返回类型，如CompletableFuture、DefferedResult, 则会选择DeferredResultMethodReturnValueHandler"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// DeferredResultMethodReturnValueHandler.handleReturnValue()\n public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {\n .......\n // 获取当前请求的AsyncManager实例，每个请求都有一个独立的AsyncManager实例，在DispatchServlet.doDispatch()时创建\n WebAsyncUtils.getAsyncManager(webRequest).startDeferredResultProcessing(result, mavContainer);\n }"}],"slateId":"AXyoOOq_CGCb-Z5MujLyB"}],"slateId":"SKibwTri-xu9e0WBPHb_4"},{"type":"ListItem","children":[{"text":"每个请求都一个对应的WebAsyncManager；每个WebAsyncManager持有一个AsyncWebRequest； "},{"text":"每个AsyncWebRequest持有一个AsyncContext（在Servlet中）","bold":true}],"slateId":"RJ4UsZpMQG1tlrmLcGLhC"},{"type":"ListItem","slateId":"hXHiy7sdlHZK1Q0ENQA2c","children":[{"text":"一个请求 → 一个 HttpServletRequest → 一个 WebAsyncManager","bold":true}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"// WebAsyncManager.startDeferredResultProcessing()\n public void startDeferredResultProcessing(final DeferredResult deferredResult, Object... processingContext) throws Exception {\n // 1.向AsyncWebRequest注册超时回调，错误回调、完成回调 (非重点，此处省略分析)\n .......\n // 2. 为请求创建AsyncContext\n startAsyncProcessing(processingContext);\n\n try {\n // 3. 关键:为 DeferredResult 设置结果处理器\n // 当异步业务逻辑执行完成，调用 deferredResult.setResult(\"OK\") 时，MVC内部会调用这个 resultHandler\n deferredResult.setResultHandler(result -> {\n // 设置异步业务逻辑的结果，并将请求（当前WebAsyncManger持有的this.asyncWebRequest）再次放入Servlet容器的待处理队列中\n // 等待容器为该请求分配新线程重新进入 DispatcherServlet\n setConcurrentResultAndDispatch(result); \n });\n }\n }\n \n \nprotected void startAsyncProcessing(Object... processingContext) {\n .......\n this.asyncWebRequest.startAsync(); // ← 调用 request.startAsync()，让Servlet 创建 AsyncContext\n}\n \nprivate void setConcurrentResultAndDispatch(Object result) {\n ....\n this.concurrentResult = result;\n this.asyncWebRequest.dispatch(); // ← 触发容器 dispatch！让异步请求第二次调用DispatchServlet.doDispatch()\n}"}],"slateId":"J-IVjMZQ577Sbs-Ptef5x"}],"slateId":"t_q5kOsQzQ-HTModf33_d"},{"type":"Heading2","children":[{"text":"（2）同步MVC模型"}],"slateId":"25LNNYI8GLsm8vERRB2-B"},{"type":"ListItem","slateId":"KIZU4ArQJ0gfv0k6YXjY9","children":[{"text":"常用情况是使用Restfu的MVC风格，也就是Controller层注释了@ResponseBody"}]},{"type":"ListItem","slateId":"GPu6d1fXR6gtioJ_MgfKG","children":[{"text":"所以HandlerMethodReturnValueHandler会选择RequestResponseBodyMethodProcessor来进行返回值处理，结果由 RequestResponseBodyMethodProcessor 处理，"},{"text":"直接写入Servlet的 HttpServletResponse 的输出流","bold":true}]},{"type":"ListItem","slateId":"famLC2BA2Vdfx5eQ1sj2V","children":[{"text":"RequestResponseBodyMethodProcessor持有List的引用, 使用 HttpMessageConverter（如 Jackson）将对象序列化为 JSON，写入响应体"}]},{"type":"CodeBlock","activeTabIndex":0,"children":[{"type":"CodeTab","language":"java","name":"","children":[{"text":"public class RequestResponseBodyMethodProcessor extends AbstractMessageConverterMethodProcessor\n implements HandlerMethodReturnValueHandler, HandlerMethodArgumentResolver {\n // 它继承了 AbstractMessageConverterMethodProcessor，后者持有 MessageConverters\n // 构造函数中会注入 List> \n @Override\n public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,\n ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws IOException, HttpMediaTypeNotAcceptableException {\n mavContainer.setRequestHandled(true);\n ServletServerHttpRequest inputMessage = createInputMessage(webRequest);\n ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);\n \n // 3. 核心调用：尝试写入消息\n // 这里会遍历内部持有的 messageConverters 列表，找到合适的转换器进行写入\n writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);\n }\n }"}],"slateId":"qXAcsQnror5rLDr6WgqNS"}],"slateId":"QcboktMoyMp5h-u2oUJ4Z"}]