SpringBoot启动过程核心源码解析思维导图模板

StopWatch stopWatch = new StopWatch(); stopWatch.start();

SpringApplicationRunListeners listeners = getRunListeners(args);

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

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;  }

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {   String factoryTypeName = factoryType.getName();   return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());  }

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {   MultiValueMap<String, String> result = cache.get(classLoader);   if (result != null) {    return result;   }   try {    Enumeration<URL> urls = (classLoader != null ?      classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :      ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));    result = new LinkedMultiValueMap<>();    while (urls.hasMoreElements()) {     URL url = urls.nextElement();     UrlResource resource = new UrlResource(url);     Properties properties = PropertiesLoaderUtils.loadProperties(resource);     for (Map.Entry<?, ?> entry : properties.entrySet()) {      String factoryTypeName = ((String) entry.getKey()).trim();      for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {       result.add(factoryTypeName, factoryImplementationName.trim());      }     }    }    cache.put(classLoader, result);    return result;   }   catch (IOException ex) {    throw new IllegalArgumentException("Unable to load factories from location [" +      FACTORIES_RESOURCE_LOCATION + "]", ex);   }  }

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;  }

listeners.start();

void starting() {   for (SpringApplicationRunListener listener : this.listeners) {    listener.starting();   }  }

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {  ...... @Override  public void starting() {   this.initialMulticaster.multicastEvent(new ApplicationStartingEvent(this.application, this.args));  }  ...... }

ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

