invokeBeanFactoryPostProcessors
这个方法会实例化和调用所有BeanFactoryPostProcessor，包括其子类BeanDefinitionRegistryPostProcessor。
BeanFactoryPostProcessor接口是Spring初始化BeanFactory时对外暴露的扩展点，Spring IOC容器允许BeanFactoryPostProcessor在容器实例化bean之前读取并修改bean定义。
注意：BeanDefinitionRegistryPostProcessor继承BeanFactoryPostProcessor，比BeanFactoryPostProcessor具有更高的优先级。
正文
我们回到AbstractApplicationContext的refresh()方法，找到invokeBeanFactoryPostProcessors(beanFactory);然后点开跳转到：AbstractApplicationContext类的invokeBeanFactoryPostProcessors()方法：
在上面这个方法里进行了两步操作：
1、获取当前上下文中beanFactoryPostProcessors 的值getBeanFactoryPostProcessors()
2、实例化所有已注册的 BeanFactoryPostProcessor
第一步：
this.beanFactoryPostProcessors指的就是下面这个list
getBeanFactoryPostProcessors()会获得当前环境中已经注册的BeanFactoryPostProcessor，一般情况下，this.beanFactoryPostProcessors是空集合。为什么说是一般情况下？因为这里获取的是我们手动注册。BeanFactoryPostProcessors有三种情况：
1、我们手动注册
2、Spring扫描出来的
3、Spring自定义的
什么是手动注册的？
就是我们手动调用AnnotationConfigApplicationContext.addBeanFactoryPostProcessor();这个方法添加的。
什么是Spring扫描出来的？
我们自己实现了BeanFactoryPostProcessor接口的类可以加@Companent，也可以不加，如果加了那么就属于是Spring扫描出来的。
什么是Spring自定义的？
在Spring内容也有其实现类BeanFactoryPostProcessor接口的类，它会自己去获取出来，我们不用管。
第二步：
实例化所有已注册的 BeanFactoryPostProcessor。执行：PostProcessorRegistrationDelegate类的invokeBeanFactoryPostProcessors()方法：
现在我们来说这个方法的执行流程：
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
Set<String> processedBeans = new HashSet<>();
//先执行(beanFactory)容器的 BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry()方法
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
//都是放程序员自己添加的 BeanFactoryPostProcessor BeanDefinitionRegistryPostProcessor
//regularPostProcessors 常规的后置处理器
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
//这个for用来区分 BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
//执行自己手动加进去的
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.
// 放的是 spring 内部自己实现了 BeanDefinitionRegistryPostProcessor 接口的类
//ConfigurationClassPostProcessor 就是spring自己的 目前来说只有一个：ConfigurationClassPostProcessor
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
//获取容器中 所有的 BeanDefinitionRegistryPostProcessor
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 第一优先级 先执行实现了 PriorityOrdered 优先级接口的 BeanDefinitionRegistryPostProcessor
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//把要执行的 BeanDefinitionRegistryPostProcessor 放在 currentRegistryProcessors 集合中
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
//把要执行的 postProcessorName 放在 processedBeans 集合中
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
//把自己手动调用方法添加的 BeanDefinitionRegistryPostProcessor 与 spring内部的合并
registryProcessors.addAll(currentRegistryProcessors);
//执行 spring 内部的 beanDefinitionRegistryPostProcessor
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
// 第二优先级 执行实现了 Ordered 顺序接口的 BeanDefinitionRegistryPostProcessor
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
//在之前的 执行过的postProcessorName中不包含当前的名称，且类型是 Ordered 的
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);
currentRegistryProcessors.clear();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
// 最后执行没有实现 PriorityOrdered 、 Ordered 接口的 BeanDefinitionRegistryPostProcessor
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);
currentRegistryProcessors.clear();
}
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
// 执行 实现了 postProcessBeanFactory.postProcessBeanFactory() 的方法
//只是将父子类分开执行了，先子类后父类
// 这里只执行 BeanFactoryPostProcessor 中的 postProcessBeanFactory 方法
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
//处理常规的后置处理器，BeanFactoryPostProcessor
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!
//这里执行实现了 BeanFactoryPostProcessor 接口的 postProcessBeanFactory() 方法
// 就是 BeanFactoryPostProcessor 在 BeanDefinitionRegistryPostProcessor 之后执行
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<>();
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<>();
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();
}这里第一步进行了一个判断：
图一
我在这里说一下，这里传过来的的beanFactory其实是：DefaultListableBeanFactory
我们看一下DefaultListableBeanFactory这个类的继承关系：
DefaultListableBeanFactory实现了BeanDefinitionRegistry这个接口，所以图一的那个判断是成立的。我们接着往下看：
现在我们知道第一个if判断是正确的，进入这个if语句里，
1、将当前beanFactory类型为BeanDefinitionRegistry类型。
2、定义两个List，其中：regularPostProcessors代表的是BeanFactoryPostProcessor类型的
registryProcessors代表的是BeanDefinitionRegistryPostProcessor类型的。为什么要定义两个List？
因为我们可以实现，BeanFactoryPostProcessor，也可以实BeanDefinitionRegistryPostProcessor
我们将实现了这两个类的后置处理器手动注册到了beanFactoryPostProcessors(以参数的形式传过来的)，由于这两个类的执行时期不同，所以我们需要将这两种类型的处理器分开处理。
在这个for循环里，如果是实现了BeanDefinitionRegistryPostProcessor的类，则将当前这个类放入到registryProcessors集合当中，否则就是实现了BeanFactoryPostProcessor的类，将它放入到regularPostProcessors集合当中。我们接着往下看：Spring又定义了一个List，这个List用于存放Spring自己添加的BeanDefinitionRegistryPostProcessor类，之后根据BeanDefinitionRegistryPostProcessor类型来获取所有实现了此类型的beanName。
其实这个postProcessorNames只有一个类，那就是我们的ConfigurationClassPostProcessor类
还记得我们这个类是什么时候放进去的吗？我们回顾一下：
在我们创建 AnnotatedBeanDefinitionReader时不是加了6个bean到beanFactory当中吗，其中有一个bean就是ConfigurationClassPostProcessor，而这个类实现了BeanDefinitionRegistryPostProcessor接口。
我们回到 invokeBeanFactoryPostProcessors这个方法。接下来就是合并，
把自己手动调用方法添加的 BeanDefinitionRegistryPostProcessor 与 spring内部的合并registryProcessors.addAll(currentRegistryProcessors);合并完成之后，执行Spring内部的beanDefinitionRegistryPostProcessor
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);点开这个方法：
遍历postProcessors，调用
postProcessBeanDefinitionRegistry()方法，我们接着看这个方法
接着点开：processConfigBeanDefinitions(registry); 这个方法非常非常重要，我们来看看这个方法里都做了哪些事情。我先贴一下这个方法的全部代码：
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
// app提供的bean
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
// 获取容器中 注册的 所有 容器的名字
String[] candidateNames = registry.getBeanDefinitionNames();
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
//配置类的类型标记判断
if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
//判断是否是一个配置 beanDefinition加了@configrution,@Component,@import 等等
//并且设置配置db的类型标记：
// 1.full @configrution
// 2.lite @Component,@ComponentScan,@import,@ImportResource
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(CONFIGURATION_BEAN_NAME_GENERATOR);
if (generator != null) {
this.componentScanBeanNameGenerator = generator;
this.importBeanNameGenerator = generator;
}
}
}
if (this.environment == null) {
this.environment = new StandardEnvironment();
}
// Parse each @Configuration class
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
//去重
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
//主要做扫描包，扫描出来的类放在parser中，在下面统一进行注册到容器
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());
}
//把扫描出来的 db 注册到容器中，
// 包括ImportSelector,ImportBeanDefinitionRegistrar
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();
}
}我们来一步一步第分析 processConfigBeanDefinitions：
1、先定义一个List configCandidates 用于存放交给Spring管理的bean。
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();2、获取容器中所有已注册的bean的名字
// 获取容器中 注册的 所有 容器的名字
String[] candidateNames = registry.getBeanDefinitionNames();3、遍历所有已经注册的bean
3.1、根据beanName获取Bean定义：beanDef
3.2、第一个if，判断当前bean是不是已经处理过(当前是第一次进，肯定没有处理过)，那么会进else if，这个if判断当前bean是不是一个加了
@Configuration，@Component，@ComponentScan，@Import，@ImportResource注解，如果加了这些注解那么(ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)这个判断会返回true，也就是进了这个判断将当前这个bean封装成BeanDefinitionHolder，放进最开始定义的：configCandidates当中。
以下这些方法，我就不说了。
我们接着往下看：创建一个解析器，用来解析配置信息
重点：
//去重
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
//主要做扫描包，扫描出来的类放在parser中，在下面统一进行注册到容器
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());
}
//把扫描出来的 db 注册到容器中，
// 包括ImportSelector,ImportBeanDefinitionRegistrar
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());定义两个set集合：
第一个Set：将符合条件的bean去重，Spring害怕你提供了多个相同的bean，所以这里进行了去除。
第二个Set：现在先不说。
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());我们接着往下看进入到do ... while循环：
先来做包扫描(configClasses 这个说的是配置类，加了@configuration注解的类也就是我们的Appconfig类)
点开这个方法：
1、循环解析配置类(可能存在多个)
2、获取我们的BeanDefinition ，判断是哪种bean，不同的bean解析方式不同，我们以AppConfig为例，此时的bean肯定是加了注解的bean ，所以一地个if语句符合，点击parse()方法：
接着看：
当前类为AppConfig类也就是我们的配置类。
第一、判断当前类是哦福需要跳过解析，我们肯定不需要
第二、判断是否被其他类加了@import
第三、do....while 循环处理配置类
将配置类转换为 SourceClass 这里理解成bean的另一种形式。
do...while循环处理配置类，我们点开doProcessConfigurationClass这个方法：
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// Recursively process any member (nested) classes first
//处理内部类
processMemberClasses(configClass, sourceClass);
}
// 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
//处理 @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
//处理 @ComponentScan 这里处理扫描包，扫描出来的加入到容器
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 注解
//判断一组类是不是imports(3种)
// getImports 内部是递归出 注解@Import 的value 并返回
processImports(configClass, sourceClass, getImports(sourceClass), 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;
}这个方法主要是做了两件事：
第一：获取@ComponentScan中的值，并循环扫描包下的类，将扫描出来的类转换为bean注册到beanFactory当中。
第二：处理@Import，@Import(ImportSelector)，实现了ImportBeanDefinitionRegistrar的类这个比较复杂，可以理解为将某些类注册到beanFactory当中
首先我们来看下面这段代码，是doProcessConfigurationClass()方法：
根据注释知道，就是获取所有交给Spring管理的类，将这些类进行解析转换成beanDefinition最后注册到beanFactory当中。接着往下看：
1、循环处理 @ComponentScan 注解 (扫描包)
我们来看这个this.componentScanParser.parse()方法：
//处理 @ComponentScan 注解 (扫描包)
public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
//这里的扫描器是spring内部用的，AnnotationConfigApplicationContext类中的扫描器是提供给外部使用的
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
//beanName生成器
Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
BeanUtils.instantiateClass(generatorClass));
ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
scanner.setScopedProxyMode(scopedProxyMode);
}
else {
Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
}
scanner.setResourcePattern(componentScan.getString("resourcePattern"));
for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
for (TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addIncludeFilter(typeFilter);
}
}
for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
for (TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addExcludeFilter(typeFilter);
}
}
boolean lazyInit = componentScan.getBoolean("lazyInit");
if (lazyInit) {
scanner.getBeanDefinitionDefaults().setLazyInit(true);
}
Set<String> basePackages = new LinkedHashSet<>();
String[] basePackagesArray = componentScan.getStringArray("basePackages");
for (String pkg : basePackagesArray) {
String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
Collections.addAll(basePackages, tokenized);
}
for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
basePackages.add(ClassUtils.getPackageName(clazz));
}
if (basePackages.isEmpty()) {
basePackages.add(ClassUtils.getPackageName(declaringClass));
}
scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
@Override
protected boolean matchClassName(String className) {
return declaringClass.equals(className);
}
});
//扫描
return scanner.doScan(StringUtils.toStringArray(basePackages));
}请看这段代码的第一局话：在这里首先创建了一个 扫描器：
//这里的扫描器是spring内部用的，AnnotationConfigApplicationContext类中的扫描器是提供给外部使用的
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);这个扫描器在实例化好像还在别的地方看到过，那就是AnnotationConfigApplicationContext的构造方法里：
这说明，我们外部调用的这个扫描器，不是Spring执行的扫描器，Spring要执行的扫描器是自己又创建了一个，所以我这里注释里说到，这个基本用不到。
我们接着往下看：
生成beanName生成器，解析作用域代理模式，过滤一些类，判断是否是懒加载等等....这些都不重要，最重要的是下面这段代码：
//扫描
return scanner.doScan(StringUtils.toStringArray(basePackages));我们点开这个doScan()方法,内容如下：
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
for (String basePackage : basePackages) {
//真正去扫描的，找组件,asm去扫描的
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
//eg: singleton prototype
candidate.setScope(scopeMetadata.getScopeName());
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
if (candidate instanceof AbstractBeanDefinition) {
//设置默认值，比如没有加@lazy，则设置lazy的默认值
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
//处理注解，比如加了@lazy，设置lazy的值
// @Primary @DependsOn @Role @Description
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
//加入到 map 中
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}这个方法完成的内容是：利用asm框架，将扫描包下的类，将其转换为BeanDefinition，而后遍历，扫描出来的beanDefinition，设置bean的作用域，是否是懒加载的，处理注解信息，最后将处理好的beanDefinition放入到beanFactory当中。下面这段代码就是将bean放入beanFactory当中，具体就不解释了，我在第一篇的时候已经解释过了，不清楚的可以参考我第一篇文章：https://mp.csdn.net/mp_blog/creation/editor/117809214
//加入到 map 中
registerBeanDefinition(definitionHolder, this.registry);到这里就已经完成：扫描包，将扫描出来的类放入bean工厂。
现在我们回到：ConfigurationClassParser类的doProcessConfigurationClass()方法：
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
// 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
//处理 @ComponentScan 这里处理扫描包，扫描出来的加入到容器
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 注解
//判断一组类是不是imports(3种)
// getImports 内部是递归出 注解@Import 的value 并返回
processImports(configClass, sourceClass, getImports(sourceClass), 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没有说，这个比较复杂，有时间我会另外开一片博客进行说明，这里就简单理解为将一些特殊的bean直接放到beanFactory当中就可以了。
再往下就是处理添加了@Configuration注解的类，处理@Bean注解这个我也会跟3种@Import一起说明。
到现在为止执行完Spring自定义的BeanDefinitionRegistryPostProcessors，现在该执行
BeanFactoryPostProcessors，我再贴一遍代码，这里删减了一些不必要的代码：
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
...
//执行 spring 内部的 beanDefinitionRegistryPostProcessor
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
...
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
...
}invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);执行bean工厂的后置处理器，点开这个方法：
再点开postProcessBeanFactory();
enhanceConfigurationClasses(beanFactory);
注意这行代码，作用是增强配置类，产生cglib动态代理。
在这里我简单说一下Spring具体要做的功能。
这个类一般我们的配置类，比如说AppConfig，以下我以加了@Configuration的AppConfig进行解说。
spring会为appconfig产生一个cglib代理类，这个代理类会去实现一个BeanFactoryAware接口，并自动注入一个BeanFactory，于是当我们调用Appconfig里加了@Bean方法的时候，就会去判断这个类，会过滤这个类的这个方法，过滤方法会先判断这个对象是不是第一次得到，如果是第一次得到，它就会去调用new()方法，如果不是，它会从BeanFactory得到这个对象然后返回。
举个栗子：:如果说是创建对象，那么流程是，先通过beanFactory获取，如果获取不到说明没有创建，通过FactoryBean获取，就是通过beanFactory.getBean(beanName),如果获取不到说明被创建的对象不是一个FactoryBean，而是一个普通类，那么就通过beanFactory.createBean去创建。
为什么要使用cglib动态代理？为什么要产生代理对象？
1、因为我们配置类一定是一个类，不是一个接口，cglib是以类为基础进行代理增强，而JDK是以接口为基础进行代理增强。
2、为什么要产生代理对象，如果我们不产生代理对象，那么我们在配置类里对添加了@Bean的方法互相调用时产生的对象不是单例的，而Spring默认是单例对象，与Spring规则相违背，就是为了处理这个问题引出的cglib。
讲到这里其实invokeBeanFactoryPostProcessors()这个方法就讲完了，我这里总结一下：
1、执行BeanDefinitionRegistryPostProcessor（先执行我们自定义的，后执行Spring内置）
2、将我们交给Spring管理的类以包扫描的形式获取到，进而注册到beanFactory当中
3、处理3种Import
4、执行BeanFactoryPostProcessor，这里把配置类信息进行代理增强
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
