概述
在invokeBeanFactoryPostProcessors中，spring回对spring中默认的BeanFactory的后置处理器进行调用，而这里相关的最主要的类就是ConfigurationClassPostProcessor，ConfigurationClassPostProcessor这个类继承自BeanDefinitionRegistryPostProcessor，而BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor
在这里，对BeanFactoryPostProcessor的postProcessBeanFactory和BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry都会进行调用
processConfigBeanDefinitions
在 postProcessBeanDefinitionRegistry() 这个方法中，做的事情都在 processConfigBeanDefinitions() 这个方法中，所以直接来到processConfigBeanDefinitions()
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
String[] candidateNames = registry.getBeanDefinitionNames();
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// Return immediately if no @Configuration classes were found
// 没有找到配置类
if (configCandidates.isEmpty()) {
return;
}configCandidates :存放配置 bean 的集合
candidateNames ：获取容器中注册的BeanDefinitioin
获取到容器中注册的BeanDefinition后就会，进行循环，对于循环的m每一个BeanDefintion会判断其是不是一个进行配置的Bean
下面来看看，Spring是如何判断一个Bean是不是配置bean
public static boolean checkConfigurationClassCandidate(
BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {
String className = beanDef.getBeanClassName();
if (className == null || beanDef.getFactoryMethodName() != null) {
return false;
}
AnnotationMetadata metadata;
if (beanDef instanceof AnnotatedBeanDefinition &&
className.equals(((AnnotatedBeanDefinition) beanDef).getMetadata().getClassName())) {
metadata = ((AnnotatedBeanDefinition) beanDef).getMetadata();
}
//省略部分代码
Map<String, Object> config = metadata.getAnnotationAttributes(Configuration.class.getName());
if (config != null && !Boolean.FALSE.equals(config.get("proxyBeanMethods"))) {
beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
}
else if (config != null || isConfigurationCandidate(metadata)) {
beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
}
else {
return false;
}
Integer order = getOrder(metadata);
if (order != null) {
beanDef.setAttribute(ORDER_ATTRIBUTE, order);
}
return true;
}当遍历到我们自己写的配置类的时候，就会进入第一个if()，这里就拿到配置类的原数据信息，例如我们写的配置类叫做AppConfig,就会拿到AppConfig这个类的元数据信息
接着，通过元数据信息就可以判断当前这个类上面有没有加 @Configruation 这个注解，有的话就会设置CONFIGURATION_CLASS_ATTRIBUTE这个属性为CONFIGURATION_CLASS_FULL
没有的话，还有一个判断 isConfigurationCandidate(metadata)
private static final Set<String> candidateIndicators = new HashSet<>(8);
static {
candidateIndicators.add(Component.class.getName());
candidateIndicators.add(ComponentScan.class.getName());
candidateIndicators.add(Import.class.getName());
candidateIndicators.add(ImportResource.class.getName());
}
public static boolean isConfigurationCandidate(AnnotationMetadata metadata) {
if (metadata.isInterface()) {return false;}
for (String indicator : candidateIndicators) {
if (metadata.isAnnotated(indicator)) {
return true;
}
}
try {
return metadata.hasAnnotatedMethods(Bean.class.getName());
}
catch (Throwable ex) {
...
return false;
}
}首先是排除接口，然后判断如果类上面存在@Component，@ComponentScan，@Import，@ImportResource
或者，如果这个类里面 有方法加了@Bean，那么spring也会将这个类认为是一个配置类
就会将 CONFIGURATION_CLASS_ATTRIBUTE这个属性为CONFIGURATION_CLASS_LITE
在检查是不是一个配置类的最后还会进行BeanDefinition 中 ORDER_ATTRIBUTE属性的设置，这个属性就是解析配置Bean的顺序
这个值就是从元数据中获取@Order注解的value
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});完成上述后在 processConfigBeanDefinitions 这个方法里面就会根据 ORDER_ATTRIBUTE 进行排序
public static final String CONFIGURATION_BEAN_NAME_GENERATOR =
"org.springframework.context.annotation.internalConfigurationBeanNameGenerator";
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry) registry;
if (!this.localBeanNameGeneratorSet) {
// 程序员可以指定一个beanName生成器 applicationContext.setBeanNameGenerator()
BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
if (generator != null) {
this.componentScanBeanNameGenerator = generator;
//@Import的bean是无法指定beanName的 所以这里有一个Import的BeanName的生成器
this.importBeanNameGenerator = generator;
}
}
}这一步的操作是获取beanName的生成器，我们注册到spring 的bean常常没有指定beanName,所以spring需要自己取给Bean生成一个BeanName
这里spring就会去找org.springframework.context.annotation.internalConfigurationBeanNameGenerator这个类，然后赋值给componentScanBeanNameGenerator 和 importBeanNameGenerator
接下来就是最关键的部分了
do {
// 对配置类进行解析
parser.parse(candidates);
parser.validate();
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);
candidates.clear();
if (registry.getBeanDefinitionCount() > candidateNames.length) {
String[] newCandidateNames = registry.getBeanDefinitionNames();
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
Set<String> alreadyParsedClasses = new HashSet<>();
for (ConfigurationClass configurationClass : alreadyParsed) {
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
for (String candidateName : newCandidateNames) {
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty());这部分的代码用了do-while的循环，因为spring在解析配置类的时候，很可能这个配置类又导入了另外一个配置类，所以需要进行迭代的解析
首先是parser.parse(candidates)，对之前check出来的配置类进行解析，然后从解析出来的类里面再获取到配置类，并把这些类封装为ConfigurationClass对象放入set集合。而ConfigurationClass这个对象可以看成是配置类的信息，存储着一些配置类的元数据
当然，这里获取的配置类会包含之前解析过的配置类，所以扫描之后还会进行一次过滤，过滤到解析过的配置类
来看看spring具体是如何进行解析的
public void parse(Set<BeanDefinitionHolder> configCandidates) {
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) {
....
}
}
this.deferredImportSelectorHandler.process();
}configCandidates：check出来的配置类
这里虽然有三层的if else判断，但是做的事情都是同一个事情，获取当前配置类的元信息，然后进行parse()
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(metadata, beanName));
}
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
//删除非关键代码
SourceClass sourceClass = asSourceClass(configClass);
do {
sourceClass = doProcessConfigurationClass(configClass, sourceClass);
}
while (sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}解析的核心就是再这个do-while 循环里面，这才是真正的解析，这个do-while的目的其实是去遍历父类
首先会解析当前配置配，解析完成后，就回去判断，这个类有没有父类，如果有父类就会将父类添加到sourceClass
再交给外层的do-while进行解析
然后解析完后会将这个配置Bean添加到configurationClasses
doProcessConfigurationClass
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
processMemberClasses(configClass, sourceClass);
}
private void processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {
Collection<SourceClass> memberClasses = sourceClass.getMemberClasses();
if (!memberClasses.isEmpty()) {
List<SourceClass> candidates = new ArrayList<>(memberClasses.size());
for (SourceClass memberClass : memberClasses) {
if (ConfigurationClassUtils.isConfigurationCandidate(memberClass.getMetadata()) &&
!memberClass.getMetadata().getClassName().equals(configClass.getMetadata().getClassName())) {
candidates.add(memberClass);
}
}
OrderComparator.sort(candidates);
for (SourceClass candidate : candidates) {
if (this.importStack.contains(configClass)) {
this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
}
else {
this.importStack.push(configClass);
try {
processConfigurationClass(candidate.asConfigClass(configClass));
}
finally {
this.importStack.pop();
}
}
}
}
}首先是对于@Componet这个注解的解析，如果加了@Componet，就会进入processMemberClasses()这个方法
在processMemberClasses()里面会去判断当前解析的类是不是有内部类，获取内部类集合，然后遍历内部类集合
判断内部类上是否存在Component、ComponentScan、Import、ImportResource注解，如果存，就说明这个内部类是一个配置类
就会递归进行处理
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), PropertySources.class,
org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {
processPropertySource(propertySource);
}
else {
...
}
}解析@PropertySource注解，如果有这个注解，就会取出注解的值，然后调用processPropertySource()进行处理
private void processPropertySource(AnnotationAttributes propertySource) throws IOException {
String name = propertySource.getString("name");
if (!StringUtils.hasLength(name)) {
name = null;
}
String encoding = propertySource.getString("encoding");
if (!StringUtils.hasLength(encoding)) {
encoding = null;
}
String[] locations = propertySource.getStringArray("value");
Assert.isTrue(locations.length > 0, "At least one @PropertySource(value) location is required");
boolean ignoreResourceNotFound = propertySource.getBoolean("ignoreResourceNotFound");
Class<? extends PropertySourceFactory> factoryClass = propertySource.getClass("factory");
PropertySourceFactory factory = (factoryClass == PropertySourceFactory.class ?
DEFAULT_PROPERTY_SOURCE_FACTORY : BeanUtils.instantiateClass(factoryClass));
// @PropertySource注解中所指定的properties文件路径
for (String location : locations) {
try {
// 解析占位符
String resolvedLocation = this.environment.resolveRequiredPlaceholders(location);
// 得到资源文件
Resource resource = this.resourceLoader.getResource(resolvedLocation);
// 把资源文件解析成PropertySource对象，并且添加到environment中去
addPropertySource(factory.createPropertySource(name, new EncodedResource(resource, encoding)));
}
catch (IllegalArgumentException | FileNotFoundException | UnknownHostException ex) {
// Placeholders not resolvable or resource not found when trying to open it
if (ignoreResourceNotFound) {
if (logger.isInfoEnabled()) {
logger.info("Properties location [" + location + "] not resolvable: " + ex.getMessage());
}
}
else {
throw ex;
}
}
}
}比较关键的是@PropertySource 注解中value的值，我们可以通过@PropertySource（classpath：xxx.properties）导入一个properties的配置文件，然后这个路径就是再这里通过value取出，并且可以设置多个
然后对这个路径数组进行循环，并且解析
1.首先始解析占位符，也就是说我们可以在@PropertySource（classpath：${xxx}）解析 ${xxx} 这个占位符，这个占位符的解析就需要从spring的环境中去获取，但是注意，这里的这个占位符只能从通过系统变量，或者是jvm的启动变量中获取
2.通过解析之后的路径获取到properties的资源
3.然后将文件的内容进行解析，生成一些键值对，然后加到spring的环境中（environment）
这也就是为什么@Value（ ${xxx} ）可以获取到propreties里面的一些值，因为在spring 启动的时候，就已经将这些变量解析到environment中了
现在回到doProcessConfigurationClass，前面已经进行了@Component 和 @PropertySource的注解解析，接下来就是@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
// 扫描得到BeanDefinition
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();
}
// 检查扫描所得到BeanDefinition是不是配置Bean，基本上都有@Component注解，所以都是配置类
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}首先是判断这个类有没有加@ComponentScans 或者 @ComponentScan 注解 ，将添加了这些注解的类放入集合，
将这个集合进行遍历，对每个注解进行解析，其实主要就是进行扫描生成对应的BeanDefinition
public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
//获取
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"));
// 设置IncludeFilter
for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
for (TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addIncludeFilter(typeFilter);
}
}
// 设置ExcludeFilter
for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
for (TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addExcludeFilter(typeFilter);
}
}
// 设置懒加载 如果通过@ComponentScan 设置的懒加载，那么@ComponetScan扫描出来的类都是懒加载的
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);
}
});
// 开始扫描包路径，得到BeanDefinitionHolder的集合
return scanner.doScan(StringUtils.toStringArray(basePackages));
}其实这个方法最主要做的事情，就是扫描之前的一些设置，例如，需要扫描哪些注解，不需要扫描哪些注解，扫描出来的Bean的beanName如何生成，设置懒加载
然后获取@ComponentScan上面的路径，进过一些处理，就开始进行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) {
// 扫描包路径得到BeanDefinition，得到的BeanDefinition是空的，还没有解析类上所定义的注解信息
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
// 得到Scope的信息，并设置
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
// 得到beanName
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
if (checkCandidate(beanName, candidate)) {
// 生成BeanDefinitionHolder并注册到registry中
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}其中 findCandidateComponents(basePackage) 就是对路径下的类进行扫描，
扫描出的每一个类都会经过前面设置的 excludeFilters 和 includeFilters ，如果匹配上了 excludeFilters 就会直接return false
如果 匹配上了 includeFilters 才会返回 true
然后通过了过滤的类下扫描出来会封装为一个 ScannedGenericBeanDefinition 对象
完成之后机会生成一个beanName，让后将BeanDefinition的一些默认值设置到 ScannedGenericBeanDefinition
处理完 @ComponentScan 之后就是处理@Import 注解了
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
Collection<SourceClass> importCandidates, boolean checkForCircularImports) {
if (importCandidates.isEmpty()) {return;}
if (checkForCircularImports && isChainedImportOnStack(configClass)) {
this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
}
else {
this.importStack.push(configClass);
try {
for (SourceClass candidate : importCandidates) {
if (candidate.isAssignable(ImportSelector.class)) {
// Candidate class is an ImportSelector -> delegate to it to determine imports
Class<?> candidateClass = candidate.loadClass();
ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
this.environment, this.resourceLoader, this.registry);
if (selector instanceof DeferredImportSelector) {
this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
}
else {
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
processImports(configClass, currentSourceClass, importSourceClasses, false);
}
}
else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
// 如果@Import注解中的类实现了ImportBeanDefinitionRegistrar接口，就把该类的实例放入importBeanDefinitionRegistrars中，
// 后面再执行该实例的registerBeanDefinitions方法
Class<?> candidateClass = candidate.loadClass();
ImportBeanDefinitionRegistrar registrar =
ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
this.environment, this.resourceLoader, this.registry);
configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
}
else {
// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
// process it as an @Configuration class
this.importStack.registerImport(
currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
processConfigurationClass(candidate.asConfigClass(configClass));
}
}
}
catch (BeanDefinitionStoreException ex) {
........
}
finally {
this.importStack.pop();
}
}
}简单介绍一个这个方法的几个参数
ConfigurationClass configClass, SourceClass currentSourceClass, ：这两个参数都是配置类的信息
Collection importCandidates ：返回当前配置类上 @Import注解中所导入的类的信息
boolean checkForCircularImports : true
接下来关键 的部分就是对这个 importCandidates 进行判断，也就是对Import 注解导入的类进行判断
首先判断是不是ImportSelector.class 的子类，然后判断是不是实现了 ImportBeanDefinitionRegistrar.class,最后就是处理普通的类
1.实现了ImportSelector.class
根据传入的类型，生成一个ImportSelector 对象，其实际类型是传入类型
执行重写的 selectImports 方法，得到String数组（ClassName）
根据这个String数组，加载 出对应的类
进行递归调用，判断导入进来的类是不是实现了ImportSelector 或者是 ImportBeanDefinitionRegistrar
这里也就是说通过@Import导入进来的普通类，一样会当成配置类进行处理
2.实现了ImportBeanDefinitionRegistrar
首先也是实例化了一个ImportBeanDefinitionRegistrar 的对象
但是这里没有调用其重写的方法，而是将这个对象加入当前配置类的一个map属性中
3.普通类型
其实通过@Import 导入进来的类就是一个配置类，所以会将这个配置类添加到configurationClasses这个map中
接下来就是处理@ImportResource
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);
}
}对于@ImportResource 而言，就说会获取@ImportResource 上面的值，然后将这个路径添加 到importedResources 这个集合之中，
这个集合就可以理解为：当前配置文件导入资源的路径，这里并不会做解析工作，而是后面进行解析
然后是处理@Bean注解
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}这里就会遍历，拿到当前标注了@Bean注解的方法，然后将这些方法封装为BeanMethod，然后添加当配置类的beanMethods 集合中
private void processInterfaces(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {
for (SourceClass ifc : sourceClass.getInterfaces()) {
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(ifc);
for (MethodMetadata methodMetadata : beanMethods) {
if (!methodMetadata.isAbstract()) {
// A default method or other concrete method on a Java 8+ interface...
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
}
processInterfaces(configClass, ifc);
}
}这一部分的内容是为了配合java8的功能，去判断配置类实现的接口，因为在java8中，接口可以写一些默认方法，如果接口中有方法加了@Bean一样会扫描出来
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();
}
}最后一步就是对父类的处理了，前面提到过的，如果有父类就会将父类添加到sourceClass ，通过do-while循环进行处理
接下来回到processConfigBeanDefinitions 这个方法里面，上述的所有操纵也只是完成了 parser.parse(conadidates)
spring 已经完成了配置类的加载，同时可能得到了跟多的配置类，但是现在需要去解析这些类
private void loadBeanDefinitionsForConfigurationClass(
ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
if (trackedConditionEvaluator.shouldSkip(configClass)) {
String beanName = configClass.getBeanName();
if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
this.registry.removeBeanDefinition(beanName);
}
this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
return;
}
// 当前配置类是不是通过@Import注解导入进来的，如果是则解析该类上面的比如@Scope,@Lazy这些注解信息
// 然后生成一个AnnotationBeanDefintion 然后进行注册
if (configClass.isImported()) {
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
//处理@Bean 生成 BeanDefintion 进行注册
//这里生成的BeanDefinition 是ConfigurationClassBeanDefinition
//需要注意的几个点 @Bean 的注入模型是AUTOWIRE_CONSTRUCTOR,也就是通过构造方法
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
loadBeanDefinitionsForBeanMethod(beanMethod);
}
// 从配置类中Import进来的资源文件中加载BeanDefinition，比如xml文件
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
// 调用ImportBeanDefinitionRegistrar对象的registerBeanDefinitions方法加载BeanDefinition
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}进过这个方法之后，spring就算是完成了扫描和BeanDefinition的注册了
