spring5.0源码解析 之 ConfigurationClassPostProcessor
ConfigurationClassPostProcessor 的介绍
从图中可以看出 ConfigurationClassPostProcessor 的继承关系，首先 他 实现了一些Aware 可以获取到，环境和容器相关的属性，具体可以看这篇文章。
spring5.0 源码解析 initializeBean
同时 他实现了 BeanDefinitionRegistryPostProcessor
BeanDefinitionRegistryPostProcessor 又继承了 BeanFactoryPostProcessor
在容器启动阶段执行这两个方法，具体的执行顺序可以看这篇文章
spring5.0 源码解析（day03） invokeBeanFactoryPostProcessors(beanFactory)
void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
postProcessBeanDefinitionRegistry
在 postProcessBeanDefinitionRegistry 方法中可以获得 BeanDefinitionRegistry 对象，BeanDefinitionRegistry 保存了bean的注册信息 beanDefinition 的相关信息
具体的方法实现
// 获取 registry 的 hashCode
int registryId = System.identityHashCode(registry);
// 判断 这个 registry 已经执行过 或者正在执行
if (this.registriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
}
// 判断 这个 registry 已经执行过 或者正在执行
if (this.factoriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + registry);
}
this.registriesPostProcessed.add(registryId);
// 从名称上可以看出 处理 BeanDefinitions 的配置
processConfigBeanDefinitions(registry);
processConfigBeanDefinitions 对多个配置类的循环解析
解析配置类相关信息 ， 并把解析到的bean定义注册到 registry
从下面的方法可以看出 具体的 candidate 的解析 是委托 ConfigurationClassParser 处理的 ，通过 配置类解析器的 parse 方法完成解析的
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
// 获取所有 的 BeanDefinition 全限名
String[] candidateNames = registry.getBeanDefinitionNames();
// 循环处理
for (String beanName : candidateNames) {
// 通过 registry 获取 BeanDefinition
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
// 检验 BeanDefinition 的 属性中是否含有 configurationClass 属性 我认为这里是 标记 beanDef 的作用 已经被标记的代表已经处理完成
if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
// 检查 beanDef 是否是个配置类的候选者，如果是做个标记。
// beanDef 拥有 @Configuration 或 @Component 或 @ComponentScan 或 @Import 或 @ImportResource 其中的一个注解，那它就是配置类的候选者
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
// 保存 BeanDefinitionHolder 为一个 配置的候选者
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
// 检查bean 的生成策略 是否为 singleton
SingletonBeanRegistry sbr = null;
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry) registry;
// 获取 一个 beanName 生成器
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 的解析器 主要为了解析 @Configuration 注解
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
// 报错 所有的 cofing 获选者
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
// 记录已经解析出来并已经读取完 BeanDefinition 的 ConfigurationClass
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
// 循环解析
do {
StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");
// 解析 candidates
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
// 初始化 BeanDefinitionReader 用来加载 解析到的 configClasses
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
// 加载 BeanDefinitions
this.reader.loadBeanDefinitions(configClasses);
// 记录已经解析完成 ConfigurationClass 并注册到 registry
alreadyParsed.addAll(configClasses);
processConfig.tag("classCount", () -> String.valueOf(configClasses.size())).end();
candidates.clear();
// 如果 registry 中的bean定义 大于 candidateNames 的长度 说明有新的 ConfigurationClass 被加载进来
if (registry.getBeanDefinitionCount() > candidateNames.length) {
String[] newCandidateNames = registry.getBeanDefinitionNames();
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
Set<String> alreadyParsedClasses = new HashSet<>();
// 记录以处理的 ConfigurationClass 的 class名称
for (ConfigurationClass configurationClass : alreadyParsed) {
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
for (String candidateName : newCandidateNames) {
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);
// 把未处理的 放到 candidates 循环处理
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
// 将ImportRegistry注册为bean，以支持ImportAware@Configuration类
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.
清除外部提供的MetadataReaderFactory中的缓存；这是一个无操作，因为它将被ApplicationContext清除
((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
}
}
ConfigurationClassParser.parse 方法 解析配置类
parse 方法 用于根据不同的 BeanDefinition 定义选取不同的 parse 方法， 其实最终还是根据 processConfigurationClass 进行解析的。
public void parse(Set<BeanDefinitionHolder> configCandidates) {
// 循环解析
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
try {
// 根据把不同的 BeanDefinition 选择不同的解析方式 全是根据 processConfigurationClass 方法进行解析
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);
}
}
this.deferredImportSelectorHandler.process();
}
processConfigurationClass 方法 解析配置类
这个方法主要判断 配置类是否被解析过 如果没有则 递归调用doProcessConfigurationClass解析 配置类的层次结构
// 判断适应应该跳过该配置类
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
return;
}
// 看这个类是否已经存在
ConfigurationClass existingClass = this.configurationClasses.get(configClass);
if (existingClass != null) {
// 判断配置类 是否被其他 配置类 import 如果是 直接合并
if (configClass.isImported()) {
if (existingClass.isImported()) {
// 将给定配置类中导入的by声明合并到此类中
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.
//找到显式bean定义，可能替换了导入。
//我们把旧的拿走，换新的。
this.configurationClasses.remove(configClass);
this.knownSuperclasses.values().removeIf(configClass::equals);
}
}
// Recursively process the configuration class and its superclass hierarchy.
// 递归处理 configClass 的 多层次结构
SourceClass sourceClass = asSourceClass(configClass, filter);
do {
sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
}
while (sourceClass != null);
// 保存 configClass
this.configurationClasses.put(configClass, configClass);
doProcessConfigurationClass
-
处理@Component注解：
如果当前配置类上存在@Component以及派生注解，包括@Repository、@Service、@Controller、@Configuration等注解，那么调用processMemberClasses方法递归内部类配置类。 -
处理属性资源文件，加了@PropertySource注解。
解析出来的本地属性源会存入environment环境变量中。 -
处理@ComponentScans、@ComponentScan注解
依靠ClassPathBeanDefinitionScanner的doScan方法 注册到 register 中 -
处理@Import注解。
将扫描到的 Import 的类 保存到 ImportStack的imports 中 在上面说的processConfigBeanDefinitions方法中 read -
处理@ImportResource注解
这里仅仅对于@ImportResource注解引入的配置文件路径进行占位符的替换（从environment环境变量中查找），并方法替换后的路径和reader读取器通过addImportedResource方法存入configClass的importedResources缓存中， -
处理加了@Bean注解的方法。
用于通过方法引入bean定义，类似于工厂方法。这里同样将解析后的方法元数据通过addBeanMethod方法存入configClass的beanMethods缓存中，后续再继续处 -
通过processInterfaces()处理接口的默认方法，
从JDK8开始，接口中的方法可以有自己的默认实现，因此，如果这个接口中的方法也加了@Bean注解，也需要被解析。(很少用) -
解析父类，如果被解析的配置类继承了某个类，那么也会递归解析父类
-
如果没有符合规则的父类或者都解析完毕，那么返回null，将会在外层的processConfigurationClass中跳出循环，进行后续步骤
该方法对于通过@ComponentScans、@ComponentScan注解引入的bean定义会添加到了容器中，但是对于@Import、@Bean、@ImportResource注解引入的bean定义并没有注册到容器中，而是在后面的processConfigBeanDefinitions 方法 调用 this.reader.loadBeanDefinitions()方法中才会真正的解析和注册。
protected final SourceClass doProcessConfigurationClass(
ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
throws IOException {
// Component 注解解析
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// 首先递归处理嵌套类
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) {
// 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());
}
}
}
}
// 处理 @Import annotations
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
// 处理 @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);
}
}
// 处理 @Bean methods
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// 处理接口上的默认方法
processInterfaces(configClass, sourceClass);
// 处理超类，如果有的话
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;
}
postProcessBeanFactory
在执行完 postProcessBeanDefinitionRegistry 之后 会执行 postProcessBeanFactory
ConfigurationClassPostProcessor 的 postProcessBeanFactory 主要作用 准备配置类，以便在运行时为bean请求提供服务通过用CGLIB增强的子类替换它们。
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 获取 hash值
int factoryId = System.identityHashCode(beanFactory);
// 查看是否以处理过 或正在处理
if (this.factoriesPostProcessed.contains(factoryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + beanFactory);
}
this.factoriesPostProcessed.add(factoryId);
// 判断 registriesPostProcess 是否被执行过
if (!this.registriesPostProcessed.contains(factoryId)) {
// BeanDefinitionRegistryPostProcessor hook apparently not supported...
// Simply call processConfigurationClasses lazily at this point then.
processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
}
// 对加了@Configuration注解的配置类进行Cglib代理
enhanceConfigurationClasses(beanFactory);
// 添加一个BeanPostProcessor后置处理器
beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}
在代码中可以看到 后置处理通过 enhanceConfigurationClasses 对加了@Configuration注解的配置类进行Cglib代理
在此方法中 调用 配置类增强器 进行代理操作
// 新建一个 配置类增强器
ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
// 遍历所有 配置类
for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
AbstractBeanDefinition beanDef = entry.getValue();
// If a @Configuration class gets proxied, always proxy the target class
// 如果@Configuration类被代理，则始终代理目标类
beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
// Set enhanced subclass of the user-specified bean class
// 设置用户指定bean类的增强子类
Class<?> configClass = beanDef.getBeanClass();
// 对配置类进行 增强
Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
if (configClass != enhancedClass) {
if (logger.isTraceEnabled()) {
logger.trace(String.format("Replacing bean definition '%s' existing class '%s' with " +
"enhanced class '%s'", entry.getKey(), configClass.getName(), enhancedClass.getName()));
}
beanDef.setBeanClass(enhancedClass);
}
}
在 enhance 增强中 会设置 两个过滤器
-
BeanMethodInterceptor拦截器，将会拦截配置类中的@Bean方法 保证在单例情况下 调用bean方法只返回一个相同的实例
对于被@Configuration注解及其派生注解标注的proxyBeanMethods属性的值为true（默认就是true）的配置类，内部的单例@Bean方法仅仅会被调用一次，用于创建对象，后续如果存在任何@Bean方法之间的调用，或者外部对象对@Bean方法的调用（这要求该对象交给Spring容器管理），都会是从容器中直接查找已创建的对象返回，不会再调用@Bean方法，能够保证是同一个实例，即都指向IoC内的单例。 -
BeanFactoryAwareMethodInterceptor拦截器，将会拦截setBeanFactory方法。
拦截BeanFactoryAware的setBeanFactory方法回调，为"$$beanFactory"属性赋值，这里的拦截早于@Bean方法的拦截，在创建对象之后就马上调用了该方法
ImportAwareBeanPostProcessor
postProcessBeforeInitialization方法则是在initializeBean初始化bean的时候被调用 ， 其作用是为EnhanceConfiguration类的beanFactory属性赋值。
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
//如果是ImportAware类型
if (bean instanceof ImportAware) {
//获取IMPORT_REGISTRY_BEAN_NAME的bean实例，在前面的processConfigBeanDefinitions方法最后就注册了该名字的bean实例
ImportRegistry ir = this.beanFactory.getBean(IMPORT_REGISTRY_BEAN_NAME, ImportRegistry.class);
//获取引入当前类的类元数据的最后一个，当前类就是被@Import注解引入的普通类，引入类就是添加@Import注解的类
AnnotationMetadata importingClass = ir.getImportingClassFor(ClassUtils.getUserClass(bean).getName());
//设置到setImportMetadata方法参数中
if (importingClass != null) {
((ImportAware) bean).setImportMetadata(importingClass);
}
}
return bean;
}
public PropertyValues postProcessProperties(@Nullable PropertyValues pvs, Object bean, String beanName) {
// Inject the BeanFactory before AutowiredAnnotationBeanPostProcessor's
// postProcessProperties method attempts to autowire other configuration beans.
//对于EnhancedConfiguration类型的代理对象注入beanFactory实例
if (bean instanceof EnhancedConfiguration) {
((EnhancedConfiguration) bean).setBeanFactory(this.beanFactory);
}
return pvs;
}
135
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
