@SpringBootApplication(scanBasePackages = {"cn.dark"})
public class SpringbootDemo {

 public static void main(String[] args) {
  // 第一種
  SpringApplication.run(SpringbootDemo .class, args);

 // 第二種
  new SpringApplicationBuilder(SpringbootDemo .class)).run(args);

 // 第三種
  SpringApplication springApplication = new SpringApplication(SpringbootDemo.class);
  springApplication.run(); 
 }
}

 public ConfigurableApplicationContext run(String... args) {
 // 統(tǒng)計(jì)時間用的工具類
 StopWatch stopWatch = new StopWatch();
 stopWatch.start();
 ConfigurableApplicationContext context = null;
 Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
 configureHeadlessProperty();
 // 獲取實(shí)現(xiàn)了SpringApplicationRunListener接口的實(shí)現(xiàn)類，通過SPI機(jī)制加載
 // META-INF/spring.factories文件下的類
 SpringApplicationRunListeners listeners = getRunListeners(args);

 // 首先調(diào)用SpringApplicationRunListener的starting方法
 listeners.starting();
 try {
 ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

 // 處理配置數(shù)據(jù)
 ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
 configureIgnoreBeanInfo(environment);

 // 啟動時打印banner
 Banner printedBanner = printBanner(environment);

 // 創(chuàng)建上下文對象
 context = createApplicationContext();

 // 獲取SpringBootExceptionReporter接口的類，異常報(bào)告
 exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
  new Class[] { ConfigurableApplicationContext.class }, context);

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

 // 核心方法，啟動spring容器
 refreshContext(context);
 afterRefresh(context, applicationArguments);

 // 統(tǒng)計(jì)結(jié)束
 stopWatch.stop();
 if (this.logStartupInfo) {
 new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
 }
 // 調(diào)用started
 listeners.started(context);

 // ApplicationRunner
 // CommandLineRunner
 // 獲取這兩個接口的實(shí)現(xiàn)類，并調(diào)用其run方法
 callRunners(context, applicationArguments);
 }
 catch (Throwable ex) {
 handleRunFailure(context, ex, exceptionReporters, listeners);
 throw new IllegalStateException(ex);
 }

 try {
 // 最后調(diào)用running方法
 listeners.running(context);
 }
 catch (Throwable ex) {
 handleRunFailure(context, ex, exceptionReporters, null);
 throw new IllegalStateException(ex);
 }
 return context;
 }

 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));
 // 加載上來后反射實(shí)例化
 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());
 }

 public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

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

 public static final String DEFAULT_SERVLET_WEB_CONTEXT_CLASS = "org.springframework.boot."
 + "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";

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

 public AnnotationConfigServletWebServerApplicationContext() {
 this.reader = new AnnotatedBeanDefinitionReader(this);
 this.scanner = new ClassPathBeanDefinitionScanner(this);
 }

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

 protected void refresh(ApplicationContext applicationContext) {
 Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
 ((AbstractApplicationContext) applicationContext).refresh();
 }

 public final void refresh() throws BeansException, IllegalStateException {
 try {
 super.refresh();
 }
 catch (RuntimeException ex) {
 stopAndReleaseWebServer();
 throw ex;
 }
 }

 public void refresh() throws BeansException, IllegalStateException {
 synchronized (this.startupShutdownMonitor) {
 // Prepare this context for refreshing.
 prepareRefresh();

 // Tell the subclass to refresh the internal bean factory.
 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

 // Prepare the bean factory for use in this context.
 prepareBeanFactory(beanFactory);

 try {
 // Allows post-processing of the bean factory in context subclasses.
 postProcessBeanFactory(beanFactory);

 // Invoke factory processors registered as beans in the context.
 invokeBeanFactoryPostProcessors(beanFactory);

 // Register bean processors that intercept bean creation.
 registerBeanPostProcessors(beanFactory);

 // Initialize message source for this context.
 initMessageSource();

 // Initialize event multicaster for this context.
 initApplicationEventMulticaster();

 // Initialize other special beans in specific context subclasses.
 onRefresh();

 // Check for listener beans and register them.
 registerListeners();

 // Instantiate all remaining (non-lazy-init) singletons.
 finishBeanFactoryInitialization(beanFactory);

 // Last step: publish corresponding event.
 finishRefresh();
 }

 catch (BeansException ex) {
 if (logger.isWarnEnabled()) {
  logger.warn("Exception encountered during context initialization - " +
  "cancelling refresh attempt: " + ex);
 }

 // Destroy already created singletons to avoid dangling resources.
 destroyBeans();

 // Reset 'active' flag.
 cancelRefresh(ex);

 // Propagate exception to caller.
 throw ex;
 }

 finally {
 // Reset common introspection caches in Spring's core, since we
 // might not ever need metadata for singleton beans anymore...
 resetCommonCaches();
 }
 }
 }

 protected void onRefresh() {
 super.onRefresh();
 try {
 createWebServer();
 }
 catch (Throwable ex) {
 throw new ApplicationContextException("Unable to start web server", ex);
 }
 }

 private void createWebServer() {
 WebServer webServer = this.webServer;
 ServletContext servletContext = getServletContext();
 if (webServer == null && servletContext == null) {
 ServletWebServerFactory factory = getWebServerFactory();
 // 主要看這個方法
 this.webServer = factory.getWebServer(getSelfInitializer());
 }
 else if (servletContext != null) {
 try {
 getSelfInitializer().onStartup(servletContext);
 }
 catch (ServletException ex) {
 throw new ApplicationContextException("Cannot initialize servlet context", ex);
 }
 }
 initPropertySources();
 }

 public WebServer getWebServer(ServletContextInitializer... initializers) {
 if (this.disableMBeanRegistry) {
 Registry.disableRegistry();
 }
 Tomcat tomcat = new Tomcat();
 File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
 tomcat.setBaseDir(baseDir.getAbsolutePath());
 Connector connector = new Connector(this.protocol);
 connector.setThrowOnFailure(true);
 tomcat.getService().addConnector(connector);
 customizeConnector(connector);
 tomcat.setConnector(connector);
 tomcat.getHost().setAutoDeploy(false);
 configureEngine(tomcat.getEngine());
 for (Connector additionalConnector : this.additionalTomcatConnectors) {
 tomcat.getService().addConnector(additionalConnector);
 }
 prepareContext(tomcat.getHost(), initializers);
 return getTomcatWebServer(tomcat);
 }

