SpringBoot源码解析

自动配置(SpringBootApplication)

​ 自动配置是指根据我们添加的jar包依赖，会自动将一些配置类的bean注册进IOC容器，我们可以在需要的地方使用@Autowired或者@Resource等注解来使用。

那么SpringBoot是如何实现自动配置的呢，都把那些组件进行了自动配置？

首先需要从启动类说起。

被标注了SpringBootApplication的类为核心启动类，此注解是一个组合注解，,此注解中重要的就是SpringBootConfiguration、EnableAutoConfiguration、ComponentScan

1
2
3
4
5
6
7
8
9
10
11
12
@Target(ElementType.TYPE)  //注解的适用5范围，Type表示注解可以描述在类、接口、注解或枚举中
@Retention(RetentionPolicy.RUNTIME)  //表示注解的生命周期 Runtime表示运行时
@Documented  //表示该注解可以记录在javadoc中
@Inherited // 表示可以被子类继承该注解
//--------------------  源注解
@SpringBootConfiguration //标明该类为配置类
@EnableAutoConfiguration //开启自动配置功能
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) }) //注解扫描
public @interface SpringBootApplication {
    
}

SpringBootConfiguration

1
2
3
4
5
6
7
8
9
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
//-----------------------
@Configuration //标注该类为配置类
@Indexed
public @interface SpringBootConfiguration {
    
}

EnableAutoConfiguration

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage //自动配置包
@Import(AutoConfigurationImportSelector.class) // spring的底层注解@Import，给容器导入一个组件，导入的组件是AutoConfigurationPackages.Register.class
public @interface EnableAutoConfiguration { //告诉SpringBoot开启自动配置功能，这样自动配置才会生效

	/**
	 * Environment property that can be used to override when auto-configuration is
	 * enabled.
	 */
	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

	/**
	 * Exclude specific auto-configuration classes such that they will never be applied.
	 * @return the classes to exclude //返回不会被导入到Spring容器中的类
	 */
	Class<?>[] exclude() default {};

	/**
	 * Exclude specific auto-configuration class names such that they will never be
	 * applied.
	 * @return the class names to exclude  // 返回不会被导入Spring容器中的类名
	 * @since 1.3.0
	 */
	String[] excludeName() default {};

}

Spring中有很多以Enable开头的注解，其作用就是借助@Import来收集并注册特定场景相关的Bean，并加载到IOC容器中。

@EnableAutoConfiguration就是借助@Import来收集所有符合自动配置条件的bean的定义，并加载到IOC容器。

AutoConfigurationPackage
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class) // spring的底层注解@Import，给容器中导入一个组件，导入的组件是AutoConfigurationPackages.Registrar.class
public @interface AutoConfigurationPackage {

	/**
	 * Base packages that should be registered with {@link AutoConfigurationPackages}.
	 * <p>
	 * Use {@link #basePackageClasses} for a type-safe alternative to String-based package
	 * names.
	 * @return the back package names
	 * @since 2.3.0
	 */
	String[] basePackages() default {};

	/**
	 * Type-safe alternative to {@link #basePackages} for specifying the packages to be
	 * registered with {@link AutoConfigurationPackages}.
	 * <p>
	 * Consider creating a special no-op marker class or interface in each package that
	 * serves no purpose other than being referenced by this attribute.
	 * @return the base package classes
	 * @since 2.3.0
	 */
	Class<?>[] basePackageClasses() default {};

}

@AutoConfigurationPackage：自动配置包，也是一个组合注解，其中最重要的注解是@Import(AutoConfigurationPackages.Registrar.class)，他是Spring框架的底层注解，他的作用就是给容器中导入某个组件类，例如@Import(AutoConfigurationPackages.Registrar.class)，它是将Registrar这个组件类导入到容器中，可查看Registrar中的registerBeanDefinitions方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//AutoConfigurationPackages.Registrar.class,是AutoConfigurationPackages中的一个静态类
public abstract class AutoConfigurationPackages {
    static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

		@Override
		public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            //将注解标注的源信息传入，获取相应的报名
            // new PackageImports(metadata).getPackageNames().toArray(new String[0]) ---net.oiyou.webdemo，即为注解标注的类所在的包路径
			register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
		}

		@Override
		public Set<Object> determineImports(AnnotationMetadata metadata) {
			return Collections.singleton(new PackageImports(metadata));
		}
	}
    
    public static void register(BeanDefinitionRegistry registry, String... packageNames) {
        //这里参数packageNames 缺省情况下就是一个字符串，是使用了@SSpringBootApplication的SpringBoot应用程序入口类所在的包
		if (registry.containsBeanDefinition(BEAN)) {
            //如果该bean已经注册，则将要注册包名称添加进去
			addBasePackages(registry.getBeanDefinition(BEAN), packageNames);
		}
		else {
            //如果bean未注册，则注册该bean，参数中提供的包名称都会被设置到bean定义中
			RootBeanDefinition beanDefinition = new RootBeanDefinition(BasePackages.class);
			beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
			addBasePackages(beanDefinition, packageNames);
			registry.registerBeanDefinition(BEAN, beanDefinition);
		}
	}
    
}

AutoConfigurationPaackages.Registrar这个类就干一个事，注册一个bean，这个bean就是org.springframework.boot.autoconfigure.AutoConfigurationPackages.BasePackages，它只有一个参数，这个参数是试用了@AutoConfigurationPackage这个注解的类所在的包路径，保存自动配置类以供之后的使用。

bean注册方法包含两个参数，其中metadata是注解的元数据信息，registry为bean定义的注册中心

image.png

@Import(AutoConfigurationImportSelector.class)

借助@Import，将AutoConfigurationSelector注入IOC容器中，AutoConfigurationSelector可以帮助SpringBoot将所有符合条件的@Configuration配置都加载到当前SpringBoot创建并使用的IOC容器(ApplicationConttext)中

AutoConfigurationSelector

从类继承上可以看出该类继承了BeanClassLoaderAware,ResourceLoaderAware, BeanFactoryAware, EnvironmentAware几个Aware接口，实现Aware接口，就会执行相应的回调，拿到对应的Sspring组件，然后赋值给此类中的对应属性；

此外还实现了DeferredImportSelector，是ImportSelectot(spring中用于导入外部配置的核心接口)， 

