关键词:
-
Spring解析配置类注解Bean
-
Spring注册Bean后置增强器（BPP）
-
Spring消息资源和监听器的初始化
一：Spring解析配置类注解Bean==>ConfigurationClassPostProcessor
前言:Spring注册Bean可以是XML形式的也可以是注解修饰的。该小节介绍的是ConfigurationClassPostProcessor类是如何将被注解修饰的配置类注册进Bean
1.ConfigurationClassPostProcessor实现了BeanDefinitionRegistryPostProcessor（BDRPP），也就表明该类继承继承了来自父类postProcessBeanDefinitionRegistry()方法。根据之前的介绍，这个方法是对BeanDefinition进行一些具体操作的。这个方法也会在Refresh()方法执行过程中被调用，这里不再赘言。
2.我们通过Debug的方式进入到了该方法，看到了之前的几个步骤并不是是否关键，但是最后一个方法进行了跳转
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
// 根据对应的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);
}
// 将马上要进行处理的registry对象的id值放到已经处理的集合对象中
this.registriesPostProcessed.add(registryId);
// ==> 处理配置类的bean定义信息
processConfigBeanDefinitions(registry);
}
3.debug进入后会发现进入到了一个特别长的方法里面。这里采取先介绍，再上源码，如何源码+注释的方式理解。
- 获取到Bean工厂中所有的BeanDefinitionNames
- 在进行遍历所有的BeanDefinitionName时，获取每个BeanDefinition，进行校验
- ==>是否已经处理过了
- ==>检测是否为一个配置类
- 解析操作
3.1关于"是否已经处理过了"的解析
主要是根据beanDefinition中的configurationClass属性是否为空进行判断。不等于空，那么意味着已经处理过，输出日志信息
3.2关于"检测是否为一个配置类"的解析
主要是根据ConfigurationClassUtils的checkConfigurationClassCandidate方法来进行校验
// 1.【筛选】遍历所有要处理的beanDefinition的名称,筛选对应的beanDefinition（被注解修饰的）
for (String beanName : candidateNames) {
// 获取指定名称的BeanDefinition对象
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
// 如果beanDefinition中的configurationClass属性不等于空，那么意味着已经处理过，输出日志信息
if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
/**
* 1.判断当前BeanDefinition是否是一个配置类
* 2.如果添加了@Configuration且配置proxyBeanMethods代理为true则设置属性为full
* 3.如果加了@Bean、@Component、@ComponentScan、@Import、@ImportResource注解
* 或只是添加了@Configuration，则设置为lite
* 4.如果配置类上被@Order注解标注，则设置BeanDefinition的order属性值
* 5.如果被注解修饰了返回了true就添加到configCandidates集合中表明它是一个配置类
*/
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}3.3关于对配置类的解析操作
- 通过ConfigurationClassParser的parse方法进行解析==>参数为所有的配置类集合
- 遍历所有的BeanDefinitionHolder
- ==>根据类型BeanDefinitionHolder类型的不同调用不同的parse重载方法来进行解析（本文是以注解为Debug依据）
- ==>parse内又调用了processConfigurationClass方法
// 根据注解元数据和beanName解析配置文件，有注解元数据
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
}processConfigurationClass方法解析
protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
// 通过条件计算器判断是否跳过解析
// 通过@Conditional({})来进行
// 如果没有被@Conditional修饰，或者条件符合@Conditional的话，就跳过。反之，就跳过。
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
return;
}
// 第一次进入的时候，configurationClass的size为0，existingClass肯定为null，在此处处理configuration重复import
// 如果同一个配置类被处理两次，两次都属于被import的则合并导入类，返回，如果配置类不是被导入的，则移除旧的使用新的配置类
ConfigurationClass existingClass = this.configurationClasses.get(configClass);
if (existingClass != null) {
if (configClass.isImported()) {
if (existingClass.isImported()) {
// 如果要处理的配置类configClass在已经分析处理的配置类记录中已存在，合并两者的importBy属性
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.
// 处理配置类，由于配置类可能存在父类(若父类的全类名是以java开头的，则除外)，所有需要将configClass变成sourceClass去解析，然后返回sourceClass的父类。
// 如果此时父类为空，则不会进行while循环去解析，如果父类不为空，则会循环的去解析父类
// SourceClass的意义：简单的包装类，目的是为了以统一的方式去处理带有注解的类，不管这些类是如何加载的
// 如果无法理解，可以把它当做一个黑盒，不会影响看spring源码的主流程
SourceClass sourceClass = asSourceClass(configClass, filter);
do {
// 重点解析各种注解
sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
}
while (sourceClass != null);
// 将解析的配置类存储起来，这样回到parse方法时，能取到值
this.configurationClasses.put(configClass, configClass);
}- 开始解析各种配置类注解
@Nullable
protected final SourceClass doProcessConfigurationClass(
ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
throws IOException {
// @Configuration继承了@Component
// 【@Component】 如果含有@Component注解，就进行递归处理内部类，因为可能内部类也被@Component修饰
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// Recursively process any member (nested) classes first
// 递归处理内部类，因为内部类也是一个配置类，配置类上有@configuration注解，该注解继承@Component，if判断为true，调用processMemberClasses方法，递归解析配置类中的内部类
processMemberClasses(configClass, sourceClass, filter);
}
// Process any @PropertySource annotations
// 【@PropertySource】 如果配置类上加了@PropertySource注解，那么就解析加载properties文件，并将属性添加到spring上下文中
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】处理@ComponentScan或者@ComponentScans注解，并将扫描包下的所有bean转换成填充后的ConfigurationClass
// 此处就是将自定义的bean加载到IOC容器，因为扫描到的类可能也添加了@ComponentScan和@ComponentScans注解，因此需要进行递归解析
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和@ComponentScans配置的扫描的包所包含的类
// 比如 basePackages = com.mashibing, 那么在这一步会扫描出这个包及子包下的class，然后将其解析成BeanDefinition
// (BeanDefinition可以理解为等价于BeanDefinitionHolder)
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
// 通过上一步扫描包com.mashibing，有可能扫描出来的bean中可能也添加了ComponentScan或者ComponentScans注解.
//所以这里需要循环遍历一次，进行递归(parse)，继续解析，直到解析出的类上没有ComponentScan和ComponentScans
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
// 判断是否是一个配置类，并设置full或lite属性
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
// 处理@ImportResource注解，导入spring的配置文件
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
// 处理加了@Bean注解的方法，将@Bean方法转化为BeanMethod对象，保存再集合中
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// Process default methods on interfaces
// 处理接口的默认方法实现，从jdk8开始，接口中的方法可以有自己的默认实现，因此如果这个接口的方法加了@Bean注解，也需要被解析
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;
}附上解析配置类注解的流程图
二：Spring注册Bean后置增强器(BPP)==>refresh()中的registerBeanPostProcessors方法
前言：该方法内对于BPP的处理流程与上篇文章中对于BFPP的流程大致相像。所以介绍的篇幅不会太长。
注意：这里不同于处理BFPP，BFPP是进行调用。而这里是进行注册BPP，是【注册】
方法入口:
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}主要步骤：
1.找到所有的BPP
2.将BPP分成四类集合
- 实现了PriorityOrdered接口的
- 实现MergedBeanDefinitionPostProcessor和PriorityOrdered接口的
- 实现了Ordered接口的
- 其他类型的BPP
3.将每一个集合进行排序
4.将每一个集合进行批量注册进BeanFactrory
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 找到所有实现了BeanPostProcessor接口的类
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// 记录下BeanPostProcessor的目标计数
// 此处为什么要+1呢，原因在于，在下一行添加一个BeanPostProcessorChecker的类
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
// 添加BeanPostProcessorChecker(主要用于记录信息)到beanFactory中
// ==> Bean的三种角色在postProcessAfterInitialization()方法中可以探讨
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 定义存放实现了PriorityOrdered接口的BeanPostProcessor集合
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 定义存放spring内部的BeanPostProcessor
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
// 定义存放实现了Ordered接口的BeanPostProcessor的name集合
List<String> orderedPostProcessorNames = new ArrayList<>();
// 定义存放普通的BeanPostProcessor的name集合
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 遍历beanFactory中存在的BeanPostProcessor的集合postProcessorNames，
for (String ppName : postProcessorNames) {
// 如果ppName对应的BeanPostProcessor实例实现了PriorityOrdered接口，则获取到ppName对应的BeanPostProcessor的实例添加到priorityOrderedPostProcessors中
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
// 如果ppName对应的BeanPostProcessor实例也实现了MergedBeanDefinitionPostProcessor接口，那么则将ppName对应的bean实例添加到internalPostProcessors中
// BeanPostProcessor的几个实现类 销毁，合并，初始化，smart等等
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 如果ppName对应的BeanPostProcessor实例没有实现PriorityOrdered接口，但是实现了Ordered接口，那么将ppName对应的bean实例添加到orderedPostProcessorNames中
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
} else {
// 否则将ppName添加到nonOrderedPostProcessorNames中
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 首先，对实现了PriorityOrdered接口的BeanPostProcessor实例进行排序操作
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 注册实现了PriorityOrdered接口的BeanPostProcessor实例添加到beanFactory中
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
// 注册所有实现Ordered的beanPostProcessor
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String ppName : orderedPostProcessorNames) {
// 根据ppName找到对应的BeanPostProcessor实例对象
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
// 将实现了Ordered接口的BeanPostProcessor添加到orderedPostProcessors集合中
orderedPostProcessors.add(pp);
// 如果ppName对应的BeanPostProcessor实例也实现了MergedBeanDefinitionPostProcessor接口，那么则将ppName对应的bean实例添加到internalPostProcessors中
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 对实现了Ordered接口的BeanPostProcessor进行排序操作
sortPostProcessors(orderedPostProcessors, beanFactory);
// 注册实现了Ordered接口的BeanPostProcessor实例添加到beanFactory中
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
// 创建存放没有实现PriorityOrdered和Ordered接口的BeanPostProcessor的集合
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
// 遍历集合
for (String ppName : nonOrderedPostProcessorNames) {
// 根据ppName找到对应的BeanPostProcessor实例对象
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
// 将没有实现PriorityOrdered和Ordered接口的BeanPostProcessor添加到nonOrderedPostProcessors集合中
nonOrderedPostProcessors.add(pp);
// 如果ppName对应的BeanPostProcessor实例也实现了MergedBeanDefinitionPostProcessor接口，那么则将ppName对应的bean实例添加到internalPostProcessors中
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 注册没有实现PriorityOrdered和Ordered的BeanPostProcessor实例添加到beanFactory中
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
// 将所有实现了MergedBeanDefinitionPostProcessor类型的BeanPostProcessor进行排序操作
sortPostProcessors(internalPostProcessors, beanFactory);
// 注册所有实现了MergedBeanDefinitionPostProcessor类型的BeanPostProcessor到beanFactory中
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
// 注册ApplicationListenerDetector到beanFactory中
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}三.Spring消息资源和监听器的初始化
1.传统的观察者模式与Spring中的观察者模式
Spring中的执行顺序
2.创建多播器==>初始化事件监听多路广播器：注意，这里创建了一个多播器，如何注册进了BeanFactory中了
protected void initApplicationEventMulticaster() {
// 获取当前bean工厂,一般是DefaultListableBeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 判断容器中是否存在bdName为applicationEventMulticaster的bd，也就是说自定义的事件监听多路广播器，必须实现ApplicationEventMulticaster接口
// 第一次进来一般是没有所以走else分支
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
// 如果有，则从bean工厂得到这个bean对象
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isTraceEnabled()) {
logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
}
else {
// 【创建多播器】如果没有，则默认采用SimpleApplicationEventMulticaster
/**
* 1.SimpleApplicationEventMulticaster的父类AbstractApplicationEventMulticaster
* 下的defaultRetriever属性中有一个applicationListeners用于存储相关的监听器
* 2.将创建好的多播器注册进上下文对象
*/
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
if (logger.isTraceEnabled()) {
logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
}
}
}3.注册监听器
获取来源三个地方
1.上下文对象中（ApplicationContext）
2.容器中（BeanFactory）
3.在prepareRefresh（）时创建的监听器集合
protected void registerListeners() {
// Register statically specified listeners first.
// 遍历应用程序中存在的监听器集合，并将对应的监听器添加到监听器的多路广播器中
for (ApplicationListener<?> listener : getApplicationListeners()) {
// 从上下文对象中获取多播器添加进监听器，initApplicationEventMulticaster方法调用时已经注册好多播器了
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
// 从容器中获取所有实现了ApplicationListener接口的bd的bdName
// 放入ApplicationListenerBeans集合中
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
// 接下来所执行的是将监听器名称加入到多播器，
// 这是由于getBeanNamesForType得到的是String...Name
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
// getApplicationEventMulticaster().addApplicationListener(this.getBean(listenerBeanName,ApplicationListener.class));
}
// Publish early application events now that we finally have a multicaster...
// 此处先发布早期的监听器集合
// refresh()的第一个方法prepareRefresh()内初始化了
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}4.发布事件==>重点是publishEvent方法进行了事件发布
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
// 清除上下文级别的资源缓存(如扫描的ASM元数据)
// 清空在资源加载器中的所有资源缓存
clearResourceCaches();
// Initialize lifecycle processor for this context.
// 为这个上下文初始化生命周期处理器
// 初始化LifecycleProcessor.如果上下文中找到'lifecycleProcessor'的LifecycleProcessor Bean对象，
// 则使用DefaultLifecycleProcessor
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
// 首先将刷新传播到生命周期处理器
// 上下文刷新的通知，例如自动启动的组件
getLifecycleProcessor().onRefresh();
// Publish the final event.
// 【发布】发布最终事件
// 新建ContextRefreshedEvent事件对象，将其发布到所有监听器。
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
// 参与LiveBeansView MBean，如果是活动的
// LiveBeansView:Sping用于支持JMX 服务的类
// 注册当前上下文到LiveBeansView，以支持JMX服务
LiveBeansView.registerApplicationContext(this);
}
769
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