Connector connector = new Connector(this.protocol);

 private String protocol = DEFAULT_PROTOCOL;
 public static final String DEFAULT_PROTOCOL = "org.apache.coyote.http11.Http11NioProtocol";

@SpringBootApplication
public class SpringEventDemo {

 public static void main(String[] args) {
  new SpringApplicationBuilder(SpringEventDemo.class)
    .listeners(event -> {
     System.err.println("接收到事件：" + event.getClass().getSimpleName());
    })
    .run()
    .close();
 }

}

org.springframework.context.ApplicationListener=\
org.springframework.boot.ClearCachesApplicationListener,\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,\
org.springframework.boot.context.FileEncodingApplicationListener,\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\
org.springframework.boot.context.config.ConfigFileApplicationListener,\
org.springframework.boot.context.config.DelegatingApplicationListener,\
org.springframework.boot.context.logging.ClasspathLoggingApplicationListener,\
org.springframework.boot.context.logging.LoggingApplicationListener,\
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
 @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {}

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

}

@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {

}

 public String[] selectImports(AnnotationMetadata annotationMetadata) {
 if (!isEnabled(annotationMetadata)) {
 return NO_IMPORTS;
 }
 AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
 .loadMetadata(this.beanClassLoader);
 // 獲取所有的自動配置類
 AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,
 annotationMetadata);
 return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
 }

 protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
 AnnotationMetadata annotationMetadata) {
 if (!isEnabled(annotationMetadata)) {
 return EMPTY_ENTRY;
 }
 AnnotationAttributes attributes = getAttributes(annotationMetadata);
 // SPI獲取EnableAutoConfiguration為key的所有實(shí)現(xiàn)類
 List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
 configurations = removeDuplicates(configurations);
 Set<String> exclusions = getExclusions(annotationMetadata, attributes);
 checkExcludedClasses(configurations, exclusions);
 configurations.removeAll(exclusions);
 // 把某些自動配置類過濾掉
 configurations = filter(configurations, autoConfigurationMetadata);
 fireAutoConfigurationImportEvents(configurations, exclusions);
 // 包裝成自動配置實(shí)體類
 return new AutoConfigurationEntry(configurations, exclusions);
 }

 protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
 // SPI獲取EnableAutoConfiguration為key的所有實(shí)現(xiàn)類
 List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
 getBeanClassLoader());
 Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
 + "are using a custom packaging, make sure that file is correct.");
 return configurations;
 }

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
 List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
 String[] candidateNames = registry.getBeanDefinitionNames();

 for (String beanName : candidateNames) {
 BeanDefinition beanDef = registry.getBeanDefinition(beanName);
 if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
 if (logger.isDebugEnabled()) {
  logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
 }
 }
 else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
 configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
 }
 }

 // Return immediately if no @Configuration classes were found
 if (configCandidates.isEmpty()) {
 return;
 }

 // Sort by previously determined @Order value, if applicable
 configCandidates.sort((bd1, bd2) -> {
 int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
 int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
 return Integer.compare(i1, i2);
 });

 // Detect any custom bean name generation strategy supplied through the enclosing application context
 SingletonBeanRegistry sbr = null;
 if (registry instanceof SingletonBeanRegistry) {
 sbr = (SingletonBeanRegistry) registry;
 if (!this.localBeanNameGeneratorSet) {
 BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
  AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
 if (generator != null) {
  this.componentScanBeanNameGenerator = generator;
  this.importBeanNameGenerator = generator;
 }
 }
 }

 if (this.environment == null) {
 this.environment = new StandardEnvironment();
 }

 // Parse each @Configuration class
 ConfigurationClassParser parser = new ConfigurationClassParser(
 this.metadataReaderFactory, this.problemReporter, this.environment,
 this.resourceLoader, this.componentScanBeanNameGenerator, registry);

 Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
 Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
 do {
 parser.parse(candidates);
 parser.validate();

 Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
 configClasses.removeAll(alreadyParsed);

 // Read the model and create bean definitions based on its content
 if (this.reader == null) {
 this.reader = new ConfigurationClassBeanDefinitionReader(
  registry, this.sourceExtractor, this.resourceLoader, this.environment,
  this.importBeanNameGenerator, parser.getImportRegistry());
 }
 this.reader.loadBeanDefinitions(configClasses);
 alreadyParsed.addAll(configClasses);

 // 省略。。。。
 }

 protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
 if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
 return;
 }

 ConfigurationClass existingClass = this.configurationClasses.get(configClass);
 if (existingClass != null) {
 if (configClass.isImported()) {
 if (existingClass.isImported()) {
  existingClass.mergeImportedBy(configClass);
 }
 // Otherwise ignore new imported config class; existing non-imported class overrides it.
 return;
 }
 else {
 // Explicit bean definition found, probably replacing an import.
 // Let's remove the old one and go with the new one.
 this.configurationClasses.remove(configClass);
 this.knownSuperclasses.values().removeIf(configClass::equals);
 }
 }

 // Recursively process the configuration class and its superclass hierarchy.
 SourceClass sourceClass = asSourceClass(configClass);
 do {
 sourceClass = doProcessConfigurationClass(configClass, sourceClass);
 }
 while (sourceClass != null);

 this.configurationClasses.put(configClass, configClass);
 }

 protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
 throws IOException {
 省略....

 // Process any @Import annotations
 processImports(configClass, sourceClass, getImports(sourceClass), true);

 省略....
 return null;
 }

 private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
 Collection<SourceClass> importCandidates, boolean checkForCircularImports) {

 if (importCandidates.isEmpty()) {
 return;
 }

 if (checkForCircularImports && isChainedImportOnStack(configClass)) {
 this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
 }
 else {
 this.importStack.push(configClass);
 try {
 for (SourceClass candidate : importCandidates) {
  if (candidate.isAssignable(ImportSelector.class)) {
  // Candidate class is an ImportSelector -> delegate to it to determine imports
  Class<?> candidateClass = candidate.loadClass();
  ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
  this.environment, this.resourceLoader, this.registry);
  if (selector instanceof DeferredImportSelector) {
  this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
  }
  else {
  String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
  Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
  processImports(configClass, currentSourceClass, importSourceClasses, false);
  }
  }
  else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
  Class<?> candidateClass = candidate.loadClass();
  ImportBeanDefinitionRegistrar registrar =
  ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
   this.environment, this.resourceLoader, this.registry);
  configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
  }
  else {
  this.importStack.registerImport(
  currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
  processConfigurationClass(candidate.asConfigClass(configClass));
  }
 }
 }
 }
 }

 private List<DeferredImportSelectorHolder> deferredImportSelectors = new ArrayList<>();
 
 public void handle(ConfigurationClass configClass, DeferredImportSelector importSelector) {
 DeferredImportSelectorHolder holder = new DeferredImportSelectorHolder(
  configClass, importSelector);
 if (this.deferredImportSelectors == null) {
 DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
 handler.register(holder);
 handler.processGroupImports();
 }
 else {
 this.deferredImportSelectors.add(holder);
 }
 }

 public void parse(Set<BeanDefinitionHolder> configCandidates) {
 省略.....

 this.deferredImportSelectorHandler.process();
 }

 public void process() {
 List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
 this.deferredImportSelectors = null;
 try {
 if (deferredImports != null) {
 DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
 deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
 deferredImports.forEach(handler::register);
 handler.processGroupImports();
 }
 }
 finally {
 this.deferredImportSelectors = new ArrayList<>();
 }
 }

 public void register(DeferredImportSelectorHolder deferredImport) {
 Class<? extends Group> group = deferredImport.getImportSelector()
 .getImportGroup();
 DeferredImportSelectorGrouping grouping = this.groupings.computeIfAbsent(
 (group != null ? group : deferredImport),
 key -> new DeferredImportSelectorGrouping(createGroup(group)));
 grouping.add(deferredImport);
 this.configurationClasses.put(deferredImport.getConfigurationClass().getMetadata(),
 deferredImport.getConfigurationClass());
 }

 public Class<? extends Group> getImportGroup() {
 return AutoConfigurationGroup.class;
 }

 public void processGroupImports() {
 for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
 grouping.getImports().forEach(entry -> {
  ConfigurationClass configurationClass = this.configurationClasses.get(
  entry.getMetadata());
  try {
  processImports(configurationClass, asSourceClass(configurationClass),
  asSourceClasses(entry.getImportClassName()), false);
  }
  catch (BeanDefinitionStoreException ex) {
  throw ex;
  }
  catch (Throwable ex) {
  throw new BeanDefinitionStoreException(
  "Failed to process import candidates for configuration class [" +
   configurationClass.getMetadata().getClassName() + "]", ex);
  }
 });
 }
 }

 public Iterable<Group.Entry> getImports() {
 for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
 this.group.process(deferredImport.getConfigurationClass().getMetadata(),
  deferredImport.getImportSelector());
 }
 return this.group.selectImports();
 }