public class DefaultApplicationArguments implements ApplicationArguments {  private final Source source;  private final String[] args;  public DefaultApplicationArguments(String... args) {   Assert.notNull(args, "Args must not be null");   this.source = new Source(args);   this.args = args;  } }

ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,    ApplicationArguments applicationArguments) {   // Create and configure the environment   ConfigurableEnvironment environment = getOrCreateEnvironment();   configureEnvironment(environment, applicationArguments.getSourceArgs());   ConfigurationPropertySources.attach(environment);   listeners.environmentPrepared(environment);   bindToSpringApplication(environment);   if (!this.isCustomEnvironment) {    environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,      deduceEnvironmentClass());   }   ConfigurationPropertySources.attach(environment);   return environment;  }

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

protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {   if (this.addConversionService) {    ConversionService conversionService = ApplicationConversionService.getSharedInstance();    environment.setConversionService((ConfigurableConversionService) conversionService);   }   configurePropertySources(environment, args);   configureProfiles(environment, args);  }

protected void configurePropertySources(ConfigurableEnvironment environment, String[] args) {   MutablePropertySources sources = environment.getPropertySources();   if (this.defaultProperties != null && !this.defaultProperties.isEmpty()) {    sources.addLast(new MapPropertySource("defaultProperties", this.defaultProperties));   }   if (this.addCommandLineProperties && args.length > 0) {    String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;    if (sources.contains(name)) {     PropertySource<?> source = sources.get(name);     CompositePropertySource composite = new CompositePropertySource(name);     composite.addPropertySource(       new SimpleCommandLinePropertySource("springApplicationCommandLineArgs", args));     composite.addPropertySource(source);     sources.replace(name, composite);    }    else {     sources.addFirst(new SimpleCommandLinePropertySource(args));    }   }  }

protected void configureProfiles(ConfigurableEnvironment environment, String[] args) {   Set<String> profiles = new LinkedHashSet<>(this.additionalProfiles);   profiles.addAll(Arrays.asList(environment.getActiveProfiles()));   environment.setActiveProfiles(StringUtils.toStringArray(profiles));  }

public final class ConfigurationPropertySources { public static void attach(Environment environment) {   Assert.isInstanceOf(ConfigurableEnvironment.class, environment);   MutablePropertySources sources = ((ConfigurableEnvironment) environment).getPropertySources();   PropertySource<?> attached = sources.get(ATTACHED_PROPERTY_SOURCE_NAME);   if (attached != null && attached.getSource() != sources) {    sources.remove(ATTACHED_PROPERTY_SOURCE_NAME);    attached = null;   }   if (attached == null) {    sources.addFirst(new ConfigurationPropertySourcesPropertySource(ATTACHED_PROPERTY_SOURCE_NAME,      new SpringConfigurationPropertySources(sources)));   }  } }

class SpringApplicationRunListeners { void environmentPrepared(ConfigurableEnvironment environment) {   for (SpringApplicationRunListener listener : this.listeners) {    listener.environmentPrepared(environment);   }  } }

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered { @Override  public void environmentPrepared(ConfigurableEnvironment environment) {   this.initialMulticaster     .multicastEvent(new ApplicationEnvironmentPreparedEvent(this.application, this.args, environment));  } }

protected void bindToSpringApplication(ConfigurableEnvironment environment) {   try {    Binder.get(environment).bind("spring.main", Bindable.ofInstance(this));   }   catch (Exception ex) {    throw new IllegalStateException("Cannot bind to SpringApplication", ex);   }  }

configureIgnoreBeanInfo(environment);

private void configureIgnoreBeanInfo(ConfigurableEnvironment environment) {   if (System.getProperty(CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME) == null) {    Boolean ignore = environment.getProperty("spring.beaninfo.ignore", Boolean.class, Boolean.TRUE);    System.setProperty(CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME, ignore.toString());   }  }

Banner printedBanner = printBanner(environment);

private Banner printBanner(ConfigurableEnvironment environment) {   if (this.bannerMode == Banner.Mode.OFF) {    return null;   }   ResourceLoader resourceLoader = (this.resourceLoader != null) ? this.resourceLoader     : new DefaultResourceLoader(null);   SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter(resourceLoader, this.banner);   if (this.bannerMode == Mode.LOG) {    return bannerPrinter.print(environment, this.mainApplicationClass, logger);   }   return bannerPrinter.print(environment, this.mainApplicationClass, System.out);  }

ConfigurableApplicationContext context = createApplicationContext();

protected ConfigurableApplicationContext createApplicationContext() {   Class<?> contextClass = this.applicationContextClass;   if (contextClass == null) {    try {     switch (this.webApplicationType) {     case SERVLET:      contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);      break;     case REACTIVE:      contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);      break;     default:      contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);     }    }    catch (ClassNotFoundException ex) {     throw new IllegalStateException(       "Unable create a default ApplicationContext, please specify an ApplicationContextClass", ex);    }   }   return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);  }

prepareContext(context, environment, listeners, applicationArguments, printedBanner);

private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,    SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {   context.setEnvironment(environment);   postProcessApplicationContext(context);   applyInitializers(context);   listeners.contextPrepared(context);   if (this.logStartupInfo) {    logStartupInfo(context.getParent() == null);    logStartupProfileInfo(context);   }   // Add boot specific singleton beans   ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();   beanFactory.registerSingleton("springApplicationArguments", applicationArguments);   if (printedBanner != null) {    beanFactory.registerSingleton("springBootBanner", printedBanner);   }   if (beanFactory instanceof DefaultListableBeanFactory) {    ((DefaultListableBeanFactory) beanFactory)      .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);   }   if (this.lazyInitialization) {    context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());   }   // Load the sources   Set<Object> sources = getAllSources();   Assert.notEmpty(sources, "Sources must not be empty");   load(context, sources.toArray(new Object[0]));   listeners.contextLoaded(context);  }

protected void postProcessApplicationContext(ConfigurableApplicationContext context) {   if (this.beanNameGenerator != null) {    context.getBeanFactory().registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,      this.beanNameGenerator);   }   if (this.resourceLoader != null) {    if (context instanceof GenericApplicationContext) {     ((GenericApplicationContext) context).setResourceLoader(this.resourceLoader);    }    if (context instanceof DefaultResourceLoader) {     ((DefaultResourceLoader) context).setClassLoader(this.resourceLoader.getClassLoader());    }   }   if (this.addConversionService) {    context.getBeanFactory().setConversionService(ApplicationConversionService.getSharedInstance());   }  }

