首页  思维导图  详情

SpringBoot启动过程核心源码解析

2022-05-23 17:33:00   7  举报





AI智能生成

SpringBoot

启动

源码

作者其他创作

大纲/内容

应用入口

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

解析SpringApplication

public ConfigurableApplicationContext run(String... args)

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