Spring系列-SpringMvc父子容器启动原理剖析

惊落一身雪  金牌会员 | 2024-6-14 21:30:50 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 657|帖子 657|积分 1971

1、Spring整合SpringMVC

特性：
说到Spring整合SpringMVC唯一的体现就是父子容器：


  • 通常我们会设置父容器（Spring）管理Service、Dao层的Bean, 子容器(SpringMVC)管理Controller的Bean .
  • 子容器可以访问父容器的Bean, 父容器无法访问子容器的Bean。
实现：
相信大家在SSM框架整合的时候都曾在web.xml设置过这段：
  1. <!--spring 基于web应用的启动-->
  2. <listener>
  3.     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  4. </listener>
  5. <!--全局参数：spring配置文件-->
  6. <context-param>
  7.     <param-name>contextConfigLocation</param-name>
  8.     <param-value>classpath:spring-core.xml</param-value>
  9. </context-param>
  10. <!--前端调度器servlet-->
  11. <servlet>
  12.     <servlet-name>dispatcherServlet</servlet-name>
  13.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  14.     <!--设置配置文件的路径-->
  15.     <init-param>
  16.     <param-name>contextConfigLocation</param-name>
  17.     <param-value>classpath:spring-mvc.xml</param-value>
  18. </init-param>
  19.     <!--设置启动即加载-->
  20.     <load-on-startup>1</load-on-startup>
  21. </servlet>
  22. <servlet-mapping>
  23.     <servlet-name>dispatcherServlet</servlet-name>
  24.     <url-pattern>/</url-pattern>
复制代码
但是它的作用是什么知道吗？


有人大概只知道DispatcherServlet叫前端控制器，是SpringMVC处理前端请求的一个核心调理器
那它为什么能处理请求？处理之前做了什么准备工作呢？又是怎么和Spring联合起来的呢？
为什么有了DispatcherServlet还要个ContextLoaderListener， 配一个不行吗？干嘛要配俩啊？
看完本文你就会有答案！


还有人大概会以为， 我现在都用SpringBoot开发， 哪还要配这玩意.......


这就是典型的SpringBoot使用后遗症，SpringBoot降低了使用难度，但是从某种程度来说，也让初级的程序员变得更加小白，把实现原理都隐藏起来了而我们只管用，一旦涉及扩展就束手无策。
那当然我们本日不讲SpringBoot,我们本日用贴近SpringBoot的方式来讲SpringMVC。也就是零设置（零xml）的放式来说明SpringMVC的原理！！
   此方式作为我们本文重点先容，也是很多人缺失的一种方式， 实在早在Spring3+就已经提供， 只不外我们直到SpringBoot才使用该方式举行自动设置， 这也是很多人从xml调到SpringBoot不适应的原因， 因为你缺失了这个版本。 以是我们以这种方式作为源码切入点既可以理解到XML的方式又能兼顾到SpringBoot的方式 。
  

2、零设置SpringMVC实现方式：

那没有设置就需要省略掉web.xml 怎么省略呢？
在Servlet3.0提供的规范文档中可以找到2种方式：


  • 注解的方式

  • @WebServlet
  • @WebFilter
  • @WebListener
但是这种方式倒霉于扩展， 并且如果编写在jar包中tomcat是无法感知到的。


  • SPI的方式
在Serlvet3-1的规范手册中：就提供了一种更加易于扩展可用于共享库可插拔的一种方式，参见8.2.4：

也就是让你在应用META-INF/services 路径下 放一个 javax.servlet.ServletContainerInitailizer ——即SPI规范
SPI 我们叫他服务接口扩展,(Service Provider Interface) 直译服务提供商接口， 不要被这个名字唬到了， 实在很好理解的一个东西：
实在就是根据Servlet厂商（服务提供商）提供要求的一个接口， 在固定的目录（META-INF/services）放上以接口全类名 为定名的文件， 文件中放入接口的实现的全类名，该类由我们本身实现，按照这种约定的方式（即SPI规范），服务提供商会调用文件中实现类的方法， 从而完成扩展。
ok 那我们知道了SPI是什么，我们是不是可以在Web应用中，在Servlet的SPI放入对应的接口文件：


放入实现类：


通过ServletContext就可以动态注册三大组件：以Servlet注册为例：
  1. public class TulingSpringServletContainerInitializer extends SpringServletContainerInitializer {
  3.     @Override
  4.     public void onStartup(Set<Class<?>> webAppInitializerClasses, ServletContext servletContext) throws ServletException {
  6.         // 通过servletContext动态添加Servlet
  7.         servletContext.addServlet("spiServlet", new HttpServlet() {
  8.             @Override
  9.             protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  10.                 resp.getWriter().write("spiServlet--doGet");
  11.             }
  12.         }).addMapping("/spiServlet.do");
  15.     }