1
2
3
4
5
6
7
8
9
10
11
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
		ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
            
    private ConfigurableListableBeanFactory beanFactory;

	private Environment environment;

	private ClassLoader beanClassLoader;

	private ResourceLoader resourceLoader;   
}

确定自动配置实现逻辑的入口方法：跟自动配置相关的入口方法在DeferredImportSelectorGrouping类中的getImports方法处，因此我们从DeferredImportSelectorGrouping类的getImports方法开始分析SpringBoot的自动配置就好(后续有调用入口说明)

DeferredImportSelectorGrouping是ConfigurationClassParser的一个静态内部类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
class ConfigurationClassParser {
    private static class DeferredImportSelectorGrouping {

		private final DeferredImportSelector.Group group;

		private final List<DeferredImportSelectorHolder> deferredImports = new ArrayList<>();

		DeferredImportSelectorGrouping(Group group) {
			this.group = group;
		}

		public void add(DeferredImportSelectorHolder deferredImport) {
			this.deferredImports.add(deferredImport);
		}

		/**
		 * Return the imports defined by the group.
		 * @return each import with its associated configuration class
		 */
		public Iterable<Group.Entry> getImports() {
            //遍历DeferredImportSelectorHolder对象集合deferredImports，deferredImports集合装了各种ImportSelector，当然这里装的是AutoConfigurationImportSelector
			for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
                //调用AutoConfigurationImportSelector.process方法,
                // 【1】 利用AutoConfigurationGroup的process方法来处理自动配置相关的逻辑，决定导入那些配置类(这个是分析的重点，自动配置逻辑全在这里)
				this.group.process(deferredImport.getConfigurationClass().getMetadata(),
                        // 即AutoConfigurationImportSelector
						deferredImport.getImportSelector());
			}
            //【2】 经过上面的处理后，然后在进行选择导入那些配置类
			return this.group.selectImports();
		}

		public Predicate<String> getCandidateFilter() {
			Predicate<String> mergedFilter = DEFAULT_EXCLUSION_FILTER;
			for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
				Predicate<String> selectorFilter = deferredImport.getImportSelector().getExclusionFilter();
				if (selectorFilter != null) {
					mergedFilter = mergedFilter.or(selectorFilter);
				}
			}
			return mergedFilter;
		}
	}
}

