《Yangzai的知识地图》- Springboot源码

阳光穿透心脏的1/2处 2022-10-29 13:23 136阅读 0赞

# Springboot源码分析及一些理解 #

> 看这个之前需要一些Spring的知识可以参考下面这些  
> 系类文章  
> 1、[Spring源码分析][Spring]  
> 2、[Spring开篇][Spring]  
> 3、[Bean的生命周期][Bean]

--------------------

### 文章目录 ###

*  Springboot源码分析及一些理解
 *  前言
 *  一、Springboot是什么？
 *  二、Springboot启动流程
 *   *  1.XXApplication
     *   *  1.1 SpringApplication
         *  1.2 Starter

--------------------

# 前言 #

这是个人技术学习总结的相关文章，是对自己的查缺补漏。

--------------------

# 一、Springboot是什么？ #

> [官方文档][Link 1]

*  个人理解

> SpringBoot 相较于Spring进行了相应的功能扩展，如内嵌web容器、提供starter简化项目配置依赖，尽量做到开箱即用，自动配置，将以前人为的重复工作交由Springboot来实现，并将配置的bean交由Spring容器管理，总之就是为了方便开发【一个字懒】

*  重点关注几个特性【主要是加粗部分】

>  *  Create stand-alone Spring applications
>  *  Embed Tomcat, Jetty or Undertow directly (no need to deploy  
>     WAR files)
>  *  **Provide opinionated ‘starter’ dependencies to simplify your build  
>     configuration**
>  *  **Automatically configure Spring and 3rd party libraries whenever  
>     possible**
>  *  Provide production-ready features such as metrics, health checks, > and externalized configuration
>  *  Absolutely no code generation and no requirement for XMLconfiguration

# 二、Springboot启动流程 #

## 1.XXApplication ##

代码如下（示例）：

***代码流程1.***

@EnableCaching
    @EnableAspectJAutoProxy
    @SpringBootApplication
    public class XXApplication { 
    	//每个Springboot项目我们都可以看到这样的main函数，这个就是Springboot项目的入口函数
        public static void main(String[] args) { 
        	//重点关注一下这个run方法
            SpringApplication.run(XXApplication.class, args);
        }
    }

*  下面我们就一点点跟一下代码

***代码流程2.***

public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) { 
    		return run(new Class<?>[] {  primarySource }, args);
    	}

***代码流程3.***

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) { 
    		return new SpringApplication(primarySources).run(args);
    	}

### 1.1 SpringApplication ###

> 首先会创建SpringApplication，然后在调用run方法

***代码流程4.***

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) { 
    	//这个地方入参为空
       	this.resourceLoader = resourceLoader;
       	Assert.notNull(primarySources, "PrimarySources must not be null");
       	//primarySources 其实就是我们的启动类
       	this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
       	//设置web应用的类型
       	this.webApplicationType = WebApplicationType.deduceFromClasspath();
       	//从spring.factories中加载ApplicationContextInitializer的实现类
       	setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
       	//从spring.factories中加载ApplicationListener的实现类
       	setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
       	//从堆栈信息中找到运行主函数
       	this.mainApplicationClass = deduceMainApplicationClass();
       }

*  执行run方法

***代码流程5.***

public ConfigurableApplicationContext run(String... args) { 
     		//创建StopWatch 主要用于应用启动计时统计
    		StopWatch stopWatch = new StopWatch();
    		//计时
    		stopWatch.start();
    		//上下文信息声明
    		ConfigurableApplicationContext context = null;
    		//应用异常报告类
    		Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    		//这个可以不关注
    		configureHeadlessProperty();
    		//获取spring.factories中SpringApplicationRunListener的实现类并实例化他们
    		SpringApplicationRunListeners listeners = getRunListeners(args);
    		//开始监听
    		listeners.starting();
    		try { 
    		    //应用启动参数
    			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
    			//运行环境配置获取
    			ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
    			configureIgnoreBeanInfo(environment);
    			//准备banner资源
    			Banner printedBanner = printBanner(environment);
    			context = createApplicationContext();
    			获取spring.factories中SpringBootExceptionReporter的实现类并实例化他们
    			exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
    					new Class[] {  ConfigurableApplicationContext.class }, context);
    			//准备上下文详见代码流程5.1
    			prepareContext(context, environment, listeners, applicationArguments, printedBanner);
    			//上面已经准备好了Bean工厂，下面我们就要开始执行Bean的创建工作将代码流程5.2 这个地方我们直接跟进到Spring的refresh方法
    			refreshContext(context);
    			afterRefresh(context, applicationArguments);
    			stopWatch.stop();
    			if (this.logStartupInfo) { 
    				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
    			}
    			listeners.started(context);
    			callRunners(context, applicationArguments);
    		}
    		catch (Throwable ex) { 
    			handleRunFailure(context, ex, exceptionReporters, listeners);
    			throw new IllegalStateException(ex);
    		}
    
    		try { 
    			listeners.running(context);
    		}
    		catch (Throwable ex) { 
    			handleRunFailure(context, ex, exceptionReporters, null);
    			throw new IllegalStateException(ex);
    		}
    		return context;
    	}

