前言
前面分析了 Spring 如何执行 BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor 接口中的方法,也就是 BeanFactory 后置处理器什么时候执行。
Spring 的默认 BeanFactory 后置处理器有几个,但有一个 BeanFactory 后置处理器不得不提,那就是 ConfigurationClassPostProcessor,可以说它是 Spring 做重要的 BeanFactory 后置处理器,没有之一。
ConfigurationClassPostProcessor
为什么说它是最重要的 BeanFactory 后置处理器?
Spring 执行到这里之前,除了前面提过添加内置后置处理器,和程序员提供的配置类,Spring 并没有开始去解析用户提供的 Bean。而这最重要的一步,就是由 ConfigurationClassPostProcessor 来处理。
源码分析
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
// HashCode 处理并验证
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);
}
前面部分代码只是验证,跟进最后一行代码processConfigBeanDefinitions(registry);
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
// 可能是 configClass 集合
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
// 取出所有的 BeanDefinition 的名称
String[] candidateNames = registry.getBeanDefinitionNames();
// 遍历所有的 BeanDefinition 的名称
for (String beanName : candidateNames) {
// 根据名称获得 BeanDefinition
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);
}
}
// 判断是否可能为配置类
// 根据类上的注解判断配置类是FULL模式还是LITE模式
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// 如果不存在配置类,则直接返回
if (configCandidates.isEmpty()) {
return;
}
// 排序
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});
// 确认类名生成器正常
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
// 初始化一个 ConfigurationClass 解析器,包含了注解解析工厂,问题广播器,容器环境,资源加载器,通过 @componentScan 注解扫描出 Bean 的名称生成器
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
// 还未解析的配置类或者说等待解析的配置类
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
// 保存已解析的 BeanDefinition
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
// 开始解析配置类
parser.parse(candidates);
// 检查是否有错误
parser.validate();
// 前面解析配置类,只有 @Configuration 和通过 @ComponentScan 注解扫描出来的类才会加入到 BeanFactory 的 BeanDefinitionMap
// 其他注解,例如@Import、@Bean,会包装为 ConfigurationClass 类
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());
}
// 把前面解析为 ConfigurationClass 类解析为 BeanDefinition 加入到 BeanDefinitionMap
this.reader.loadBeanDefinitions(configClasses);
// 解析过加入到已经解析的类集合
alreadyParsed.addAll(configClasses);
candidates.clear();
// 判断解析后的 BeanFactory 是否有增加 BeanDefinition
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));
}
}
}
// 更新当前所有 BeanDefinition 名称
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty());
if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}
// 清除缓存
if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
}
}
1、加入到 configCandidates 集合的 BeanDefinition,说明这个 BeanDefinition 是个配置类,接下来要解析它。而判断是不是配置类的逻辑在这行代码ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory
public static boolean checkConfigurationClassCandidate(
BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {
// 验证
String className = beanDef.getBeanClassName();
if (className == null || beanDef.getFactoryMethodName() != null) {
return false;
}
AnnotationMetadata metadata;
// 判断是否支持注解解析 BeanDefinition 和当前 BeanDefinition 和注解元数据(类)是否来自同一个类
if (beanDef instanceof AnnotatedBeanDefinition &&
className.equals(((AnnotatedBeanDefinition) beanDef).getMetadata().getClassName())) {
// 获得元数据
metadata = ((AnnotatedBeanDefinition) beanDef).getMetadata();
}
else if (beanDef instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) beanDef).hasBeanClass()) {
Class<?> beanClass = ((AbstractBeanDefinition) beanDef).getBeanClass();
if (BeanFactoryPostProcessor.class.isAssignableFrom(beanClass) ||
BeanPostProcessor.class.isAssignableFrom(beanClass) ||
AopInfrastructureBean.class.isAssignableFrom(beanClass) ||
EventListenerFactory.class.isAssignableFrom(beanClass)) {
return false;
}
metadata = AnnotationMetadata.introspect(beanClass);
}
// 上面都不是那就判断是否支持注解解析,不支持直接返回。
else {
try {
MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(className);
metadata = metadataReader.getAnnotationMetadata();
}
catch (IOException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Could not find class file for introspecting configuration annotations: " +
className, ex);
}
return false;
}
}
// 从类中取出 @Configuration 注解
// 如果类中有 @Configuration 注解并且 proxyBeanMethods 属性为 false,则标记配置类为FULL模式 @Configuration(proxyBeanMethods=false)
// 如果类中有 @Configuration 注解并且 proxyBeanMethods 属性为 true,则标记配置类为Lite模式
// 如果类中没有 @Configuration,但有 @Bean,@Component,@ComponentScan,@Import,@ImportResource 这些注解,也标记为Lite模式
// 如果是实现了 Configuration 接口或者是以上注解都没有,则直接跳过,不是配置类不解析
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;
}
// 解析 @Order 注解
Integer order = getOrder(metadata);
if (order != null) {
beanDef.setAttribute(ORDER_ATTRIBUTE, order);
}
return true;
}
能被当做配置类的,不仅仅是程序员加 @Configuration
,还有 @Bean,@Component,@ComponentScan,@Import,@ImportResource
这些注解 Spring 认为也是配置类。不同的是 @Configuration
注解标记为FULL
模式,而其他标记为LITE
模式。
2、正在做解析的是 ConfigurationClassParser 类,执行了 parser.parse(candidates)
public void parse(Set<BeanDefinitionHolder> configCandidates) {
// 遍历需要解析的配置类集合
for (BeanDefinitionHolder holder : configCandidates) {
// 获得 BeanDefinition
BeanDefinition bd = holder.getBeanDefinition();
// 不同的 BeanDefinition 使用不同解析方式
try {
if (bd instanceof AnnotatedBeanDefinition) {
// 递归到 processConfigurationClass
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
}
else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
// 递归到 processConfigurationClass
parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
}
else {
// 递归到 processConfigurationClass
parse(bd.getBeanClassName(), holder.getBeanName());
}
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
}
}
this.deferredImportSelectorHandler.process();
}
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 final void parse(Class<?> clazz, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(clazz, beanName), DEFAULT_EXCLUSION_FILTER);
}
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
}
不同的 BeanDefinition,使用的都是同一种解析方法,最后都是进入 processConfigurationClass 方法。
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);
}
return;
}
else {
this.configurationClasses.remove(configClass);
this.knownSuperclasses.values().removeIf(configClass::equals);
}
}
// 递归解析配置类,可能配置类有父类。
SourceClass sourceClass = asSourceClass(configClass, filter);
do {
sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
}
while (sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}
前面验证不说了,下面解析方法 doProcessConfigurationClass。
protected final SourceClass doProcessConfigurationClass(
ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
throws IOException {
// 解析 @Component 配置类
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// Recursively process any member (nested) classes first
processMemberClasses(configClass, sourceClass, filter);
}
// 解析 @PropertySource 注解配置资源
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");
}
}
// 解析 @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) {
// 扫描 @ComponentScan 配置的包
Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// 递归解析扫描出的配置类
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());
}
}
}
}
// 解析 @Import 注解类
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
// 解析 @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);
}
}
// 解析 @Bean 注解
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// 解析配置类接口
processInterfaces(configClass, sourceClass);
// 配置类是否有父类,父类不是JDK内置类,返回上一层继续解析
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();
}
}
// 没有父类需要解析,不需要再递归
return null;
}
前面被标记为配置类的 BeanDefinition,都在这里解析。注意下面一点,配置类的父类也会被循环解析。
3、仔细看前面有几个解析代码块是用了do while
循环,不断从配置类解析出新的配置类,直到所有的配置都被解析完成。
总结
扫描程序员配置,把需要转化的类全部转为 BeanDefinition。加入到 BeanFactory 中。准备实例化。