实现逻辑在AutoConfigurationImportSelector中的AutoConfigurationGroup类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
		ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
	
        /**
        ....
        */
            
        private static class AutoConfigurationGroup
			implements DeferredImportSelector.Group, BeanClassLoaderAware, BeanFactoryAware, ResourceLoaderAware {

		private final Map<String, AnnotationMetadata> entries = new LinkedHashMap<>();

		private final List<AutoConfigurationEntry> autoConfigurationEntries = new ArrayList<>();

		private ClassLoader beanClassLoader;

		private BeanFactory beanFactory;

		private ResourceLoader resourceLoader;

		private AutoConfigurationMetadata autoConfigurationMetadata;

		@Override
		public void setBeanClassLoader(ClassLoader classLoader) {
			this.beanClassLoader = classLoader;
		}

		@Override
		public void setBeanFactory(BeanFactory beanFactory) {
			this.beanFactory = beanFactory;
		}

		@Override
		public void setResourceLoader(ResourceLoader resourceLoader) {
			this.resourceLoader = resourceLoader;
		}

        //这里用来处理自动配置类，比如过滤掉不符合条件的自动配置类    
		@Override
		public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
			Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
					() -> String.format("Only %s implementations are supported, got %s",
							AutoConfigurationImportSelector.class.getSimpleName(),
							deferredImportSelector.getClass().getName()));
            // 【1】调用getAutoConfiguraationEnrty方法的带自动配置类放入autoConfigurationEntry对象中
			AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
					.getAutoConfigurationEntry(annotationMetadata);
            //【2】又将封装了自动配置类的autoConfigurationEntry对象装进autoConfigurationEntries集合
			this.autoConfigurationEntries.add(autoConfigurationEntry);
            // 【3】遍历刚获取到的自动配置类
			for (String importClassName : autoConfigurationEntry.getConfigurations()) {
                //这里将符合条件的自动配置类作为key，annotationMetadata作为值放进entries中  
				this.entries.putIfAbsent(importClassName, annotationMetadata);
			}
		}

		@Override
		public Iterable<Entry> selectImports() {
			if (this.autoConfigurationEntries.isEmpty()) {
				return Collections.emptyList();
			}
            // 这里得到所有要排除的自动配置类的set集合
			Set<String> allExclusions = this.autoConfigurationEntries.stream()
					.map(AutoConfigurationEntry::getExclusions).flatMap(Collection::stream).collect(Collectors.toSet());
            //这里得到经过过滤后的所有符合条件的自动配置类的set集合
			Set<String> processedConfigurations = this.autoConfigurationEntries.stream()
					.map(AutoConfigurationEntry::getConfigurations).flatMap(Collection::stream)
					.collect(Collectors.toCollection(LinkedHashSet::new));
            //移除掉要排除的自动配置类
			processedConfigurations.removeAll(allExclusions);
            // 对标注有@order注解的自动配置类进行排序
			return sortAutoConfigurations(processedConfigurations, getAutoConfigurationMetadata()).stream()
					.map((importClassName) -> new Entry(this.entries.get(importClassName), importClassName)).toList();
		}

		private AutoConfigurationMetadata getAutoConfigurationMetadata() {
			if (this.autoConfigurationMetadata == null) {
				this.autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
			}
			return this.autoConfigurationMetadata;
		}

		private List<String> sortAutoConfigurations(Set<String> configurations,
				AutoConfigurationMetadata autoConfigurationMetadata) {
			return new AutoConfigurationSorter(getMetadataReaderFactory(), autoConfigurationMetadata)
					.getInPriorityOrder(configurations);
		}

		private MetadataReaderFactory getMetadataReaderFactory() {
			try {
				return this.beanFactory.getBean(SharedMetadataReaderFactoryContextInitializer.BEAN_NAME,
						MetadataReaderFactory.class);
			}
			catch (NoSuchBeanDefinitionException ex) {
				return new CachingMetadataReaderFactory(this.resourceLoader);
			}
		}

	}
    
    // 获取符合条件的配置类   
    protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
        //【1】 得到spring.factories文件配置的所有自动配置类，2.7版本后迁移至META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
        
        // 利用LinkedHashSet移除重复的我配置项
		configurations = removeDuplicates(configurations);
        //得到要排除的自动配置类，比如注解属性exclude的配置类
        //比如@SpringBootApplication(exclude = FreeMarkereAutoConfiguration.class)
        // 将获取到exclude = FreeMarkereAutoConfiguration.class的注解数据
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
        // 检查要被排除的配置类，因为有些不是自动配置类，故要抛出异常
		checkExcludedClasses(configurations, exclusions);
        //【2】将要排除的配置类移除
		configurations.removeAll(exclusions);
        // 【3】因为从文件啊中获取到的自动配置类数量很多，如果有些不必要的而自动配置类都加载进内存，会造成内存浪费，
        // 因此需要过滤s
		configurations = getConfigurationClassFilter().filter(configurations);
        // 【4】 获取了符合条件的自动配置类后，此时出发AutoConfigurationImportEvent事件
        // 目的是告诉ConditionEvaluationReport条件评估报告器对象来记录符合条件的自动配置类s
		fireAutoConfigurationImportEvents(configurations, exclusions);
        //【5】将满足条件和要排除的自动配置类封装进AutoConfigurationEntry对象并返回
		return new AutoConfigurationEntry(configurations, exclusions);
	}
    
    //获取所有自动配置类
    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        // 这个方法需要传入两个参数AutoConfiguration.class(2.7版本前后会有不一致)和getBeanClassLoader()
        //
        //getBeanClassLoade()这个方法返回的是beanClasLoader(类加载器)
		List<String> configurations = ImportCandidates.load(AutoConfiguration.class, getBeanClassLoader())
				.getCandidates();
		Assert.notEmpty(configurations,
				"No auto configuration classes found in "
						+ "META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. If you "
						+ "are using a custom packaging, make sure that file is correct.");
		return configurations;
	}
            
    // 过滤 
    private static class ConfigurationClassFilter {

		private final AutoConfigurationMetadata autoConfigurationMetadata;

		private final List<AutoConfigurationImportFilter> filters;

		ConfigurationClassFilter(ClassLoader classLoader, List<AutoConfigurationImportFilter> filters) {
			this.autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(classLoader);
			this.filters = filters;
		}

		List<String> filter(List<String> configurations) {
			long startTime = System.nanoTime();
            //将获取到的自动配置类转出字符串数组
			String[] candidates = StringUtils.toStringArray(configurations);
            
			boolean skipped = false;
			for (AutoConfigurationImportFilter filter : this.filters) {
                // 调用各种aware方法，将beanClaassLoader，beanFactory等注入filter对象中
                //这里的efilter即OnBeanCondition，OnClassCondition,OnWebApplicationCondition
                
                //判断各种filter来判断candidate(这里实质要通过candidate(自动配置类)拿到其标注的@ConditionOnClaas,@ConditionOnBean和@ConditionOnWebApplication里面的注解值)是否匹配
                //candidates数组与match数组一一对应
				boolean[] match = filter.match(candidates, this.autoConfigurationMetadata);
				for (int i = 0; i < match.length; i++) {
					if (!match[i]) {
						candidates[i] = null;
						skipped = true;
					}
				}
			}
            //判断是否包含需要跳过的自动配置类，没有时则直接返回
			if (!skipped) {
				return configurations;
			}
			List<String> result = new ArrayList<>(candidates.length);
			for (String candidate : candidates) {
				if (candidate != null) {
					result.add(candidate);
				}
			}
			if (logger.isTraceEnabled()) {
				int numberFiltered = configurations.size() - result.size();
				logger.trace("Filtered " + numberFiltered + " auto configuration class in "
						+ TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime) + " ms");
			}
			return result;
		}
	}
    
}
Spring条件注解
类型 说明
ConditionalOnBean 仅仅在当前上下文中存在某个对象时，才会实例化一个Bean
ConditionalOnClass 某个class位于类路径上，才会实例化一个Bean
ConditionalOnExpression 当表达式为true的时候，才会实例化一个Bean。
ConditionalOnMissingBean 仅仅在当前上下文中不存在某个对象时，才会实例化一个Bean。
ConditionalOnMissingClass 某个class类路径上不存在的时候，才会实例化一个Bean。
ConditionalOnNotWebApplication 不是web应用，才会实例化一个Bean。
ConditionalOnBean 当容器中有指定Bean的条件下进行实例化。
ConditionalOnMissingBean 当容器里没有指定Bean的条件下进行实例化。
ConditionalOnClass 当classpath类路径下有指定类的条件下进行实例化。
ConditionalOnMissingClass 当类路径下没有指定类的条件下进行实例化。
ConditionalOnWebApplication 当项目是一个Web项目时进行实例化。
ConditionalOnNotWebApplication 当项目不是一个Web项目时进行实例化。
ConditionalOnProperty 当指定的属性有指定的值时进行实例化。
ConditionalOnExpression 基于SpEL表达式的条件判断。
ConditionalOnJava 当JVM版本为指定的版本范围时触发实例化。
ConditionalOnResource 当类路径下有指定的资源时触发实例化。
ConditionalOnJndi 在JNDI存在的条件下触发实例化。
ConditionalOnSingleCandidate 当指定的Bean在容器中只有一个，或者有多个但是指定了首选的Bean时触发实例化。

@ComponentScan

ComponentScan的使用

主要是从定义的路径扫描中，找出标识了需要装配的类自动装配到spring的bean容器中。

常用属性如下

  • basePackages、value：指定扫描路径，如果为空则以@ComponentScan注解的类所在的包为基本扫描路径
  • basePackageClasses：指定具体扫描的类
  • includeFilters：指定满足Filter条件的类
  • excludeFilters：指定排除Filter条件的类

includeFilters和excludeFilters的FilterType可选：ANNOTATION=注解类型(默认)、ASIGNABLE_TYPE(指定固定类)、ASSPECTTJ(ASPECTJ类型)、REGEX(正则表表达式)、CUSTOM(自定义类型)，自定义的Filter需要实现TypeFilter接口

@ComponentScan的配置如下

1
2
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })

借助excludeFilters将TypeExcludeFilter及FilteType这两个二类进行排除

