• Spring Boot 启动流程源码分析


    学习过springboot的都知道,在Springboot的main入口函数中调用SpringApplication.run(DemoApplication.class,args)函数便可以启用SpringBoot应用程序,跟踪一下SpringApplication源码可以发现,最终还是调用了SpringApplication的动态run函数。

    下面以SpringBoot2.0.3.RELEASE为例简单分析一下运行过程。

    SpringApplicatiton部分源码:

    1 public static ConfigurableApplicationContext run(Class<?>[] primarySources,
    2       String[] args) {
    3   //创建springapplication对象,调用函数run(args)
    4    return new SpringApplication(primarySources).run(args);
    5 }

    上面的源码可以发现还是先创建SpringApplication实例,再调用run方法

    第一步 分析 SpringApplication构造函数

    SpringApplication构造函数代码如下:

     1  public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
     2    this.resourceLoader = resourceLoader;
     3    Assert.notNull(primarySources, "PrimarySources must not be null");
     4    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
     5 
     6   //1:判断web环境
     7    this.webApplicationType = deduceWebApplicationType();
     8 
     9   //2:加载classpath下META-INF/spring.factories中配置的ApplicationContextInitializer
    10    setInitializers((Collection) getSpringFactoriesInstances(
    11          ApplicationContextInitializer.class));
    12   //3:加载classpath下META-INF/spring.factories中配置的ApplicationListener
    13   
    14    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    15   //4:推断main方法所在的类
    16    this.mainApplicationClass = deduceMainApplicationClass();
    17 }

    具体逻辑分析:

    1. deduceWebApplicationType(),  SpringApplication构造函数中首先初始化应用类型,根据加载相关类路径判断应用类型,具体逻辑如下:
     1   private static final String REACTIVE_WEB_ENVIRONMENT_CLASS = "org.springframework."
     2       + "web.reactive.DispatcherHandler";
     3 
     4   private static final String MVC_WEB_ENVIRONMENT_CLASS = "org.springframework."
     5       + "web.servlet.DispatcherServlet";
     6 
     7   private static final String[] WEB_ENVIRONMENT_CLASSES = { "javax.servlet.Servlet",
     8       "org.springframework.web.context.ConfigurableWebApplicationContext" };
     9 
    10 
    11 
    12    private WebApplicationType deduceWebApplicationType() {
    13   //当类路径中存在REACTIVE_WEB_ENVIRONMENT_CLASS并且不存在MVC_WEB_ENVIRONMENT_CLASS时
    14    if (ClassUtils.isPresent(REACTIVE_WEB_ENVIRONMENT_CLASS, null)
    15          && !ClassUtils.isPresent(MVC_WEB_ENVIRONMENT_CLASS, null)) {
    16       return WebApplicationType.REACTIVE;
    17    }
    18   //当加载的类路径中不包含WEB_ENVIRONMENT_CLASSES中定义的任何一个类时,返回标准应用()
    19    for (String className : WEB_ENVIRONMENT_CLASSES) {
    20       if (!ClassUtils.isPresent(className, null)) {
    22 return WebApplicationType.NONE; 23 } 24 } 25   //加载的类路径中包含了WEB_ENVIRONMENT_CLASSES中定义的所有类型则判断为servlet的web应用 26 return WebApplicationType.SERVLET; 27 }

      2. setInitializers初始化属性initializers,加载classpath下META-INF/spring.factories中配置的ApplicationContextInitializer,此处getSpringFactoriesInstances方法入参type=ApplicationContextInitializer.class

     1   private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
     2         Class<?>[] parameterTypes, Object... args) {
     3      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
     4      // Use names and ensure unique to protect against duplicates
     5     // SpringFactoriesLoader.loadFactoryNames()方法将会从calssptah下的META-INF/spring.factories中读取key为//org.springframework.context.ApplicationContextInitializer的值,并以集合形式返回
     6      Set<String> names = new LinkedHashSet<>(
     7            SpringFactoriesLoader.loadFactoryNames(type, classLoader));
     8      //根据返回names集合逐个实例化,也就是初始化各种ApplicationContextInitializer,这些Initializer实际是在Spring上下文ApplicationContext执行refresh前调用
     9      List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
    10          classLoader, args, names);
    11      AnnotationAwareOrderComparator.sort(instances); //对instance排序
    12      return instances;
    13   }

            以我的demo为例,实际debug时得到的initializers如下,其中数据来源于spring-boot,spring-boot-autoconfiguration和spring-boot-devtolls三个jar包下的classpath中,ApplicationContextInitializer接口是Spring框架提供地的,其主要作用是在Spring容器初始化过程中prepareContext()这一步进行回调,具体可参考:Spring Boot(七)扩展分析

     

      3. setListeners 初始化属性listeners,加载classpath下META-INF/spring.factories中配置的ApplicationListener,此处入参为getSpringFactoriesInstances方法入参type= ApplicationListener.class

     1    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type,
     2         Class<?>[] parameterTypes, Object... args) {
     3      ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
     4      // Use names and ensure unique to protect against duplicates
     5     // SpringFactoriesLoader.loadFactoryNames()方法将会从calssptah下的META-INF/spring.factories中读取key为//org.springframework.context.ApplicationListener的值,并以集合形式返回
     6      Set<String> names = new LinkedHashSet<>(
     7          SpringFactoriesLoader.loadFactoryNames(type, classLoader));
     8     //根据配置,初始化各种ApplicationListener,作用是用来监听ApplicationEvent
     9      List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
    10          classLoader, args, names);
    11      AnnotationAwareOrderComparator.sort(instances);
    12      return instances;
    13   }

    第二步 分析 SpringApplication中 run方法

    SpringApplication的run方法代码如下:

     1 public ConfigurableApplicationContext run(String... args) {
     2    StopWatch stopWatch = new StopWatch();
     3    stopWatch.start();
     4    ConfigurableApplicationContext context = null;
     5    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
     6     //设置系统变量java.awt.headless
     7    configureHeadlessProperty();
     8     //1:获取监听器:加载classpath下面的META-INF/spring.factories配置的监听器SpringApplicationRunListener
     9    SpringApplicationRunListeners listeners = getRunListeners(args);
    10     //2:启动监听器:执行所有runlistener的starting方法,实际上发布一个【ApplicationStartingEvent】事件
    11    listeners.starting();
    12    try {
    13       //3:实例化ApplicationArguments对象
    14       ApplicationArguments applicationArguments = new DefaultApplicationArguments(
    15             args);
    16       //4: 准备应用上下文环境Environment (web环境 or 标准环境)+配置Environment,主要是把run方法的参数配置到Environment  发布【ApplicationEnvironmentPreparedEvent】事件
    17       ConfigurableEnvironment environment = prepareEnvironment(listeners,
    18             applicationArguments);
    19           configureIgnoreBeanInfo(environment);
    20     //打印banner,SpringBoot启动时,控制台输出的一个歪歪扭扭的很不清楚的Spring几个大字母,也可以自定义
    21       Banner printedBanner = printBanner(environment);
    22     //5: 根据不同environment实例化上下文 context
    23       context = createApplicationContext();
    24     // 异常处理,实例化一个SpringBootExceptionReporter.class 用于处理启动过程中的错误
    25       exceptionReporters = getSpringFactoriesInstances(
    26             SpringBootExceptionReporter.class,
    27             new Class[] { ConfigurableApplicationContext.class }, context);
    28     //6: 上下文相关预处理                  发布【ApplicationPreparedEvent】事件
    29       prepareContext(context, environment, listeners, applicationArguments,
    30             printedBanner);
    31     //7: 【刷新应用上线文】执行spring容器(context)的refresh方法,并且调用context的registerShutdownHook方法
    32       refreshContext(context);
    33     //8:空方法,用于扩展
    34       afterRefresh(context, applicationArguments);
    35       stopWatch.stop();
    36       if (this.logStartupInfo) {
    37          new StartupInfoLogger(this.mainApplicationClass)
    38                .logStarted(getApplicationLog(), stopWatch);
    39       }
    40      //9:执行所有runlisteners的started方法,发布【ApplicationStartedEvent】事件
    41       listeners.started(context);
    42      //10: 遍历执行CommandLineRunner和ApplicationRunner
    43      //如果需要在SpringBoot应用启动后运行一些特殊的逻辑,可以通过实现ApplicationRunner或CommandLineRunner接口中的run方法,该自定义类的run方法会在此处统一调用
    44       callRunners(context, applicationArguments);
    45    }
    46    catch (Throwable ex) {
    47       handleRunFailure(context, ex, exceptionReporters, listeners);
    48       throw new IllegalStateException(ex);
    49    }
    50 
    51    try {
    52       listeners.running(context);
    53    }
    54    catch (Throwable ex) {
    55       handleRunFailure(context, ex, exceptionReporters, null);
    56       throw new IllegalStateException(ex);
    57    }
    58    return context;
    59 }

    具体分析:

      1. 获取监听器:getRunListeners(args) 加载各种SpringApplicationRunListener实例,内部实现也还是通过SpringFactoriesLoader.loadFactoryNames(type, classLoader))实现,加载META-INF/spring.factories中key为org.springframework.boot.SpringApplicationRunListener的值,生成对应实例,SpringBoot实际加载了一个EventPublishingRunListener监听器,该监听器继承SpringApplicationRunListener接口,SpringApplicationRunListener规定了SpringBoot的生命周期,在各个生命周期广播相应的事件,调用实际的ApplicationListener类。

      2. 启动监听器: listeners.starting()  执行所有SpringApplicationRunListener的stating方法,发布ApplicationStartedEvent事件,该事件被ApplicationListener类型的listener监听

      3.  实例化ApplicationArguments对象

      4 . 准备应用上下文环境 并发布ApplicationEnvironmentPreparedEvent事件

     1    private ConfigurableEnvironment prepareEnvironment(
     2       SpringApplicationRunListeners listeners,
     3       ApplicationArguments applicationArguments) {
     4      // Create and configure the environment
     5    ConfigurableEnvironment environment = getOrCreateEnvironment();
     6   //根据properties和profiles配置环境
     7    configureEnvironment(environment, applicationArguments.getSourceArgs());
     8   // 执行EventPublishingRunListener发布ApplicationEnvironmentPreparedEvent事件,将会被ApplicationListener监听到
     9    listeners.environmentPrepared(environment);
    10   //
    11    bindToSpringApplication(environment);
    12    if (this.webApplicationType == WebApplicationType.NONE) {
    13       environment = new EnvironmentConverter(getClassLoader())
    14             .convertToStandardEnvironmentIfNecessary(environment);
    15    }
    16    ConfigurationPropertySources.attach(environment);
    17    return environment;
    18 }

    备注:实际上载spring-boot-2.0.3.RELEASE.jar包中,可以发现spring.factories中只配置了一个RunListener: org.springframework.boot.context.event.EventPublishingRunListener

         截取EventPublishingRunListener.java部分代码:

     1 public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {
     2     
     3 
     4      public EventPublishingRunListener(SpringApplication application, String[] args) {
     5        this.application = application;
     6        this.args = args;
     7        this.initialMulticaster = new SimpleApplicationEventMulticaster();
     8       //将SpringApplication实例中的ApplicationListener类型的listeners添加到initialMulticaster,后续执行监听
     9      for (ApplicationListener<?> listener : application.getListeners()) {
    10         this.initialMulticaster.addApplicationListener(listener);
    11      }
    12   }
    13 
    14   // 发布一个ApplicationEnvironmentPreparedEvent事件
    15     @Override
    16     public void environmentPrepared(ConfigurableEnvironment environment) {
    17         //所有被添加到initialMulticaster中的listener都将监听ApplicationEnvironmentPreparedEvent事件
    18         this.initialMulticaster.multicastEvent(new ApplicationEnvironmentPreparedEvent(
    19                 this.application, this.args, environment));
    20     }
    21 
    22 }

       

          4.1 根据properties和profiles配置环境:configureEnvironment(environment, applicationArguments.getSourceArgs());

               以下假设指定配文件application-dev.properties,跟踪一下源码,可以发现:

        protected void configureEnvironment(ConfigurableEnvironment environment,
                String[] args) {
            configurePropertySources(environment, args);
            configureProfiles(environment, args);
        }

       configureEnvironment方法内部比较简洁,直接调用两个方法完事,

            configurePropertySources(environment, args)方法的作用是将args封装成了SimpleCommandLinePropertySource并加入到了environment中,其中arg中含有启动参数:--spring.profiles.active=dev

            configureProfiles(environment, args)作用是将启动参数中指定的配置文件激活。

    configureProfiles中执行enviroment.getActiveProfiles():强制读取启动命令中指定的配置文件

        protected Set<String> doGetActiveProfiles() {
            synchronized (this.activeProfiles) {
                if (this.activeProfiles.isEmpty()) {
                    String profiles = getProperty(ACTIVE_PROFILES_PROPERTY_NAME);
                    if (StringUtils.hasText(profiles)) {
                        setActiveProfiles(StringUtils.commaDelimitedListToStringArray(
                                StringUtils.trimAllWhitespace(profiles)));
                    }
                }
                return this.activeProfiles;
            }
        }

           5. 根据environment类型创建ApplicationContext,通常情况下,我们启动的是一个Servlet应用,debug进createApplicationContext()源码,可以看到内部初始化了AnnotationConfigServletWebServerApplicationContext类,也就是我们的上下文context

      6. 上下文相关预处理,prepareContext()方法

     1 private void prepareContext(ConfigurableApplicationContext context,
     2       ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
     3       ApplicationArguments applicationArguments, Banner printedBanner) {
     4    context.setEnvironment(environment); //设置容器环境,environment前面已经准备好
     5   //配置beanNameGenerator和资源加载器
     6    postProcessApplicationContext(context);
     7   //回调所有的ApplicationContextInitializer初始化器
     8    applyInitializers(context);
     9   //发布容器以准备好的事件:执行所有SpringApplicationRunListener的contextPrepared方法,触发事件,实际上EventPublishingRunListener中contextPrepared是一个空方法,什么都没执行
    10    listeners.contextPrepared(context);
    11    if (this.logStartupInfo) {
    12       logStartupInfo(context.getParent() == null);
    13       logStartupProfileInfo(context);
    14    }
    15 
    16   //向Spring容器注入springApplicationArguments和springBootBanner,实际执行是将main函数的参数args和printedBanner分别封装成单例bean注册到容器中。
    17    // Add boot specific singleton beans
    18    context.getBeanFactory().registerSingleton("springApplicationArguments",
    19          applicationArguments);
    20    if (printedBanner != null) {
    21       context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
    22    }
    23 
    24    // Load the sources
    25    Set<Object> sources = getAllSources();
    26    Assert.notEmpty(sources, "Sources must not be empty");
    //加载启动类,将启动类也注入容器
    27 load(context, sources.toArray(new Object[0])); 28   //发布容器已加载事件:执行所有SpringApplicationRunListener的contextLoaded方法,下面是EventPublishingRunListener中的contextLoaded 29 listeners.contextLoaded(context); 30 }

         具体load方法实现, load方法的作用其注释写的也很清楚,"Load beans into the application context",实际执行时可以发现主要是将我们的SpringBoot应用的启动类(此处SpringbootdemoApplication2)注册到容器中!前面if条件都为false,不执行,具体分析loader.loader()。

    protected void load(ApplicationContext context, Object[] sources) {
            if (logger.isDebugEnabled()) {
                logger.debug(
                        "Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
            }
            BeanDefinitionLoader loader = createBeanDefinitionLoader(
                    getBeanDefinitionRegistry(context), sources);
            if (this.beanNameGenerator != null) {
                loader.setBeanNameGenerator(this.beanNameGenerator);
            }
            if (this.resourceLoader != null) {
                loader.setResourceLoader(this.resourceLoader);
            }
            if (this.environment != null) {
                loader.setEnvironment(this.environment);
            }
            loader.load();
        }

    loader.load()源码:

    public int load() {
            int count = 0;
            for (Object source : this.sources) {
                count += load(source);
            }
            return count;
        }
    
        private int load(Object source) {
            Assert.notNull(source, "Source must not be null");
            if (source instanceof Class<?>) {
                return load((Class<?>) source);  //执行
            }
            if (source instanceof Resource) {
                return load((Resource) source);
            }
            if (source instanceof Package) {
                return load((Package) source);
            }
            if (source instanceof CharSequence) {
                return load((CharSequence) source);
            }
            throw new IllegalArgumentException("Invalid source type " + source.getClass());
        }
    
        private int load(Class<?> source) {
            if (isGroovyPresent()
                    && GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
                // Any GroovyLoaders added in beans{} DSL can contribute beans here
                GroovyBeanDefinitionSource loader = BeanUtils.instantiateClass(source,
                        GroovyBeanDefinitionSource.class);
                load(loader);
            }
            if (isComponent(source)) {
                this.annotatedReader.register(source);
                return 1;
            }
            return 0;
        }

      isComponent(source)方法判断当前类是不是有@Component注解,显然启动类的@SpringBootApplication这个组合注解是包含Component注解的。

          this.annotatedReader.register(source)方法内部调用Spring框架底层提供的AnnotatedBeanDefinitionReader.doRegisterBean(xxx)方法,最终将SpringBoot应用的启动类注册到容器中。

     

        7.  执行context的refresh,并且调用context的registerShutdownHook方法,refresh方法的具体逻辑分析可以参考:

          Spring源码解析 – AnnotationConfigApplicationContext容器创建过程

      8. afterRefresh空方法

      9. 执行所有runlisteners的started方法,发布ApplicationStartedEvent事件

      10. 遍历执行CommandLineRunner和ApplicationRunner

    以上。

  • 相关阅读:
    python中namedtuple介绍
    导入mysql数据的时候提示Field * doesn't have a default value解决方法
    Django中多表查询思路
    使用questionsModel.values()后不能获取模型中的属性对应的外键属性值的解决方式
    使用django UWSGI 出现 Bad Request (400)
    reverse函数实现指定页面跳转
    Model中内部类meta详解
    models中的pk主键用法
    binlog的几种复制形式
    Mysqldump参数大全(参数来源于mysql5.5.19源码)
  • 原文地址:https://www.cnblogs.com/ashleyboy/p/9563565.html
Copyright © 2020-2023  润新知