***代码流程5.1.***

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
    		//获取BeanFactory--DefaultListableBeanFactory
    		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
    		//加载资源 source 
    		Set<Object> sources = getAllSources();
    		Assert.notEmpty(sources, "Sources must not be empty");
    		//根据配置类注册所有的资源
    		load(context, sources.toArray(new Object[0]));
    		listeners.contextLoaded(context);
    	}

***代码流程5.2.***

@Override
    	public void refresh() throws BeansException, IllegalStateException { 
    		synchronized (this.startupShutdownMonitor) { 
    			// Prepare this context for refreshing.
    			prepareRefresh();
    
    			// Tell the subclass to refresh the internal bean factory.
    			//获取上面准备步骤得到的DefaultListableBeanFactory
    			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.
    				//重点关注这一步骤将代码流程5.2.1
    				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();
    			}
    		}
    	}

***代码流程5.2.1.***

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { 
    		//重点关注这个方法见代码流程5.2.1.1
    		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    
    		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
    		// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
    		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { 
    			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
    			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    		}
    	}

***代码流程5.2.1.1.***

private static void invokeBeanDefinitionRegistryPostProcessors(
    			Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) { 
    
    		for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) { 
    			/** *跟进去找到具体实现类org.springframework.context.annotation.ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry 看代码流程5.2.1.2 */
    			postProcessor.postProcessBeanDefinitionRegistry(registry);
    		}
    	}

***代码流程5.2.1.2***

@Override
    	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) { 
    		int registryId = System.identityHashCode(registry);
    		if (this.registriesPostProcessed.contains(registryId)) { 
    			throw new IllegalStateException(
    					"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
    		}
    		if (this.factoriesPostProcessed.contains(registryId)) { 
    			throw new IllegalStateException(
    					"postProcessBeanFactory already called on this post-processor against " + registry);
    		}
    		this.registriesPostProcessed.add(registryId);
    		//继续跟这个方法见代码流程5.2.1.3
    		processConfigBeanDefinitions(registry);
    	}

***代码流程5.2.1.3***

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 { 
    		    //重点关注这个方法代码流程5.2.1.4
    			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);
    
    			candidates.clear();
    			if (registry.getBeanDefinitionCount() > candidateNames.length) { 
    				String[] newCandidateNames = registry.getBeanDefinitionNames();
    				Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
    				Set<String> alreadyParsedClasses = new HashSet<>();
    				for (ConfigurationClass configurationClass : alreadyParsed) { 
    					alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
    				}
    				for (String candidateName : newCandidateNames) { 
    					if (!oldCandidateNames.contains(candidateName)) { 
    						BeanDefinition bd = registry.getBeanDefinition(candidateName);
    						if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
    								!alreadyParsedClasses.contains(bd.getBeanClassName())) { 
    							candidates.add(new BeanDefinitionHolder(bd, candidateName));
    						}
    					}
    				}
    				candidateNames = newCandidateNames;
    			}
    		}
    		while (!candidates.isEmpty());
    
    		// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
    		if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) { 
    			sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
    		}
    
    		if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) { 
    			// Clear cache in externally provided MetadataReaderFactory; this is a no-op
    			// for a shared cache since it'll be cleared by the ApplicationContext.
    			((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
    		}
    	}

***代码流程5.2.1.4***

public void parse(Set<BeanDefinitionHolder> configCandidates) { 
    		for (BeanDefinitionHolder holder : configCandidates) { 
    			BeanDefinition bd = holder.getBeanDefinition();
    			try { 
    			    //因为我们使用的时注解方式所以走这个流程
    				if (bd instanceof AnnotatedBeanDefinition) { 
    				    //见代码流程5.2.1.5
    					parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
    				}
    				else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) { 
    					parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
    				}
    				else { 
    					parse(bd.getBeanClassName(), holder.getBeanName());
    				}
    			}
    			catch (BeanDefinitionStoreException ex) { 
    				throw ex;
    			}
    			catch (Throwable ex) { 
    				throw new BeanDefinitionStoreException(
    						"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
    			}
    		}
    
    		this.deferredImportSelectorHandler.process();
    	}

***代码流程5.2.1.5***

protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) 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, filter);
    		do { 
    			//重点关注这个方法 见 代码流程5.2.1.6
    			sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
    		}
    		while (sourceClass != null);
    
    		this.configurationClasses.put(configClass, configClass);
    	}