当前@ComponentScan注解没有标注basePackages及value，所以扫描路径默认为@ComponentScan注解的类所在包作为基本的扫描路径(也就是标注了@SpringBootApplication注解的项目启动类所在的路径)

抛出疑问：@EnableAutoConfiguration注解通过@Import注解进行自动配置固定的bean

​ @Componen注解自动进行注解扫描

1
那么真正根据包扫描，把组件类生成实例对象存在IOC容器中，又是如何完成的？

源码分析-Run方法执行流程

SpringBootApplication初始化过程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
public class SpringApplication {
    
    //静态方法入(核心启动类，启动参数)
    public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
        //调用重载方法
		return run(new Class<?>[] { primarySource }, args);
	}
    
    public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        // 两件事，1.初始化SpringApplication 2.调用run方法
		return new SpringApplication(primarySources).run(args);
	}
    
    public SpringApplication(Class<?>... primarySources) {
		this(null, primarySources);
	}
    //构造函数
    public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		//设置资源加载器为null
        this.resourceLoader = resourceLoader;
        //断言加载资源类即核心启动类不能为空
		Assert.notNull(primarySources, "PrimarySources must not be null");
        // 将primarySources数组转换为Lit,最后放到LinkedHashSet中
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        //【1.1 推断应用类型，后面会根据类型初始化对应的环境，常用的一般都是servlet环境】
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
        //【1.2 初始化classpath下META-INF/spring.factories中已配置的BootstrapRegistryInitializer】 ？？具体作用待分析？？
		this.bootstrapRegistryInitializers = new ArrayList<>(
				getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
		//【1.3 初始化classpath下META-INF/spring.factories中已配置的ApplicationContextInitializer】
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        //【1.4 初始化classpath下所有已配置的ApplicationListener】
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        //【1.5 根据调用栈，推断出main方法的类名】
		this.mainApplicationClass = deduceMainApplicationClass();
	}
    
    // 1.2，1.3获取spring.factories中对应配置
    private <T> List<T> getSpringFactoriesInstances(Class<T> type) {
            return getSpringFactoriesInstances(type, null);
    }
    private <T> List<T> getSpringFactoriesInstances(Class<T> type, ArgumentResolver argumentResolver) {
        //1.SpringFactoriesLoader.forResourceLocation调用静态方法获取META-INF/spring.factories加载器对象
        //2.调用load方法加载对应type的值
		return SpringFactoriesLoader.forDefaultResourceLocation(getClassLoader()).load(type, argumentResolver);
	}
    //1.5 根据调用栈，推断出main方法的类名，即启动类信息
    private Class<?> deduceMainApplicationClass() {
		return StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE).walk(this::findMainClass)
				.orElse(null);
	}
}

// 1.1 类型判断
public enum WebApplicationType {
    static WebApplicationType deduceFromClasspath() {
        //classpath下存在org.springframework.web.reactive.DispatcherHandler并且不存在org.springframework.web.servlet.DispatcherServlet与org.glassfish.jersey.servlet.ServletContainer
		if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
				&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
			return WebApplicationType.REACTIVE;
		}
		for (String className : SERVLET_INDICATOR_CLASSES) {
            //classspath下不存在jakarta.servlet.Servlet或
			//org.springframework.web.context.ConfigurableWebApplicationContext之就返回
			if (!ClassUtils.isPresent(className, null)) {
                //不是web应用，也不会启动内嵌tomcat
				return WebApplicationType.NONE;
			}
		}
        //基于servlet的web服务器是，并且启动内嵌tomcat
		return WebApplicationType.SERVLET;
	}
}

getSpringFactoriesInstances(ApplicationContextInitializer.class)

image.png

getSpringFactoriesInstances(ApplicationListener.class)

image.png

run方执行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
public class SpringApplication {
    // run方法执行主体过程
    public ConfigurableApplicationContext run(String... args) {
        //开始时间，用于记录程序启动时间
		long startTime = System.nanoTime();
        // ？？
		DefaultBootstrapContext bootstrapContext = createBootstrapContext();
        // ConfigurableApplicationContext 是ApplicationContext接口的子接口，但在ApplicationContext基础上增加的配置上下文工具。ConfigurableApplicationContext是容器的高级接口
        //ConfigurableApplicationContext Spring的上下文
		ConfigurableApplicationContext context = null;
		configureHeadlessProperty();
        // 【1、获取并启动监听器】
		SpringApplicationRunListeners listeners = getRunListeners(args);
		listeners.starting(bootstrapContext, this.mainApplicationClass);
		try {
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            //【2、构建应用上下文环境】
			ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
            //banner打印
			Banner printedBanner = printBanner(environment);
            //【3、初始化应用上下文】
			context = createApplicationContext();
			context.setApplicationStartup(this.applicationStartup);
            // 【4、刷新应用上下文前的准备阶段】
			prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
            // 【5、刷新应用上下文】
			refreshContext(context);
            // 【6、刷新应用上下文后的扩展接口】
			afterRefresh(context, applicationArguments);
            // 时间记录
			Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
			}
			listeners.started(context, timeTakenToStartup);
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			if (ex instanceof AbandonedRunException) {
				throw ex;
			}
			handleRunFailure(context, ex, listeners);
			throw new IllegalStateException(ex);
		}
		try {
			if (context.isRunning()) {
				Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
				listeners.ready(context, timeTakenToReady);
			}
		}
		catch (Throwable ex) {
			if (ex instanceof AbandonedRunException) {
				throw ex;
			}
			handleRunFailure(context, ex, null);
			throw new IllegalStateException(ex);
		}
		return context;
	}
}
获取启动监听器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class SpringApplication {
    //获取监听器
    private SpringApplicationRunListeners getRunListeners(String[] args) {
        // ??
		ArgumentResolver argumentResolver = ArgumentResolver.of(SpringApplication.class, this);
		argumentResolver = argumentResolver.and(String[].class, args);
        // 从spring.factories获取SpringApplicationRunListener对应的数据--即EventPublishingRunListener
        // SpringApplicationRunListener负责在SpringBoot启动的不同阶段广播出不同的消息，传递给ApplicationListener
		List<SpringApplicationRunListener> listeners = getSpringFactoriesInstances(SpringApplicationRunListener.class,
				argumentResolver);
        // 钩子监听器 具体看下是什么作用？
		SpringApplicationHook hook = applicationHook.get();
		SpringApplicationRunListener hookListener = (hook != null) ? hook.getRunListener(this) : null;
		if (hookListener != null) {
			listeners = new ArrayList<>(listeners);
			listeners.add(hookListener);
		}
		return new SpringApplicationRunListeners(logger, listeners, this.applicationStartup);
	}
    private <T> List<T> getSpringFactoriesInstances(Class<T> type, ArgumentResolver argumentResolver) {
		return SpringFactoriesLoader.forDefaultResourceLocation(getClassLoader()).load(type, argumentResolver);
	}
}
构建应用上下文环境
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public class SpringApplication {
    //应用上下文环境信息准备，包含系统环境变量信息，jdk环境信息，以及自定义编写的属性信息(application)
    private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
			DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
		// Create and configure the environment
        //创建并配置相应的环境
		ConfigurableEnvironment environment = getOrCreateEnvironment();
        //根据用户配置、配置enviroment系统信息，以及命令行配置信息
		configureEnvironment(environment, applicationArguments.getSourceArgs());
        //将命令行参数类型SimpleCommandLinePropertySource--》ConfigurationPropertySourcesPropertySource，并添加到propertySources中
		ConfigurationPropertySources.attach(environment);
        // 启动相应的监听器
		listeners.environmentPrepared(bootstrapContext, environment);
		DefaultPropertiesPropertySource.moveToEnd(environment);
		Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
				"Environment prefix cannot be set via properties.");
		bindToSpringApplication(environment);
		if (!this.isCustomEnvironment) {
			EnvironmentConverter environmentConverter = new EnvironmentConverter(getClassLoader());
			environment = environmentConverter.convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
		}
		ConfigurationPropertySources.attach(environment);
		return environment;
	}
    
    // 创建并配置相应的环境
    private ConfigurableEnvironment getOrCreateEnvironment() {
		if (this.environment != null) {
			return this.environment;
		}
        // ApplicationServletEnvironment
		ConfigurableEnvironment environment = this.applicationContextFactory.createEnvironment(this.webApplicationType);
		if (environment == null && this.applicationContextFactory != ApplicationContextFactory.DEFAULT) {
			environment = ApplicationContextFactory.DEFAULT.createEnvironment(this.webApplicationType);
		}
		return (environment != null) ? environment : new ApplicationEnvironment();
	}
    // 配置环境信息
    protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
		if (this.addConversionService) {
			environment.setConversionService(new ApplicationConversionService());
		}
        // 将main函数的args封装成SimpleCommandLienProperttySource 加入环境中
		configurePropertySources(environment, args);
        // 空实现
		configureProfiles(environment, args);
	}
    
}