复制代码
 当然在SpringMVC中， 这个接口文件和实现类都把我们实现好了，甚至ContextLoaderListener和DispatcherServlet都帮我们注册好了，我们只要让他见效，来，看看他是怎么做的：
3、实现基于SPI规范的SpringMVC

TulingStarterInitializer


  • 此类继承AbstractAnnotationConfigDispatcherServletInitializer 这是个啥？ 待会我们讲原理来先容
  • getRootConfigClasses 提供父容器的设置类
  • getServletConfigClasses 提供子容器的设置类
  • getServletMappings 设置DispatcherServlet的映射
  1. public  class TulingStarterInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
  3.    /**
  4.     * 方法实现说明:IOC 父容器的启动类
  5.     * @author:xsls
  6.     * @date:2019/7/31 22:12
  7.     */
  8.    @Override
  9.    protected Class<?>[] getRootConfigClasses() {
  10.       return new Class[]{RootConfig.class};
  11.    }
  13.    /**
  14.     * 方法实现说明 IOC子容器配置 web容器配置
  15.     * @author:xsls
  16.     * @date:2019/7/31 22:12
  17.     */
  18.    @Override
  19.    protected Class<?>[] getServletConfigClasses() {
  20.       return new Class[]{WebAppConfig.class};
  21.    }
  23.    /**
  24.     * 方法实现说明
  25.     * @author:xsls
  26.     * @return: 我们前端控制器DispatcherServlet的拦截路径
  27.     * @exception:
  28.     * @date:2019/7/31 22:16
  29.     */
  30.    @Override
  31.    protected String[] getServletMappings() {
  32.       return new String[]{"/"};
复制代码
RootConfig



  • 父容器的设置类 =以前的spring.xml
  • 扫描的包排撤除@Controller
  1. @Configuration
  2. @ComponentScan(basePackages = "com.tuling",excludeFilters = {
  3.       @ComponentScan.Filter(type = FilterType.ANNOTATION,value={RestController.class,Controller.class}),
  4.       @ComponentScan.Filter(type = ASSIGNABLE_TYPE,value =WebAppConfig.class ),
  5. })
  6. public class RootConfig {
  8. }
复制代码
WebAppConfig



  • 子容器的设置类 =以前的spring-mvc.xml
  • 扫描的包：包罗掉@Controller
  1. @Configuration
  2. @ComponentScan(basePackages = {"com.tuling"},includeFilters = {
  3.       @ComponentScan.Filter(type = FilterType.ANNOTATION,value = {RestController.class, Controller.class})
  4. },useDefaultFilters =false)
  5. @EnableWebMvc   // ≈<mvc:annotation-driven/>
  6. public class WebAppConfig implements WebMvcConfigurer{
  8.    /**
  9.     * 配置拦截器
  10.     * @return
  11.     */
  12.    @Bean
  13.    public TulingInterceptor tulingInterceptor() {
  14.       return new TulingInterceptor();
  15.    }
  17.    /**
  18.     * 文件上传下载的组件
  19.     * @return
  20.     */
  21.    @Bean
  22.    public MultipartResolver multipartResolver() {
  23.       CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
  24.       multipartResolver.setDefaultEncoding("UTF-8");
  25.       multipartResolver.setMaxUploadSize(1024*1024*10);
  26.       return multipartResolver;
  27.    }
  29.    /**
  30.     * 注册处理国际化资源的组件
  31.     * @return
  32.     */
  33. /* @Bean
  34.    public AcceptHeaderLocaleResolver localeResolver() {
  35.       AcceptHeaderLocaleResolver acceptHeaderLocaleResolver = new AcceptHeaderLocaleResolver();
  36.       return acceptHeaderLocaleResolver;
  37.    }*/
  39.    @Override
  40.    public void addInterceptors(InterceptorRegistry registry) {
  41.       registry.addInterceptor(tulingInterceptor()).addPathPatterns("/*");
  42.    }
  45.    /**
  46.     * 方法实现说明:配置试图解析器
  47.     * @author:xsls
  48.     * @exception:
  49.     * @date:2019/8/6 16:23
  50.     */
  51.    @Bean
  52.    public InternalResourceViewResolver internalResourceViewResolver() {
  53.       InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
  54.       viewResolver.setSuffix(".jsp");
  55.       viewResolver.setPrefix("/WEB-INF/jsp/");
  56.       return viewResolver;
  57.    }
  61.    @Override
  62.    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
  63.       converters.add(new MappingJackson2HttpMessageConverter());
  64.    }
复制代码
本身去添加个Controller举行测试
OK， 现在可以访问你的SpringMVC了
4、SPI的方式SpringMVC启动原理

接着我们来看看SPI方式的原理是什么：
SpringMVC 大致可以分为 启动 和请求 2大部分， 以是我们本文先研究启动部分
流程图：

源码流程

  • 外置Tomcat启动的时候通过SPI 找到我们应用中的/META-INF/service/javax.servlet.ServletContainerInitializer



  • 调用SpringServletContainerInitializer.onStartUp()





    • 调用onStartUp()前会先找到@HandlesTypes(WebApplicationInitializer.class) 全部实现了WebApplicationInitializer的类，传入到OnStartup的webAppInitializerClasses参数中，并传入Servlet上下文对象。
    • 重点关注这组类：他们构成了父子容器




  • 找到全部WebApplicationInitializer的实现类后， 不是接口、不是抽象则通过反射举行实例化（以是，你会发现内部实现类都是抽象的，你想让其起作用我们必须添加一个自界说实现类，在下文提供我的自界说实现类）
  • 调用全部上一步实例化后的对象的onStartup方法




1. 起首来到AbstractDispatcherServletInitializer#onStartup再执行super.onStartup(servletContext);
  1. @Override
  2. public void onStartup(ServletContext servletContext) throws ServletException {
  3.    //实例化我们的spring root上下文
  4.    super.onStartup(servletContext);
  5.    //注册我们的DispatcherServlet   创建我们spring web 上下文对象
  6.    registerDispatcherServlet(servletContext);
复制代码
 创建父容器——ContextLoaderListener

2.父类AbstractContextLoaderInitializer#onStartup执行registerContextLoaderListener(servletContext);

  • createRootApplicationContext()该方法中会创建父容器

    • 该方法是抽象方法，实现类是AbstractAnnotationConfigDispatcherServletInitializer

      • 调用getRootConfigClasses();方法获取父容器设置类（此抽象方法在我们自界说的子类中实现提供我们自界说的映射路径 ）
      • 创建父容器，注册设置类





  • 会创建ContextLoaderListener并通过ServletContext注册


看完大家是不是感觉跟我们XML的设置ContextLoaderListener对上了：


创建子容器——DispatcherServlet
3.回到AbstractDispatcherServletInitializer#onStartup再执行registerDispatcherServlet(servletContext);


registerDispatcherServlet方法说明：

  • 调用createServletApplicationContext创建子容器

    • 该方法是抽象方法，实现类是AbstractAnnotationConfigDispatcherServletInitializer

      • 创建子容器（下图很显着不多先容）
      • 调用抽象方法：getServletConfigClasses();获得设置类（此抽象方法在我们自界说的子类中实现提供我们自界说的设置类 ）
      • 设置类除了可以通过ApplicationContext()构造函数的方式传入 ， 也可以通过这种方式动态添加，不知道了吧~





  • 调用createDispatcherServlet(servletAppContext);创建DispatcherServlet
  • 设置启动时加载：registration.setLoadOnStartup(1);
  • 调用抽象方法设置映射路径：getServletMappings()（此抽象方法在我们自界说的子类中实现提供我们自界说的映射路径 ）
看完大家是不是感觉跟我们XML的设置DispatcherServlet对上了


4. 初始化ContextLoaderListener


ContextLoaderListener加载过程比较简朴：
外置tomcat会帮我们调用ContextLoaderListener#contextInitialized 举行初始化

  • xml的方式下会判断容器为空时创建父容器
  • 在内里会调用父容器的refresh方法加载
  • 将父容器存入到Servlet域中供子容器使用


5. 初始化DispatcherServlet


可以看到流程比ContextLoaderListener流程更多
外置tomcat会帮我们调用DispatcherServlet#init()   举行初始化--->重点关注：initWebApplicationContext方法

  • getWebApplicationContext(getServletContext())获得父容器（从之前的Servlet域中拿到）
  • cwac.setParent(rootContext);给子容器设置父容器
  • 调用configureAndRefreshWebApplicationContext(cwac);





    • 注册一个监听器（该监听会初始化springmvc所需信息）

      • ContextRefreshedEvent可以看到该监听器监听的是容器refreshed事件， 会在finishRefresh中发布

    • 刷新容器



当执行refresh 即加载ioc容器 完了会调用finishRefresh():

  • publishEvent(new ContextRefreshedEvent(this));发布ContextRefreshedEvent事件
  • 触发上面的ContextRefreshListener监听器：
---->FrameworkServlet.this.onApplicationEvent(event);
-------->onRefresh(event.getApplicationContext());
-------------->initStrategies(context);
  1. protected void initStrategies(ApplicationContext context) {
  2.    //初始化我们web上下文对象的 用于文件上传下载的解析器对象
  3.    initMultipartResolver(context);
  4.    //初始化我们web上下文对象用于处理国际化资源的
  5.    initLocaleResolver(context);
  6.    //主题解析器对象初始化
  7.    initThemeResolver(context);
  8.    //初始化我们的HandlerMapping
  9.    initHandlerMappings(context);
  10.    //实例化我们的HandlerAdapters
  11.    initHandlerAdapters(context);
  12.    //实例化我们处理器异常解析器对象
  13.    initHandlerExceptionResolvers(context);
  14.    initRequestToViewNameTranslator(context);
  15.    //给DispatcherSerlvet的ViewResolvers处理器
  16.    initViewResolvers(context);
  17.    initFlashMapManager(context);
复制代码
这内里的每一个方法不用太细看， 就是给SpringMVC准备初始化的数据， 为后续SpringMVC处理请求做准备
根本都是从容器中拿到已经设置的Bean（RequestMappingHandlerMapping、RequestMappingHandlerAdapter、HandlerExceptionResolver ）放到dispatcherServlet中做准备:






...
但是这些Bean又是从哪来的呢？？ 来来来， 回到我们的WebAppConfig
我们使用的一个@EnableWebMvc

  • 导入了DelegatingWebMvcConfiguration@Import(DelegatingWebMvcConfiguration.class)
  • DelegatingWebMvcConfiguration的父类就设置了这些Bean
  • 而且我告诉你SpringBoot也是用的这种方式，




总结


  • Tomcat在启动时会通过SPI注册 ContextLoaderListener和DispatcherServlet对象

    • 同时创建父子容器

      • 分别创建在ContextLoaderListener初始化时创建父容器设置设置类
      • 在DispatcherServlet初始化时创建子容器 即2个ApplicationContext实例设置设置类


  • Tomcat在启动时执行ContextLoaderListener和DispatcherServlet对象的初始化方法， 执行容器refresh举行加载
  • 在子容器加载时 创建SpringMVC所需的Bean和预准备的数据：(通过设置类+@EnableWebMvc设置（DelegatingWebMvcConfiguration）——可实现WebMvcConfigurer举行定制扩展）

    • RequestMappingHandlerMapping，它会处理@RequestMapping 注解
    • RequestMappingHandlerAdapter，则是处理请求的适配器，确定调用哪个类的哪个方法，并且构造方法参数，返回值。
    • HandlerExceptionResolver 错误视图剖析器
    • addDefaultHttpMessageConverters 添加默认的消息转换器（剖析json、剖析xml）
    • 等....

  • 子容器需要注入父容器的Bean时（比如Controller中需要@Autowired Service的Bean）; 会先从子容器中找，没找到会去父容器中找： 详情见AbstractBeanFactory#doGetBean方法
 

  1. /**
  2. * 一般情况下,只有Spring 和SpringMvc整合的时才会有父子容器的概念,
  3. * 作用：
  4. * 比如我们的Controller中注入Service的时候，发现我们依赖的是一个引用对象，那么他就会调用getBean去把service找出来
  5. * 但是当前所在的容器是web子容器，那么就会在这里的 先去父容器找
  6. */
  7. BeanFactory parentBeanFactory = getParentBeanFactory();
  8. //若存在父工厂,且当前的bean工厂不存在当前的bean定义,那么bean定义是存在于父beanFacotry中
  9. if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  10.    //获取bean的原始名称
  11.    String nameToLookup = originalBeanName(name);
  12.    //若为 AbstractBeanFactory 类型，委托父类处理
  13.    if (parentBeanFactory instanceof AbstractBeanFactory) {
  14.       return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
  15.             nameToLookup, requiredType, args, typeCheckOnly);
  16.    }
  17.    else if (args != null) {
  18.       //  委托给构造函数 getBean() 处理
  19.       return (T) parentBeanFactory.getBean(nameToLookup, args);
  20.    }
  21.    else {
  22.       // 没有 args，委托给标准的 getBean() 处理
  23.       return parentBeanFactory.getBean(nameToLookup, requiredType);
  24.    }
复制代码


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

惊落一身雪

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表