SpringBoot 源码分析 (run方法分析12步之前4步) (三)

执行 run 方法

1. 得到 SpringApplicationRunListeners，名字取得不好，实际是事件发布器

• 发布 application starting 事件1️⃣

2. 封装启动 args
3. 准备 Environment 添加命令行参数（*）
4. ConfigurationPropertySources 处理（*）

• 发布 application environment 已准备事件2️⃣

5. 通过 EnvironmentPostProcessorApplicationListener 进行 env 后处理（*）

• application.properties，由 StandardConfigDataLocationResolver 解析
• spring.application.json

6. 绑定 spring.main 到 SpringApplication 对象（*）
7. 打印 banner（*）
8. 创建容器
9. 准备容器

• 发布 application context 已初始化事件3️⃣

10. 加载 bean 定义

• 发布 application prepared 事件4️⃣

11. refresh 容器

• 发布 application started 事件5️⃣

12. 执行 runner

• 发布 application ready 事件6️⃣
• 这其中有异常，发布 application failed 事件7️⃣

public ConfigurableApplicationContext run(String... args) {
    long startTime = System.nanoTime();
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    ConfigurableApplicationContext context = null;
    configureHeadlessProperty();
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting(bootstrapContext, this.mainApplicationClass);
    try {
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
      ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
      configureIgnoreBeanInfo(environment);
      Banner printedBanner = printBanner(environment);
      context = createApplicationContext();
      context.setApplicationStartup(this.applicationStartup);
      prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
      refreshContext(context);
      afterRefresh(context, applicationArguments);
      Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
      if (this.logStartupInfo) {
        new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
      }
      listeners.started(context, timeTakenToStartup);
      callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
      handleRunFailure(context, ex, listeners);
      throw new IllegalStateException(ex);
    }
    try {
      Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
      listeners.ready(context, timeTakenToReady);
    }
    catch (Throwable ex) {
      handleRunFailure(context, ex, null);
      throw new IllegalStateException(ex);
    }
    return context;
  }

文章目录

1.得到 SpringApplicationRunListeners

SpringApplicationRunListeners listeners = getRunListeners(args);

getRunListeners()

private SpringApplicationRunListeners getRunListeners(String[] args) {
    Class[] types = new Class[] { SpringApplication.class, String[].class };
    return new SpringApplicationRunListeners(logger,
        getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args),
        this.applicationStartup);
  }

getSpringFactoriesInstances()

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class[] parameterTypes, Object... args) {
    ClassLoader classLoader = getClassLoader();
    // Use names and ensure unique to protect against duplicates
    Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    AnnotationAwareOrderComparator.sort(instances);
    return instances;
  }

createSpringFactoriesInstances()

private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class[] parameterTypes,
      ClassLoader classLoader, Object[] args, Set<String> names) {
    List<T> instances = new ArrayList<>(names.size());
    for (String name : names) {
      try {
        Class instanceClass = ClassUtils.forName(name, classLoader);
        Assert.isAssignable(type, instanceClass);
        Constructor constructor = instanceClass.getDeclaredConstructor(parameterTypes);
        T instance = (T) BeanUtils.instantiateClass(constructor, args);
        instances.add(instance);
      }
      catch (Throwable ex) {
        throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
      }
    }
    return instances;
  }

结果还是通过反射创建SpringApplicationRunListener实例, 然后传到getRunListeners()方法上。

这个监听器对于整个run方法都有很多的用处

2.封装启动 args

DefaultApplicationArguments arguments = new DefaultApplicationArguments(args);

这里的args是以后的run执行的方法的参数

@Bean
        public CommandLineRunner commandLineRunner(){
            return args -> {
                // main 的参数
                System.out.println("执行CommandLineRunner" + Arrays.toString(args));
            };
        }
        @Bean
        public ApplicationRunner applicationRunner(){
            return args -> {
                // main的参数做封装
                System.out.println("执行ApplicationRunner" + Arrays.toString(args.getSourceArgs()));
                System.out.println(args.getOptionNames());
                System.out.println(args.getOptionValues("server.port"));
                System.out.println(args.getNonOptionArgs());
            };
        }

for (CommandLineRunner value : context.getBeansOfType(CommandLineRunner.class).values()) {
            value.run(args);
        }
        for (ApplicationRunner value : context.getBeansOfType(ApplicationRunner.class).values()) {
            value.run(arguments);
        }

3.准备 Environment 添加命令行参数

ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);

prepareEnvironment()

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
      DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
    // Create and configure the environment
    ConfigurableEnvironment environment = getOrCreateEnvironment();
    configureEnvironment(environment, applicationArguments.getSourceArgs());
    ConfigurationPropertySources.attach(environment);
    listeners.environmentPrepared(bootstrapContext, environment);
    DefaultPropertiesPropertySource.moveToEnd(environment);
    Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
        "Environment prefix cannot be set via properties.");
    bindToSpringApplication(environment);
    if (!this.isCustomEnvironment) {
      environment = convertEnvironment(environment);
    }
    ConfigurationPropertySources.attach(environment);
    return environment;
  }

getOrCreateEnvironment()

private ConfigurableEnvironment getOrCreateEnvironment() {
    if (this.environment != null) {
      return this.environment;
    }
    switch (this.webApplicationType) {
    case SERVLET:
      return new ApplicationServletEnvironment();
    case REACTIVE:
      return new ApplicationReactiveWebEnvironment();
    default:
      return new ApplicationEnvironment();
    }
  }

这里的环境由类型决定：

​​ApplicationServletEnvironment​​​​ApplicationReactiveWebEnvironment​​​​ApplicationEnvironment​​

4.ConfigurationPropertySources 处理

加入特殊的PropertySource源, 使得命名规范, 都转换为​​x-x​​

ConfigurationPropertySources.attach(environment);

attach()
加入一个优先级最高的源

public static void attach(Environment environment) {
    Assert.isInstanceOf(ConfigurableEnvironment.class, environment);
    MutablePropertySources sources = ((ConfigurableEnvironment) environment).getPropertySources();
    PropertySource attached = getAttached(sources);
    if (attached == null || !isUsingSources(attached, sources)) {
      attached = new ConfigurationPropertySourcesPropertySource(ATTACHED_PROPERTY_SOURCE_NAME,
          new SpringConfigurationPropertySources(sources));
    }
    sources.remove(ATTACHED_PROPERTY_SOURCE_NAME);
    sources.addFirst(attached);
  }

输出