listeners.environmentPrepared()用于发布环境准备完成通知，然后由获取到的ApplicationListener执行相应逻辑

其中有一个EnvironmentPostProcessorApplicationListener用于配置文件的加载。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class EnvironmentPostProcessorApplicationListener implements SmartApplicationListener, Ordered {
    // 在环境准备完成执行
    private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
		ConfigurableEnvironment environment = event.getEnvironment();
		SpringApplication application = event.getSpringApplication();
		for (EnvironmentPostProcessor postProcessor : getEnvironmentPostProcessors(application.getResourceLoader(),
				event.getBootstrapContext())) {
			postProcessor.postProcessEnvironment(environment, application);
		}
	}
    
    //获取所有环境后置处理器
    List<EnvironmentPostProcessor> getEnvironmentPostProcessors(ResourceLoader resourceLoader,
			ConfigurableBootstrapContext bootstrapContext) {
		ClassLoader classLoader = (resourceLoader != null) ? resourceLoader.getClassLoader() : null;
		EnvironmentPostProcessorsFactory postProcessorsFactory = this.postProcessorsFactory.apply(classLoader);
		return postProcessorsFactory.getEnvironmentPostProcessors(this.deferredLogs, bootstrapContext);
	}
}

获取到的后置处理器有

image.png

其中ConfigDataEnvironmentPostProcessor用于配置文件的激活处理

1
2
3
4
5
6
public class ConfigDataEnvironmentPostProcessor implements EnvironmentPostProcessor, Ordered {
	@Override
	public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
		postProcessEnvironment(environment, application.getResourceLoader(), application.getAdditionalProfiles());
	}
}s

— 旧版本使用ConfigFileApplicationListener加载配置文件

监听器ConfigFileApplicationListener，加载项目配置文件的监听器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class SpringApplicationRunListeners {
    // 当environment构建完成皇，ApplicationContext创建之前，该方法被调用
    void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
		doWithListeners("spring.boot.application.environment-prepared",
				(listener) -> listener.environmentPrepared(bootstrapContext, environment));
	}
    private void doWithListeners(String stepName, Consumer<SpringApplicationRunListener> listenerAction) {
		doWithListeners(stepName, listenerAction, null);
	}
    private void doWithListeners(String stepName, Consumer<SpringApplicationRunListener> listenerAction,
			Consumer<StartupStep> stepAction) {
		StartupStep step = this.applicationStartup.start(stepName);
		this.listeners.forEach(listenerAction);
		if (stepAction != null) {
			stepAction.accept(step);
		}
		step.end();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {
    public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext,
			ConfigurableEnvironment environment) {
		multicastInitialEvent(
				new ApplicationEnvironmentPreparedEvent(bootstrapContext, this.application, this.args, environment));
	}
    private void multicastInitialEvent(ApplicationEvent event) {
		refreshApplicationListeners();
        //配置文件加载
		this.initialMulticaster.multicastEvent(event);
	}
}
初始化应用上下文
1
2
3
4
5
6
7
8