***代码流程5.2.1.6***

protected final SourceClass doProcessConfigurationClass(
    			ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
    			throws IOException { 
    
    		if (configClass.getMetadata().isAnnotated(Component.class.getName())) { 
    			// Recursively process any member (nested) classes first
    			processMemberClasses(configClass, sourceClass, filter);
    		}
    
    		// Process any @PropertySource annotations
    		for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
    				sourceClass.getMetadata(), PropertySources.class,
    				org.springframework.context.annotation.PropertySource.class)) { 
    			if (this.environment instanceof ConfigurableEnvironment) { 
    				processPropertySource(propertySource);
    			}
    			else { 
    				logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
    						"]. Reason: Environment must implement ConfigurableEnvironment");
    			}
    		}
    
    		// Process any @ComponentScan annotations
    		Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
    				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
    		if (!componentScans.isEmpty() &&
    				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) { 
    			for (AnnotationAttributes componentScan : componentScans) { 
    				// The config class is annotated with @ComponentScan -> perform the scan immediately
    				Set<BeanDefinitionHolder> scannedBeanDefinitions =
    						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
    				// Check the set of scanned definitions for any further config classes and parse recursively if needed
    				for (BeanDefinitionHolder holder : scannedBeanDefinitions) { 
    					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
    					if (bdCand == null) { 
    						bdCand = holder.getBeanDefinition();
    					}
    					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) { 
    						parse(bdCand.getBeanClassName(), holder.getBeanName());
    					}
    				}
    			}
    		}
    
    		// Process any @Import annotations
    		//关注getImports 见 代码流程5.2.1.7 和 processImports 见 代码流程5.2.1.8
    		processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
    
    		// Process any @ImportResource annotations
    		AnnotationAttributes importResource =
    				AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
    		if (importResource != null) { 
    			String[] resources = importResource.getStringArray("locations");
    			Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
    			for (String resource : resources) { 
    				String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
    				configClass.addImportedResource(resolvedResource, readerClass);
    			}
    		}
    
    		// Process individual @Bean methods
    		Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
    		for (MethodMetadata methodMetadata : beanMethods) { 
    			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    		}
    
    		// Process default methods on interfaces
    		processInterfaces(configClass, sourceClass);
    
    		// Process superclass, if any
    		if (sourceClass.getMetadata().hasSuperClass()) { 
    			String superclass = sourceClass.getMetadata().getSuperClassName();
    			if (superclass != null && !superclass.startsWith("java") &&
    					!this.knownSuperclasses.containsKey(superclass)) { 
    				this.knownSuperclasses.put(superclass, configClass);
    				// Superclass found, return its annotation metadata and recurse
    				return sourceClass.getSuperClass();
    			}
    		}
    
    		// No superclass -> processing is complete
    		return null;
    	}

***代码流程5.2.1.7***

private Set<SourceClass> getImports(SourceClass sourceClass) throws IOException { 
    		Set<SourceClass> imports = new LinkedHashSet<>();
    		Set<SourceClass> visited = new LinkedHashSet<>();
    		collectImports(sourceClass, imports, visited);
    		return imports;
    	}

***代码流程5.2.1.8***

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
    			Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
    			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);
    						Predicate<String> selectorFilter = selector.getExclusionFilter();
    						if (selectorFilter != null) { 
    							exclusionFilter = exclusionFilter.or(selectorFilter);
    						}
    						if (selector instanceof DeferredImportSelector) { 
    							this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
    						}
    						else { 
    						    //重点关注这个方法selectImports 见代码流程5.2.1.9 实现类org.springframework.boot.autoconfigure.AutoConfigurationImportSelector#selectImports
    							String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
    							Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
    							processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
    						}
    					}
    					else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) { 
    						// Candidate class is an ImportBeanDefinitionRegistrar ->
    						// delegate to it to register additional bean definitions
    						Class<?> candidateClass = candidate.loadClass();
    						ImportBeanDefinitionRegistrar registrar =
    								ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
    										this.environment, this.resourceLoader, this.registry);
    						configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
    					}
    					else { 
    						// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
    						// process it as an @Configuration class
    						this.importStack.registerImport(
    								currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
    						processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
    					}
    				}
    			}
    			catch (BeanDefinitionStoreException ex) { 
    				throw ex;
    			}
    			catch (Throwable ex) { 
    				throw new BeanDefinitionStoreException(
    						"Failed to process import candidates for configuration class [" +
    						configClass.getMetadata().getClassName() + "]", ex);
    			}
    			finally { 
    				this.importStack.pop();
    			}
    		}
    	}