Configuration(proxyBeanMethods = false)
@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {

 @Configuration(proxyBeanMethods = false)
 @ConditionalOnClass(Advice.class)
 static class AspectJAutoProxyingConfiguration {

 @Configuration(proxyBeanMethods = false)
 @EnableAspectJAutoProxy(proxyTargetClass = false)
 @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false",
 matchIfMissing = false)
 static class JdkDynamicAutoProxyConfiguration {

 }

 @Configuration(proxyBeanMethods = false)
 @EnableAspectJAutoProxy(proxyTargetClass = true)
 @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
 matchIfMissing = true)
 static class CglibAutoProxyConfiguration {

 }
 }

 @Configuration(proxyBeanMethods = false)
 @ConditionalOnMissingClass("org.aspectj.weaver.Advice")
 @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
 matchIfMissing = true)
 static class ClassProxyingConfiguration {

 ClassProxyingConfiguration(BeanFactory beanFactory) {
 if (beanFactory instanceof BeanDefinitionRegistry) {
 BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
 AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
 AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
 }
 }

 }

}

public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
 if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
 return false;
 }

 if (phase == null) {
 if (metadata instanceof AnnotationMetadata &&
  ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
 return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
 }
 return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
 }

 List<Condition> conditions = new ArrayList<>();
 for (String[] conditionClasses : getConditionClasses(metadata)) {
 for (String conditionClass : conditionClasses) {
 Condition condition = getCondition(conditionClass, this.context.getClassLoader());
 conditions.add(condition);
 }
 }

 AnnotationAwareOrderComparator.sort(conditions);

 for (Condition condition : conditions) {
 ConfigurationPhase requiredPhase = null;
 if (condition instanceof ConfigurationCondition) {
 requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
 }
 if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
 return true;
 }
 }

 return false;
 }

 public final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
 String classOrMethodName = getClassOrMethodName(metadata);
 try {
 ConditionOutcome outcome = getMatchOutcome(context, metadata);
 logOutcome(classOrMethodName, outcome);
 recordEvaluation(context, classOrMethodName, outcome);
 return outcome.isMatch();
 }

 public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
 ConditionMessage matchMessage = ConditionMessage.empty();
 MergedAnnotations annotations = metadata.getAnnotations();
 if (annotations.isPresent(ConditionalOnBean.class)) {
 Spec<ConditionalOnBean> spec = new Spec<>(context, metadata, annotations, ConditionalOnBean.class);
 MatchResult matchResult = getMatchingBeans(context, spec);
 if (!matchResult.isAllMatched()) {
 String reason = createOnBeanNoMatchReason(matchResult);
 return ConditionOutcome.noMatch(spec.message().because(reason));
 }
 matchMessage = spec.message(matchMessage).found("bean", "beans").items(Style.QUOTE,
  matchResult.getNamesOfAllMatches());
 }
 if (metadata.isAnnotated(ConditionalOnSingleCandidate.class.getName())) {
 Spec<ConditionalOnSingleCandidate> spec = new SingleCandidateSpec(context, metadata, annotations);
 MatchResult matchResult = getMatchingBeans(context, spec);
 if (!matchResult.isAllMatched()) {
 return ConditionOutcome.noMatch(spec.message().didNotFind("any beans").atAll());
 }
 else if (!hasSingleAutowireCandidate(context.getBeanFactory(), matchResult.getNamesOfAllMatches(),
  spec.getStrategy() == SearchStrategy.ALL)) {
 return ConditionOutcome.noMatch(spec.message().didNotFind("a primary bean from beans")
  .items(Style.QUOTE, matchResult.getNamesOfAllMatches()));
 }
 matchMessage = spec.message(matchMessage).found("a primary bean from beans").items(Style.QUOTE,
  matchResult.getNamesOfAllMatches());
 }
 if (metadata.isAnnotated(ConditionalOnMissingBean.class.getName())) {
 Spec<ConditionalOnMissingBean> spec = new Spec<>(context, metadata, annotations,
  ConditionalOnMissingBean.class);
 MatchResult matchResult = getMatchingBeans(context, spec);
 if (matchResult.isAnyMatched()) {
 String reason = createOnMissingBeanNoMatchReason(matchResult);
 return ConditionOutcome.noMatch(spec.message().because(reason));
 }
 matchMessage = spec.message(matchMessage).didNotFind("any beans").atAll();
 }
 return ConditionOutcome.match(matchMessage);
 }

 protected final MatchResult getMatchingBeans(ConditionContext context, Spec<?> spec) {
 ClassLoader classLoader = context.getClassLoader();
 ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
 boolean considerHierarchy = spec.getStrategy() != SearchStrategy.CURRENT;
 Set<Class<?>> parameterizedContainers = spec.getParameterizedContainers();
 if (spec.getStrategy() == SearchStrategy.ANCESTORS) {
 BeanFactory parent = beanFactory.getParentBeanFactory();
 Assert.isInstanceOf(ConfigurableListableBeanFactory.class, parent,
  "Unable to use SearchStrategy.ANCESTORS");
 beanFactory = (ConfigurableListableBeanFactory) parent;
 }
 MatchResult result = new MatchResult();
 Set<String> beansIgnoredByType = getNamesOfBeansIgnoredByType(classLoader, beanFactory, considerHierarchy,
 spec.getIgnoredTypes(), parameterizedContainers);
 for (String type : spec.getTypes()) {
 Collection<String> typeMatches = getBeanNamesForType(classLoader, considerHierarchy, beanFactory, type,
  parameterizedContainers);
 typeMatches.removeAll(beansIgnoredByType);
 if (typeMatches.isEmpty()) {
 result.recordUnmatchedType(type);
 }
 else {
 result.recordMatchedType(type, typeMatches);
 }
 }
 for (String annotation : spec.getAnnotations()) {
 Set<String> annotationMatches = getBeanNamesForAnnotation(classLoader, beanFactory, annotation,
  considerHierarchy);
 annotationMatches.removeAll(beansIgnoredByType);
 if (annotationMatches.isEmpty()) {
 result.recordUnmatchedAnnotation(annotation);
 }
 else {
 result.recordMatchedAnnotation(annotation, annotationMatches);
 }
 }
 for (String beanName : spec.getNames()) {
 if (!beansIgnoredByType.contains(beanName) && containsBean(beanFactory, beanName, considerHierarchy)) {
 result.recordMatchedName(beanName);
 }
 else {
 result.recordUnmatchedName(beanName);
 }
 }
 return result;
 }