public class SpringApplication {
    // 创建完成后，同时创建了IOC容器，即context.beanFactory(DefaultListableBeanFactory)
    protected ConfigurableApplicationContext createApplicationContext() {
        // ApplicationContextFactory applicationContextFactory = ApplicationContextFactory.DEFAULT;
		return this.applicationContextFactory.create(this.webApplicationType);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
//  ApplicationContextFactory
class DefaultApplicationContextFactory implements ApplicationContextFactory {

	@Override
	public Class<? extends ConfigurableEnvironment> getEnvironmentType(WebApplicationType webApplicationType) {
		return getFromSpringFactories(webApplicationType, ApplicationContextFactory::getEnvironmentType, null);
	}

	@Override
	public ConfigurableEnvironment createEnvironment(WebApplicationType webApplicationType) {
		return getFromSpringFactories(webApplicationType, ApplicationContextFactory::createEnvironment, null);
	}

    //上下文创建
	@Override
	public ConfigurableApplicationContext create(WebApplicationType webApplicationType) {
		try {
			return getFromSpringFactories(webApplicationType, ApplicationContextFactory::create,
					this::createDefaultApplicationContext);
		}
		catch (Exception ex) {
			throw new IllegalStateException("Unable create a default ApplicationContext instance, "
					+ "you may need a custom ApplicationContextFactory", ex);
		}
	}

	private ConfigurableApplicationContext createDefaultApplicationContext() {
		if (!AotDetector.useGeneratedArtifacts()) {
			return new AnnotationConfigApplicationContext();
		}
		return new GenericApplicationContext();
	}

    // 开始创建
	private <T> T getFromSpringFactories(WebApplicationType webApplicationType,
			BiFunction<ApplicationContextFactory, WebApplicationType, T> action, Supplier<T> defaultResult) {
		for (ApplicationContextFactory candidate : SpringFactoriesLoader.loadFactories(ApplicationContextFactory.class,
				getClass().getClassLoader())) {
			T result = action.apply(candidate, webApplicationType);
			if (result != null) {
				return result;
			}
		}
		return (defaultResult != null) ? defaultResult.get() : null;
    }
}
刷新应用上下文的准备阶段
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
public class SpringApplication {
    //刷新应用上下文前的准备
    private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
			ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments, Banner printedBanner) {
        //设置容器环境
		context.setEnvironment(environment);
        //执行容器后置处理
		postProcessApplicationContext(context);
		addAotGeneratedInitializerIfNecessary(this.initializers);
        //在刷新上下文之前将任何应用程序上下文初始值设定项应用于上下文
		applyInitializers(context);
        //向各个监听器发送容器已经准备好的事件
		listeners.contextPrepared(context);
		bootstrapContext.close(context);
		if (this.logStartupInfo) {
			logStartupInfo(context.getParent() == null);
			logStartupProfileInfo(context);
		}
		// Add boot specific singleton beans
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        // 将main函数中的args参数封装成单例bean，注册进容器 
		beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
		if (printedBanner != null) {
			beanFactory.registerSingleton("springBootBanner", printedBanner);
		}
		if (beanFactory instanceof AbstractAutowireCapableBeanFactory autowireCapableBeanFactory) {
			autowireCapableBeanFactory.setAllowCircularReferences(this.allowCircularReferences);
			if (beanFactory instanceof DefaultListableBeanFactory listableBeanFactory) {
				listableBeanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
			}
		}
		if (this.lazyInitialization) {
			context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
		}
		context.addBeanFactoryPostProcessor(new PropertySourceOrderingBeanFactoryPostProcessor(context));
        // 确定是否必须在运行时考虑 AOT 优化
		if (!AotDetector.useGeneratedArtifacts()) {
			// 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) {
				genericApplicationContext.setResourceLoader(this.resourceLoader);
			}
			if (context instanceof DefaultResourceLoader defaultResourceLoader) {
				defaultResourceLoader.setClassLoader(this.resourceLoader.getClassLoader());
			}
		}
		if (this.addConversionService) {
			context.getBeanFactory().setConversionService(context.getEnvironment().getConversionService());
		}
	}
    //在刷新上下文之前将任何应用程序上下文初始值设定项应用于上下文
    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);
		}
	}
    
    // 将 Bean 加载到应用程序上下文中，即将启动类注册到IOC中
    protected void load(ApplicationContext context, Object[] sources) {
		if (logger.isDebugEnabled()) {
			logger.debug("Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
		}
        //创建 BeanDefinitionLoader
		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();
	}
    
    // 获取 Bean 定义注册表
    // spring容器在启动的时候，会将类解析成spring内部的beanDefinition结构，并将beanDefinition存储到DefaultListableBeanFactory的map中
    private BeanDefinitionRegistry getBeanDefinitionRegistry(ApplicationContext context) {
		if (context instanceof BeanDefinitionRegistry registry) {
			return registry;
		}
		if (context instanceof AbstractApplicationContext abstractApplicationContext) {
			return (BeanDefinitionRegistry) abstractApplicationContext.getBeanFactory();
		}
		throw new IllegalStateException("Could not locate BeanDefinitionRegistry");
	}
    
    //用于创建 BeanDefinitionLoader 的工厂方法
    protected BeanDefinitionLoader createBeanDefinitionLoader(BeanDefinitionRegistry registry, Object[] sources) {
		return new BeanDefinitionLoader(registry, sources);
	}
    
}
// 从底层源代码（包括 XML 和 JavaConfig）加载 Bean 定义。充当 AnnotatedBeanDefinitionReader、XmlBeanDefinitionReader 和 ClassPathBeanDefinitionScanner 上的简单外观
class BeanDefinitionLoader {

	BeanDefinitionLoader(BeanDefinitionRegistry registry, Object... sources) {
		Assert.notNull(registry, "Registry must not be null");
		Assert.notEmpty(sources, "Sources must not be empty");
		this.sources = sources;
        //注解形式bean定义读取器，比如@Configuration @Bean @Companent @Controller @Service等
		this.annotatedReader = new AnnotatedBeanDefinitionReader(registry);
        // xml形式的bean定义读取器
		this.xmlReader = new XmlBeanDefinitionReader(registry);
		this.groovyReader = (isGroovyPresent() ? new GroovyBeanDefinitionReader(registry) : null);
        // 类路径扫描器
		this.scanner = new ClassPathBeanDefinitionScanner(registry);
        // 扫描器添加排除过滤器
		this.scanner.addExcludeFilter(new ClassExcludeFilter(sources));
	}
    
    void load() {
		for (Object source : this.sources) {
			load(source);
		}
	}
    
    private void load(Object source) {
		Assert.notNull(source, "Source must not be null");
        // 从class加载
		if (source instanceof Class<?> clazz) {
			load(clazz);
			return;
		}
        //从resource加载
		if (source instanceof Resource resource) {
			load(resource);
			return;
		}
        // 从package加载
		if (source instanceof Package pack) {
			load(pack);
			return;
		}
        //从ChareSequence加载
		if (source instanceof CharSequence sequence) {
			load(sequence);
			return;
		}
		throw new IllegalArgumentException("Invalid source type " + source.getClass());
	}
    