***代码流程5.2.1.9***

@Override
    	public String[] selectImports(AnnotationMetadata annotationMetadata) { 
    		if (!isEnabled(annotationMetadata)) { 
    			return NO_IMPORTS;
    		}
    		AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
    				.loadMetadata(this.beanClassLoader);
    		//重点关注这个方法见代码流程5.2.1.10
    		AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,
    				annotationMetadata);
    		return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    	}

***代码流程5.2.1.10***

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
    			AnnotationMetadata annotationMetadata) { 
    		if (!isEnabled(annotationMetadata)) { 
    			return EMPTY_ENTRY;
    		}
    		AnnotationAttributes attributes = getAttributes(annotationMetadata);
    		//重点关注这个方法见代码流程5.2.1.11
    		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);
    		return new AutoConfigurationEntry(configurations, exclusions);
    	}

***代码流程5.2.1.11***

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) { 
    		//获取自动配置类List集合
    		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;
    	}
    	//这个就是获取的EnableAutoConfiguration注解
    	protected Class<?> getSpringFactoriesLoaderFactoryClass() { 
    		return EnableAutoConfiguration.class;
    	}
    	//-----------------------------------------------------------------------------
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import(AutoConfigurationImportSelector.class)
    public @interface EnableAutoConfiguration { 
    
    	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    
    	/** * Exclude specific auto-configuration classes such that they will never be applied. * @return the classes to exclude */
    	Class<?>[] exclude() default { };
    
    	/** * Exclude specific auto-configuration class names such that they will never be * applied. * @return the class names to exclude * @since 1.3.0 */
    	String[] excludeName() default { };
    
    }

*  以上就是一个自动装配的完整解析流程

> 也就是一个从connection中获取session、一个从datasource中获取session。

### 1.2 Starter ###

> Starter就是一个配置好的pom文件，然后作为mav嗯项目进行依赖  
> 每一个starter都需要依赖autoconfigure的pom文件。然后将自身需要扩展的类放置在spriing.factories中进行配置，然后交给Spring扫描并管理。

[Spring]: https://blog.csdn.net/YangzaiLeHeHe/article/details/113390665
[Bean]: https://blog.csdn.net/YangzaiLeHeHe/article/details/113396586
[Link 1]: https://spring.io/projects/spring-boot?__cf_chl_captcha_tk__=ca496dc971723f7474d2a674e30db5972e3d86a9-1613356523-0-ARnazpjLTA6fA2WfqGJcbHjy-3NrrFEPvFRrihmNecFhIt43srH0zxDKr-SDHx2wygj9pykVYkVK9_RiFDTv0IjQvZOcBFnJ8_xvZeu7QLAhTtXYz9lkRNdjG25j6r6FI_LK-7jynjN916RJ4Y3SeYbKLzaWFwdS2AiUUjmIkhnrX_L59VtMaC376HZiiUXRnfm9v91zpaoMISEPLw5WVRr33nHrUiIxqKQmhtrhCn4zx6kwMbqfMBzESgPTY_F321rGYgzASdjnSQOMQiKNs10DYTAYfJXNk2nvLLwcl9WxUPRO59t0dU_MctiK531mAXYzjnZ45rGLEXJWniHo8Llvv9wWJsoAE34SxnRbuNel3NhkXxTNtXmfuiWAaBwk_j5DhIPdqrTPbWNMhpffWO1rBMDHdtiD9ZpwHHq1g63wJD48Y5WppiM3WpdKsZMxK2PaxpA4xhh028W1ACUavhdqDnBlKCq4gqwWhU8KLE58phi7mMkB2Xz7mpwCmo7fmelCSXfSkt6RlCNDFFdzUV9u8h-bT2tk2-mZalwgNey9iM4gOyuKmnbTq-2eLxGdaQ