protected void applyInitializers(ConfigurableApplicationContext context) {   for (ApplicationContextInitializer initializer : getInitializers()) {    Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(),      ApplicationContextInitializer.class);    Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");    initializer.initialize(context);   }  }

class SpringApplicationRunListeners { void contextPrepared(ConfigurableApplicationContext context) {   for (SpringApplicationRunListener listener : this.listeners) {    listener.contextPrepared(context);   }  } }

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered { @Override  public void contextPrepared(ConfigurableApplicationContext context) {   this.initialMulticaster     .multicastEvent(new ApplicationContextInitializedEvent(this.application, this.args, context));  } }

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();  }

class SpringApplicationRunListeners { void contextLoaded(ConfigurableApplicationContext context) {   for (SpringApplicationRunListener listener : this.listeners) {    listener.contextLoaded(context);   }  } }

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered { @Override  public void contextLoaded(ConfigurableApplicationContext context) {   for (ApplicationListener<?> listener : this.application.getListeners()) {    if (listener instanceof ApplicationContextAware) {     ((ApplicationContextAware) listener).setApplicationContext(context);    }    context.addApplicationListener(listener);   }   this.initialMulticaster.multicastEvent(new ApplicationPreparedEvent(this.application, this.args, context));  } }

refreshContext(context);

private void refreshContext(ConfigurableApplicationContext context) {   refresh((ApplicationContext) context);   if (this.registerShutdownHook) {    try {     context.registerShutdownHook();    }    catch (AccessControlException ex) {     // Not allowed in some environments.    }   }  }

protected void refresh(ConfigurableApplicationContext applicationContext) {   applicationContext.refresh();  }

afterRefresh(context, applicationArguments);

protected void afterRefresh(ConfigurableApplicationContext context, ApplicationArguments args) {  }

stopWatch.stop();

listeners.started(context);

class SpringApplicationRunListeners { void started(ConfigurableApplicationContext context) {   for (SpringApplicationRunListener listener : this.listeners) {    listener.started(context);   }  } }

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered { @Override  public void started(ConfigurableApplicationContext context) {   context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context));   AvailabilityChangeEvent.publish(context, LivenessState.CORRECT);  } }

callRunners(context, applicationArguments);

private void callRunners(ApplicationContext context, ApplicationArguments args) {   List<Object> runners = new ArrayList<>();   runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());   runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());   AnnotationAwareOrderComparator.sort(runners);   for (Object runner : new LinkedHashSet<>(runners)) {    if (runner instanceof ApplicationRunner) {     callRunner((ApplicationRunner) runner, args);    }    if (runner instanceof CommandLineRunner) {     callRunner((CommandLineRunner) runner, args);    }   }  }

private void callRunner(ApplicationRunner runner, ApplicationArguments args) {   try {    (runner).run(args);   }   catch (Exception ex) {    throw new IllegalStateException("Failed to execute ApplicationRunner", ex);   }  }

private void callRunner(CommandLineRunner runner, ApplicationArguments args) {   try {    (runner).run(args.getSourceArgs());   }   catch (Exception ex) {    throw new IllegalStateException("Failed to execute CommandLineRunner", ex);   }  }

listeners.running(context);

class SpringApplicationRunListeners { void running(ConfigurableApplicationContext context) {   for (SpringApplicationRunListener listener : this.listeners) {    listener.running(context);   }  } }

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered { @Override  public void running(ConfigurableApplicationContext context) {   context.publishEvent(new ApplicationReadyEvent(this.application, this.args, context));   AvailabilityChangeEvent.publish(context, ReadinessState.ACCEPTING_TRAFFIC);  } }