    private void load(Class<?> source) {
		if (isGroovyPresent() && GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
			// Any GroovyLoaders added in beans{} DSL can contribute beans here
			GroovyBeanDefinitionSource loader = BeanUtils.instantiateClass(source, GroovyBeanDefinitionSource.class);
			((GroovyBeanDefinitionReader) this.groovyReader).beans(loader.getBeans());
		}
        // 检查是否符合注册条件
		if (isEligible(source)) {
            // 将启动类BeanDefinition注册进beanDefinitionMap
			this.annotatedReader.register(source);
		}
	}
}
刷新应用上下文
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext {
    @Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

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

				StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
				//调用在上下文中注册为 Bean 的工厂处理器. **重点**
				invokeBeanFactoryPostProcessors(beanFactory);

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

				// 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();
				contextRefresh.end();
			}
		}
	}
    
    
}
invokeBeanFactoryPostProcessors(beanFactory) （重点）

Ioc容器的初始化过程包含三个步骤，在invokeBeanFactoryPostProcessors()方法中完成了Ioc容器初始化过程的三个步骤

  1. Reosurce定位

    ​ 在SpringBoot中，我们都知道他的包扫描是从主类所在的包开始扫描的，preareContext()方法中，回先将主类解析成BeanDefinition，然后在refressh()方法的invokeBeanFactoryPostProcessors()方法中解析主类的BeanDefinition获取basePackage的路径。这样就完成了定位的过程。其次SpringBoot的各种starter是通过SPI扩展机制实现的自动装配，SpringBoot的自动装配同样也是在invokeBeanFactoryPostProcessors()方法中实现的。还有一种情况，在SpringBoot中有很多@EnableXXX的注解，细心点进去看的应该就知道其底层就是@Import注解，在啊invokeBeanFactoryPostProcessors()方法中实现了对该注解指定的配置类的定位加载。

    ​ 常规的在SpringBoot中有三种定位，第一种是主类所在的包，第二种是SPI机制扩展实现的自动装配(比如各种starter)，第三种就是@Import注解指定的类(对于非常规的)

  2. BeanDefinition载入

    在第一步中说了的暗中Resource的定位情况，定位后紧接着就是BeanDefinition的分别载入。所谓的载入就是通过上面啊的定位得到的basePackage，SpringBoot会将该路径拼接成：classpath:net/oiyou/**/.class这样的形式，然后一个叫做xPathMatchingResourcePatternResolver的类会将该路径下的所有的.class文件啊都加载进来，然后遍历是不是有@Companent注解，如果有就是我们吖装载的BeanDefinitio。大致过程就是这样的了。

    1
    2
    TIPS:
    	@Configuration @Controller @Service等注解底层都是@Companent注解，只不过包装了一层罢了

  3. 注册BeanDefinition

    这个过程通过调用上下文的BeanDefinitionRegister接口的实现来完成。这个注册过程把载入过程中解析得到的BeanDefinition向Ioc容器中进行注册。通过上下文的分析，我们可以看到，在Ioc容器中将BeanDefinition注入到ConcurrentHashMap中，Ioc容器就是十四通过这个HashMap来持有这些BeanDefinition数据的。比如DefaultListableBeanFactory中的beanDefinitionMap属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext {
    protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        // 继续
		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 (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}
    
}

调用PostProcessorRegistrationDelegate的invokeBeanFactoryPostProcessors方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
final class PostProcessorRegistrationDelegate {

	private PostProcessorRegistrationDelegate() {
	}


	public static void invokeBeanFactoryPostProcessors(
			ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

		// WARNING: Although it may appear that the body of this method can be easily
		// refactored to avoid the use of multiple loops and multiple lists, the use
		// of multiple lists and multiple passes over the names of processors is
		// intentional. We must ensure that we honor the contracts for PriorityOrdered
		// and Ordered processors. Specifically, we must NOT cause processors to be
		// instantiated (via getBean() invocations) or registered in the ApplicationContext
		// in the wrong order.
		//
		// Before submitting a pull request (PR) to change this method, please review the
		// list of all declined PRs involving changes to PostProcessorRegistrationDelegate
		// to ensure that your proposal does not result in a breaking change:
		// https://github.com/spring-projects/spring-framework/issues?q=PostProcessorRegistrationDelegate+is%3Aclosed+label%3A%22status%3A+declined%22

		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
		Set<String> processedBeans = new HashSet<>();

		if (beanFactory instanceof BeanDefinitionRegistry registry) {
			List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
			List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor registryProcessor) {
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
					registryProcessors.add(registryProcessor);
				}
				else {
					regularPostProcessors.add(postProcessor);
				}
			}

			// Do not initialize FactoryBeans here: We need to leave all regular beans
			// uninitialized to let the bean factory post-processors apply to them!
			// Separate between BeanDefinitionRegistryPostProcessors that implement
			// PriorityOrdered, Ordered, and the rest.
			List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

			// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
            // ConfigurationClassPostProcessor
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
			currentRegistryProcessors.clear();

			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
			currentRegistryProcessors.clear();

			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					if (!processedBeans.contains(ppName)) {
						currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
						processedBeans.add(ppName);
						reiterate = true;
					}
				}
				sortPostProcessors(currentRegistryProcessors, beanFactory);
				registryProcessors.addAll(currentRegistryProcessors);
				invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
				currentRegistryProcessors.clear();
			}

			// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
			invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

		else {
			// Invoke factory processors registered with the context instance.
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}

		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let the bean factory post-processors apply to them!
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
		List<String> orderedPostProcessorNames = new ArrayList<>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<>();
		for (String ppName : postProcessorNames) {
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
			}
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
		sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(orderedPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// Finally, invoke all other BeanFactoryPostProcessors.
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		// Clear cached merged bean definitions since the post-processors might have
		// modified the original metadata, e.g. replacing placeholders in values...
		beanFactory.clearMetadataCache();
	}
    
    // 调用给定的 BeanDefinitionRegistryPostProcessor bean
    private static void invokeBeanDefinitionRegistryPostProcessors(
			Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry, ApplicationStartup applicationStartup) {

		for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
			StartupStep postProcessBeanDefRegistry = applicationStartup.start("spring.context.beandef-registry.post-process")
					.tag("postProcessor", postProcessor::toString);
            // ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry
			postProcessor.postProcessBeanDefinitionRegistry(registry);
			postProcessBeanDefRegistry.end();
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,
		BeanRegistrationAotProcessor, BeanFactoryInitializationAotProcessor, PriorityOrdered,
		ResourceLoaderAware, ApplicationStartupAware, BeanClassLoaderAware, EnvironmentAware {
            
    @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);

		processConfigBeanDefinitions(registry);
	}   
    // 基于配置类的注册表生成并验证配置模型
    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);
				}
			}
            //检查给定的 Bean 定义是否是配置类（或在配置组件类中声明的嵌套组件类）的候选者，也要自动注册），并相应地对其进行标记
			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   分析每个@Configuration类
		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 {
			StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");
			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);
			processConfig.tag("classCount", () -> String.valueOf(configClasses.size())).end();

			candidates.clear();
			if (registry.getBeanDefinitionCount() > candidateNames.length) {
				String[] newCandidateNames = registry.getBeanDefinitionNames();
				Set<String> oldCandidateNames = Set.of(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());
		}

		// Store the PropertySourceDescriptors to contribute them Ahead-of-time if necessary
		this.propertySourceDescriptors = parser.getPropertySourceDescriptors();

		if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory 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.clearCache();
		}
	}
        
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
public ConfigurationClassParser(MetadataReaderFactory metadataReaderFactory,
		ProblemReporter problemReporter, Environment environment, ResourceLoader resourceLoader,
		BeanNameGenerator componentScanBeanNameGenerator, BeanDefinitionRegistry registry) {
       
       
       public void parse(Set<BeanDefinitionHolder> configCandidates) {
           // configCandidates即启动类的beanDefinitionHolder
           for (BeanDefinitionHolder holder : configCandidates) {
               BeanDefinition bd = holder.getBeanDefinition();
               try {
                   if (bd instanceof AnnotatedBeanDefinition) {
                       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);
               }
           }
           
           // 获取到所有@Import注解后执行处理
           this.deferredImportSelectorHandler.process();
       }
       protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
           processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
       }
       
       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 {
               sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
           }
           while (sourceClass != null);

           this.configurationClasses.put(configClass, configClass);
       }
       
       @Nullable
       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.propertySourceRegistry != null) {
                   this.propertySourceRegistry.processPropertySource(propertySource);
               }
               else {
                   logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
                           "]. Reason: Environment must implement ConfigurableEnvironment");
               }
           }

           // Process any @ComponentScan annotations   处理任何@ComponentScan注释
           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 处理@Import注解
           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;
       }
       
       
       protected final void parse(@Nullable String className, String beanName) throws IOException {
           Assert.notNull(className, "No bean class name for configuration class bean definition");
           MetadataReader reader = this.metadataReaderFactory.getMetadataReader(className);
           processConfigurationClass(new ConfigurationClass(reader, beanName), DEFAULT_EXCLUSION_FILTER);
       }
       
       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 {
               sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
           }
           while (sourceClass != null);

           this.configurationClasses.put(configClass, configClass);
       }
       
       
       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.propertySourceRegistry != null) {
                   this.propertySourceRegistry.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 配置类用 @ComponentScan -> 立即执行扫描进行注释
                   // componentScanParser.parse解析@Companent注解参数，同时获取basePackages，若未配置，则默认使用启动类所在包路径
                   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
           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;
       }
       //返回类@Import，考虑所有元注释
       private Set<SourceClass> getImports(SourceClass sourceClass) throws IOException {
           Set<SourceClass> imports = new LinkedHashSet<>();
           Set<SourceClass> visited = new LinkedHashSet<>();
           collectImports(sourceClass, imports, visited);
           return imports;
       }
       
       private class DeferredImportSelectorHandler {

           @Nullable
           private List<DeferredImportSelectorHolder> deferredImportSelectors = new ArrayList<>();

           /**
            * Handle the specified {@link DeferredImportSelector}. If deferred import
            * selectors are being collected, this registers this instance to the list. If
            * they are being processed, the {@link DeferredImportSelector} is also processed
            * immediately according to its {@link DeferredImportSelector.Group}.
            * @param configClass the source configuration class
            * @param importSelector the selector to handle
            */
           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 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<>();
               }
           }
       }
       
       
       private class DeferredImportSelectorGroupingHandler {

           private final Map<Object, DeferredImportSelectorGrouping> groupings = new LinkedHashMap<>();

           private final Map<AnnotationMetadata, ConfigurationClass> configurationClasses = new HashMap<>();

           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 void processGroupImports() {
               for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
                   Predicate<String> exclusionFilter = grouping.getCandidateFilter();
                   // 此处grouping.getImports()就与最开始的@Import讲解处进行对应
                   grouping.getImports().forEach(entry -> {
                       ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata());
                       try {
                           processImports(configurationClass, asSourceClass(configurationClass, exclusionFilter),
                                   Collections.singleton(asSourceClass(entry.getImportClassName(), exclusionFilter)),
                                   exclusionFilter, false);
                       }
                       catch (BeanDefinitionStoreException ex) {
                           throw ex;
                       }
                       catch (Throwable ex) {
                           throw new BeanDefinitionStoreException(
                                   "Failed to process import candidates for configuration class [" +
                                           configurationClass.getMetadata().getClassName() + "]", ex);
                       }
                   });
               }
           }

           private Group createGroup(@Nullable Class<? extends Group> type) {
               Class<? extends Group> effectiveType = (type != null ? type : DefaultDeferredImportSelectorGroup.class);
               return ParserStrategyUtils.instantiateClass(effectiveType, Group.class,
                       ConfigurationClassParser.this.environment,
                       ConfigurationClassParser.this.resourceLoader,
                       ConfigurationClassParser.this.registry);
           }
       }
       
       
   }
刷新应用上下文的扩展接口
1
2
3
protected void afterRefresh(ConfigurableApplicationContext context, ApplicationArguments args) {
    //空实现
}

后续计划

  1. BootstrapRegistryInitializer，ApplicationContextInitializer，ApplicationListener什么作用
  2. DefaultBootstrapContext作用？
  3. SpringApplicationRunListener作用
  4. SpringApplicationHook作用