highlight: arduino-light
5.context.refresh()
5.1prepareRefresh:设置关闭&激活状态&校验必需属性
```java protected void prepareRefresh() { //获取spring启动的时间 this.startupDate = System.currentTimeMillis(); //设置关闭状态为false this.closed.set(false); //设置激活状态为true this.active.set(true);
// Initialize any placeholder property sources in the context environment.
/***
* 扩展点
* 初始化资源放置位置
* 重写initPropertySources方法
* 在此方法中执行AbstractPropertyResolver类的setRequiredProperties
* 例如:
* getEnvironment().setRequiredProperties("tyrant");
* 可以强制要求指定的环境变量tyrant必须存在
*/
initPropertySources();
// Validate that all properties marked as required are resolvable:
// see ConfigurablePropertyResolver#setRequiredProperties
/***
* 判断指定的环境变量是否存在,不存在就无法启动必须存在
* 即判断 requiredProperties 中的属性对应的值是不是存在
* 如自己扩展的 getEnvironment().setRequiredProperties("tyrant");
*/
getEnvironment().validateRequiredProperties();
// Store pre-refresh ApplicationListeners...
//Springboot启动扩展了下面的 监听器和事件
if (this.earlyApplicationListeners == null) {
this.earlyApplicationListeners =
new LinkedHashSet<>(this.applicationListeners);
}
else {
// Reset local application listeners to pre-refresh state.
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
// Allow for the collection of early ApplicationEvents,
// to be published once the multicaster is available...
this.earlyApplicationEvents = new LinkedHashSet<>();} ```
扩展点:initPropertySources
扩展点:validateRequiredProperties()
5.2obtainFreshBeanFactory():获取BeanFactory
java protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { /*** * refreshBeanFactory: * 如果beanFactory已经存在 先销毁在创建 * 所以这也是为什么叫刷新的原因 * 因为是先销毁在创建 */ refreshBeanFactory(); return getBeanFactory(); }
5.2.1refreshBeanFactory()
java @Override protected final void refreshBeanFactory() throws IllegalStateException { //修改刷新状态 只能刷新一次 if (!this.refreshed.compareAndSet(false, true)) { throw new IllegalStateException( "GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once"); } //给beanFactory设置全局唯一Id this.beanFactory设置全局唯一Id.setSerializationId(getId()); }
5.2.2getBeanFactory()
java @Override public final ConfigurableListableBeanFactory getBeanFactory() { //主要就是一个校验的作用 DefaultListableBeanFactory beanFactory = this.beanFactory; if (beanFactory == null) { throw new IllegalStateException("BeanFactory not initialized or already closed - call 'refresh' before accessing beans via the ApplicationContext"); } return beanFactory; }
5.3prepareBeanFactory(beanFactory)
```java protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { // Tell the internal bean factory to use the context's class loader etc. //AppClassloader beanFactory.setBeanClassLoader(getClassLoader()); //bean表达解析器 为了让beanFactory能够解析bean表达式 beanFactory.setBeanExpressionResolver( new StandardBeanExpressionResolver (beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(
new ResourceEditorRegistrar(this, getEnvironment()));
//忽略aware接口,在BeanPostProcessor处理
//核心代码 扩展点: aop也是通过BeanPostProcessor与IOC容器建立了联系
//ApplicationContextAwareProcessor实现了BeanPostProcessor
//在postProcessBeforeInitialization调用了invokeAwareInterfaces
//在invokeAwareInterfaces中为bean注入Spring容器内置的对象即下面的Aware
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//设置忽略以下aware接口
//为什么要忽略？
//因为下面的这5个aware接口已经通过ApplicationContextAwareProcessor做了处理
//需要在bean中注入内置对象 实现对应接口即可。自动注入反而会报错。
//具体可参考
//https://blog.csdn.net/qq_36951116/article/details/99587519
/*
自动注入会报错
@Autowired
ApplicationEventPublisherAware aware;
*/
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// 自动装配规则设置 当在进行ioc初始化如果1个接口有多个实现 使用指定的对象注入
// 和@Primary作用差不多
// 比如注入BeanFactory时,注入的一定是我们指定的beanFactory
//beanFactory.registerResolvableDependency(Tyrant.class, tyrant);
//注入Tyrant时注入的一定是我们制定的这个tyrant
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
/***
ApplicationListenerDetector：主要作用：
1、在Bean初始化完成之后：如果Bean是单例的则并且bean instanceof ApplicationListener。
加入到this.applicationListeners中。
2、在Bean销毁之前搞事情： 如果Bean是一个ApplicationListener，
则会从ApplicationEventMulticaster(事件广播器)中提前删除了。
**/
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
//增加对aspectJ的支持在java中 织入分为编译期织入 运行期织入 加载期织入
//编译器织入指的是在java编译器采用特殊的编译器 将切面织入java类中
//而类加载器织入则是通过特殊的类加载器在字节码加载到jvm时织入切面
//运行期织入指的是cglib 或者 jdk 进行切面织入
//aspectJ提供了2种注入方式 编译期织入 运行期织入
//loadTimeWeaver 就是加载期织入
// Detect a LoadTimeWeaver and prepare for weaving, if found.
// 启用加载时织入,需要将@EnableLoadTimeWeaving加到配置类上
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor
(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(
new ContextTypeMatchClassLoader
(beanFactory.getBeanClassLoader()));
}
// Register default environment beans.
// 注入3个bean Environment SystemProperties SystemEnvironment
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}} ```
增加了2个BeanPostProcessor
1.ApplicationContextAwareProcessor
在postProcessBeforeInitialization 调用了invokeAwareInterfaces 在invokeAwareInterfaces中为bean注入Spring容器内置的对象
```java @Override @Nullable public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException { AccessControlContext acc = null; //判断是不是实现了一下六种接口 if (System.getSecurityManager() != null && (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware || bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware || bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) { acc = this.applicationContext.getBeanFactory().getAccessControlContext(); }
if (acc != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () ->
{invokeAwareInterfaces(bean); return null;}, acc);
}else {
//设置属性
invokeAwareInterfaces(bean);
}
return bean;} ```
2.ApplicationListenerDetector
5.3.0添加StandardBeanExpressionResolver
用于解析el表达式,#{}
★5.3.1添加ApplicationContextAwareProcessor
在postProcessBeforeInitialization 调用了ApplicationContextAwareProcessor#invokeAwareInterfaces
在invokeAwareInterfaces中为bean注入Spring容器内置的对象
```java @Override @Nullable public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException { AccessControlContext acc = null; //判断是不是实现了一下六种接口 不是就直接返回 if (System.getSecurityManager() != null && (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware || bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware || bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
acc = this.applicationContext.getBeanFactory().getAccessControlContext();
} if (acc != null) { AccessController.doPrivileged((PrivilegedAction
java /*** * 设置上下文组件 * @param bean */ private void invokeAwareInterfaces(Object bean) { if (bean instanceof Aware) { if (bean instanceof EnvironmentAware) { ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment()); } if (bean instanceof EmbeddedValueResolverAware) { ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver); } if (bean instanceof ResourceLoaderAware) { ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext); } if (bean instanceof ApplicationEventPublisherAware) { ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext); } if (bean instanceof MessageSourceAware) { ((MessageSourceAware) bean).setMessageSource(this.applicationContext); } if (bean instanceof ApplicationContextAware) { ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext); } } }
★5.3.2ignoreDependencyInterface
ApplicationContextAwareProcessor会处理
md /*** 设置忽略以下aware接口 因为下面的这5个aware接口已经通过上面注册的ApplicationContextAwareProcessor做了处理 需要在bean中注入内置对象 实现对应接口即可。 如果一个bean实现了传入ignoreDependencyInterface方法的这些感知接口，Spring是不允许外界注入任何的依赖到bean中的，只允许Spring容器内部调用感知接口的方法来注入相应的依赖。 具体可参考:https://blog.csdn.net/qq_36951116/article/details/99587519 反而是使用自动注入会报错 @Autowired ApplicationEventPublisherAware aware; */ beanFactory.ignoreDependencyInterface(EnvironmentAware.class); beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); beanFactory.ignoreDependencyInterface(MessageSourceAware.class); beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
5.3.3registerResolvableDependency
功能类似@Primary,但是比@Primary功能要强大。
registerResolvableDependency，指定了接口以及接口对应的依赖,设置了指定类型的自动装配对象。
这里指定了接口BeanFactory的实现类为当前的beanFactory。
ResourceLoader、ApplicationEventPublisher、ApplicationContext接口的实现类。
都为this也就是当前的对象,当前对象是谁？
是AnnotationConfigApplicationContext。
比如，你要从Spring容器中获取一个bean，恰好bean实现了接口ApplicationContext，此时就算你自己写了一个实现ApplicationContext接口的类注入到Spring容器中，Spring最终也会忽略掉你写的那个bean，而使用方法registerResolvableDependency中设置设置进去的beanFactory给你。
假设A接口有多个实现,如果项目现在使用的都是实现B，现在要改成实现C。
使用@Primary虽然方便但是是侵入式。但是如果使用registerResolvableDependency更灵活。
毕竟第三方的jar包里的类你没法用@Primary注解
java beanFactory.registerResolvableDependency(A.class, new C());
可以起到全局替换的作用。
registerResolvableDependency示例
java package orange; public interface MyComponent { }
java @org.springframework.stereotype.Component public class ComponentAImple implements MyComponent { private String mark = "a"; public ComponentAImple() { System.out.println(mark); } }
java package orange; @org.springframework.stereotype.Component public class ComponentBImple implements MyComponent { private String mark = "b"; public ComponentBImple() { System.out.println(mark); } }
```java package orange;
import org.springframework.context.annotation.*; import org.springframework.transaction.annotation.EnableTransactionManagement; import tyrant.Config;
@ComponentScan() @EnableAspectJAutoProxy(proxyTargetClass = true) @EnableTransactionManagement(mode = AdviceMode.PROXY) @Configuration public class BeanConfig { } ```
```java package orange;
import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.BeanFactoryPostProcessor; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
@org.springframework.stereotype.Component public class TestRegisterResolvableDependency implements BeanFactoryPostProcessor {
@Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { beanFactory.registerResolvableDependency (MyComponent.class, new ComponentBImple()); } } ```
```java package orange;
import org.springframework.context.annotation.*; import org.springframework.transaction.annotation.EnableTransactionManagement; import tyrant.Config;
@ComponentScan() @EnableAspectJAutoProxy(proxyTargetClass = true) @EnableTransactionManagement(mode = AdviceMode.PROXY) @Configuration public class BeanConfig {
} ```
```java package orange;
import com.ali.MyImport; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.ApplicationEventPublisherAware;
@org.springframework.stereotype.Component public class TestDependency {
@Autowired MyComponent component; @Autowired ApplicationEventPublisherAware aware; } ```
java package orange; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.context.annotation.AnnotatedBeanDefinitionReader; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import java.util.Map; public class TestOrangeCondition { public static void main(String[] args) { /** * 创建一个BeanDefinition读取器 根据注解读取 * 创建一个BeanDefinition扫描器 能够扫描一个类或者包 转换成bd **/ AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); //注册配置类 context.register(BeanConfig.class); context.refresh(); Class<?>[] interfaces = AopLog.class.getInterfaces(); TestDependency testDependency = context.getBean ("testDependency", TestDependency.class); //打印的是B System.out.println(testDependency.component); AopLog aopLog = context.getBean("aopLog",AopLog.class); aopLog.log(); } }
5.3.4添加BeanPostProcessor
ApplicationListenerDetector
不重要
5.3.5判断是否是加载期织入
我们常用的是运行期织入指的是cglib 或者 jdk 进行切面织入。
5.3.6注入3个环境变量
Environment
SystemProperties
SystemEnvironment
5.4postProcessBeanFactory:扩展点
```java // Allows post-processing of the bean factory in context subclasses. //扩展点 空实现 继承重写即可
/* spring中并没有具体去实现postProcessBeanFactory方法 是提供给想要实现BeanPostProcessor的三方框架使用的。 作用是在BeanFactory准备工作完成后做一些定制化的处理 一般结合BeanPostProcessor接口的实现类一起使用. 1.可以在这里注入一些重要资源(类似Application的属性和ServletContext的属性) 2.可以在这里做设置自动装配规则 3.可以在这里忽略指定的类型和接口自动装配 */ postProcessBeanFactory(beanFactory); ```
java protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { }
5.5invokeBeanFactoryPostProcessors(beanFactory)
既然我们在refresh方法中就可以通过继承空实现方法postProcessBeanFactory来修改beanFactory容器级别的信息，Spring为什么还要给我们提供接口BeanFactoryPostProcessor呢？
个人觉得，如果我们要修改beanFactory中的很多种信息，而且每种修改操作的逻辑都非常的复杂，这些逻辑势必会耦合在一个方法中，这样也不太好。
现在有了BeanFactoryPostProcessor接口之后，我们可以为每种修改操作分别创建一个类来实现接口BeanFactoryPostProcessor，这样的话至少在代码逻辑上是解耦的。
我们自定义的BeanFactoryPostProcessor即使实现了PriorityOrdered接口,不会在实现了PriorityOrdered第一级别被调用,只会在实现了Order接口的第二级别被调用。
原因:
第一次根据类型BeanFactoryPostProcessor和PriorityOrdered去找的时候只能找到内置的ConfigurationClassPostProcessor。
执行完内置的ConfigurationClassPostProcessor,会找到我们自定义的BeanFactoryPostProcessor！
第二次根据类型BeanFactoryPostProcessor和Ordered去找的时候,我们自定义的BeanFactoryPostProcessor实现了PriorityOrdered接口,所以他也是属于Ordered接口！然后就在Ordered级别被执行了！
```java protected void invokeBeanFactoryPostProcessors (ConfigurableListableBeanFactory beanFactory) { //getBeanFactoryPostProcessors 是获取自定义的 BeanFactoryPostProcessors //getBeanFactoryPostProcessors 获取到的默认是空 如果要添加 //扩展点 可以调用addBeanFactoryPostProcessors扩展 //重点是这里 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors (beanFactory, getBeanFactoryPostProcessors());
//加载时织入
if (beanFactory.getTempClassLoader() == null &&
beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor
(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader
(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}} ```
5.5.1invokeBeanFactoryPostProcessors
参数1:beanFactory
参数2:getBeanFactoryPostProcessors
5.5.1.1getBeanFactoryPostProcessors
首先从集合中获取beanFactoryPostProcessors,获取到的是一个空集合。
因为目前为止还没有向 beanFactoryPostProcessors添加过元素。
扩展点:可以调用AbstractApplicationContext#addBeanFactoryPostProcessor
java public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() { return this.beanFactoryPostProcessors; }
5.5.2 invokeBeanFactoryPostProcessors
运行到这里的时候 初始化完成的bean只有下面3个
systemEnvironment environment systemProperties
```java public static void invokeBeanFactoryPostProcessors( ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
// 无论是什么情况优先执行BeanDefinitionRegistry
// 将已经执行过的BFPP放入processedBeans 防止重复执行
Set<String> processedBeans = new HashSet<>();/********* BeanDefinitionRegistry开始 *******/
// 判断是否属于BeanDefinitionRegistry // BeanDefinitionRegistry是对beanDefinition进行增删改查的类 // 所有带Registry的类都是对Registry前面的类型进行增删改查的类 if (beanFactory instanceof BeanDefinitionRegistry) { //类型转换 BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory; //BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口 //BeanFactoryPostProcessor集合 List
regularPostProcessors = new ArrayList<>(); //BeanDefinitionRegistryPostProcessor集合 List
registryProcessors = new ArrayList<>();
//首先是从getBeanFactoryPostProcessors()方法中获取 然后分别加入不同的集合
//getBeanFactoryPostProcessors()是一个空集合
//因此这里不会执行
for (BeanFactoryPostProcessor postProcessor :
beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor
= (BeanDefinitionRegistryPostProcessor) postProcessor;
//注意这里会执行执行BeanDefinitionRegistryPostProcessor
registryProcessor.postProcessBeanDefinitionRegistry(registry);
//放入registryProcessors
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
//currentRegistryProcessors用于保存下面要执行的
//BeanDefinitionRegistryPostProcessor
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors
= new ArrayList<>();
//查找类型为BeanDefinitionRegistryPostProcessor的name
//只有1个//org.springframework.context.annotation.internalConfigurationAnnotationProcessor //org.springframework.context.annotation.ConfigurationClassPostProcessor String[] postProcessorNames = beanFactory.getBeanNamesForType (BeanDefinitionRegistryPostProcessor.class, true, false);
//遍历BeanDefinitionRegistryPostProcessor的name
//0.查找实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor
//1.getBean
//2.执行
for (String ppName : postProcessorNames) {
//查找实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//这里会执行doGetBean ！！！！
//这里会执行doGetBean ！！！！
//这里会执行doGetBean ！！！！
//这里会执行doGetBean ！！！！
//这里会执行doGetBean ！！！！
//beanFactory.getBean(ppName,
// BeanDefinitionRegistryPostProcessor.class)
//ConfigurationClassPostProcessor被创建了
//创建bean
currentRegistryProcessors
.add(
beanFactory.getBean(ppName,
BeanDefinitionRegistryPostProcessor.class));
//执行过就放入processedBeans
processedBeans.add(ppName);
}
}
//排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
//先放入registryProcessors
registryProcessors.addAll(currentRegistryProcessors);
//在执行currentRegistryProcessors中的BeanDefinitionRegistryPostProcessor
invokeBeanDefinitionRegistryPostProcessors
(currentRegistryProcessors, registry);
//清空currentRegistryProcessors
currentRegistryProcessors.clear();
//查找实现了Ordered接口的BeanDefinitionRegistryPostProcessor
postProcessorNames = beanFactory.getBeanNamesForType
(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) &&
beanFactory.isTypeMatch(ppName, Ordered.class)) {
//获取优先级第二高的 既实现了Ordered接口的
currentRegistryProcessors
.add(beanFactory.getBean
(ppName,BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
//执行
invokeBeanDefinitionRegistryPostProcessors
(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
//查找剩余的BeanDefinitionRegistryPostProcessor
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames
= beanFactory.getBeanNamesForType
(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
//最后获取没有实现Ordered和 PriorityOrdered的
currentRegistryProcessors
.add(beanFactory.getBean
(ppName,BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
//执行
invokeBeanDefinitionRegistryPostProcessors
(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
//可能会奇怪 registryProcessors中的 processors不是执行过吗?
//为什么还要再执行?
//因为BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子集
//上面执行的是BeanDefinitionRegistryPostProcessor
//这里是当做 BeanFactoryPostProcessor执行
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}else{
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}/********* BeanDefinitionRegistry结束 *******/
//查找类型为BeanFactoryPostProcessor的name
String[] postProcessorNames =
beanFactory.getBeanNamesForType
(BeanFactoryPostProcessor.class, true, false);
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors
= new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
//遍历已经执行过的Processor
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// 说明已经执行过了
}else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//在这里会实例化BeanFactoryPostProcessor
//实例化完毕分别调用
//BeanNameAware, BeanFactoryAware, ApplicationContextAware
//InitializingBean 的相关方法
//最后才调用BeanFactoryPostProcessor自己的postProcessBeanFactory方法
priorityOrderedPostProcessors
.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 执行实现了PriorityOrdered的BeanFactoryPostProcessor
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 执行实现了Ordered的BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String postProcessorName : orderedPostProcessorNames) {
//在这里会实例化BeanFactoryPostProcessor
//实例化完毕分别调用
//BeanNameAware, BeanFactoryAware, ApplicationContextAware
//InitializingBean 的相关方法
//最后才调用BeanFactoryPostProcessor自己的postProcessBeanFactory方法
orderedPostProcessors
.add(beanFactory.getBean(postProcessorName,
BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// 执行剩余的BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
//在这里会实例化BeanFactoryPostProcessor
//实例化完毕分别调用
//BeanNameAware, BeanFactoryAware, ApplicationContextAware
//InitializingBean 的相关方法
//最后才调用BeanFactoryPostProcessor自己的postProcessBeanFactory方法
nonOrderedPostProcessors
.add(beanFactory.getBean
(postProcessorName,BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
beanFactory.clearMetadataCache();} ```
5.5.2.1getBeanNamesForType
``` 1.遍历所有的beanDefinitionNames
2.首先从map缓存中获取 获取到直接返回
3.获取不到首先根据beanDefinitionName获取对应 beanDefinition
4.判断是否有父类,没有父类直接将当前BD包装返回一个RootBeanDefinition
5.有父类,继续递归调用getMergedBeanDefinition(String name)
先从缓存mergedBeanDefinitions中获取 如果获取不到判断是否有父类 没有父类
如果有父类 那么先合并父类的BD 如果父类还有父类 那么先合并爷爷类
等父类的BD都合并完毕 基于父类去合并bean的BD
具体做法是 基于父类 使用子类的属性覆盖父类的属性
比如 父类有A方法 B属性 C属性
子类有A方法 B属性 没有C属性
那么在覆盖的时候 子类A方法会覆盖父类A方法
那么在覆盖的时候 子类B属性会覆盖父类B属性
那么在覆盖的时候 子类没有C属性 父类有C属性 因为是直接基于父类构建所以子类也有C属性```
String[] postProcessorNames
= beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);根据类型BeanDefinitionRegistryPostProcessor查找对应的BeanDefinitionName,放入数组并返回。
```java @Override public String[]getBeanNamesForType(@Nullable Class> type,boolean includeNonSingletons,boolean allowEagerInit){ //!isConfigurationFrozen() true 直接进入 if(!isConfigurationFrozen()||type==null||!allowEagerInit){ return doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons,allowEagerInit); }
Map<Class<?>,String[]>cache=(includeNonSingletons?this.allBeanNamesByType:this.singletonBeanNamesByType);
String[]resolvedBeanNames=cache.get(type);
if(resolvedBeanNames!=null){
return resolvedBeanNames;
}
resolvedBeanNames=doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons,true);
if(ClassUtils.isCacheSafe(type,getBeanClassLoader())){
cache.put(type,resolvedBeanNames);
}
return resolvedBeanNames;} ```
1.遍历beanDefinitionNames即所有的beanDefinition,目前就6个。
2.判断是否有父类,没有父类直接返回beanDefinition即可。
3.有父类,继续递归调用getMergedBeanDefinition(String name)
5.5.2.1.1doGetBeanNamesForType
```java private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) { List result = new ArrayList<>(); /* this.beanDefinitionNames = {ArrayList@1160} size = 6 0 = "internalConfigurationAnnotationProcessor" 1 = "internalAutowiredAnnotationProcessor" 2 = "internalCommonAnnotationProcessor" 3 = "internalEventListenerProcessor" 4 = "internalEventListenerFactory" 5 = "beanConfig" */ //遍历5个spring自带的rootBeanDefinition for (String beanName : this.beanDefinitionNames) { // 判断是否是别名. if (!isAlias(beanName)) { try { //先从缓存mergedBeanDefinitions中获取 //如果获取不到判断是否有父类 没有父类 //直接返回一个RootBeanDefinition //如果有父类 那么先合并父类的BD 如果父类还有父类 那么先合并爷爷类 //等父类的BD都合并完毕 基于父类去合并bean的BD //具体做法是 基于父类 使用子类的属性覆盖父类的属性 //比如 父类有A方法 B属性 C属性 //子类有A方法 B属性 没有C属性 //那么在覆盖的时候 子类A方法会覆盖父类A方法 //那么在覆盖的时候 子类B属性会覆盖父类B属性 //那么在覆盖的时候 子类没有C属性 父类有C属性 //因为是直接基于父类构建所以子类也有C属性 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//非抽象
//allowEagerInit=false
//mbd.hasBeanClass()=true
//!mbd.isLazyInit() =true
//isAllowEagerClassLoading()=true
//requiresEagerInitForType(mbd.getFactoryBeanName()) = false
if (!mbd.isAbstract() && (allowEagerInit || (mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()) &&!requiresEagerInitForType(mbd.getFactoryBeanName()))) {
// 判断是否是factoryBean
boolean isFactoryBean = isFactoryBean(beanName, mbd);
BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
//不是Factory && 类型匹配
boolean matchFound =(allowEagerInit || !isFactoryBean ||dbd != null && !mbd.isLazyInit()) || containsSingleton(beanName)) &&(includeNonSingletons ||(dbd != null ? mbd.isSingleton() : isSingleton(beanName))) && isTypeMatch(beanName, type);
//如果类型不匹配 并且 是FactoryBean类型
if (!matchFound && isFactoryBean) {
beanName = FACTORY_BEAN_PREFIX + beanName;
//继续匹配一次
matchFound = (includeNonSingletons || mbd.isSingleton()) && isTypeMatch(beanName, type);
}
//如果类型匹配
if (matchFound) {
result.add(beanName);
}
}
}catch (CannotLoadBeanClassException ex) {
if (allowEagerInit) {
throw ex;
}
onSuppressedException(ex);
}catch (BeanDefinitionStoreException ex) {
if (allowEagerInit) {
throw ex;
}
onSuppressedException(ex);
}catch (NoSuchBeanDefinitionException ex) {
// Bean definition got removed while we were iterating -> ignore.
}
}
}
// Check manually registered singletons too.
/*
this.manualSingletonNames = {LinkedHashSet@1046} size = 3
0 = "environment"
1 = "systemProperties"
2 = "systemEnvironment"
*/
for (String beanName : this.manualSingletonNames) {
try {
// In case of FactoryBean, match object created by FactoryBean.
if (isFactoryBean(beanName)) {
if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) {
result.add(beanName);
continue;
}
// In case of FactoryBean, try to match FactoryBean itself next.
beanName = FACTORY_BEAN_PREFIX + beanName;
}
// Match raw bean instance (might be raw FactoryBean).
//判断类型是否匹配
if (isTypeMatch(beanName, type)) {
result.add(beanName);
}
}catch (NoSuchBeanDefinitionException ex) {
}
}
//返回1个 internalConfigurationAnnotationProcessor
return StringUtils.toStringArray(result);} ```
5.5.2.1.2getMergedLocalBeanDefinition
java protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException { // Quick check on the concurrent map first, with minimal locking. RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName); if (mbd != null) { return mbd; } //getBeanDefinition(beanName) 已经拿到了对应的BeanDefinition return getMergedBeanDefinition(beanName, getBeanDefinition(beanName)); }
```java protected RootBeanDefinition getMergedBeanDefinition( String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd) throws BeanDefinitionStoreException {
synchronized (this.mergedBeanDefinitions) {
//mergedBeanDefinition
RootBeanDefinition mbd = null;
// Check with full lock now in order to enforce the same merged instance.
//先从缓存mergedBeanDefinitions中获取
if (containingBd == null) {
mbd = this.mergedBeanDefinitions.get(beanName);
}
//缓存mergedBeanDefinitions中没有
if (mbd == null) {
//如果bd没有父类
if (bd.getParentName() == null) {
//clone RootBeanDefinition
if (bd instanceof RootBeanDefinition) {
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
} else {
mbd = new RootBeanDefinition(bd);
}
} else {
// Child bean definition: needs to be merged with parent.
BeanDefinition pbd;
try {
String parentBeanName = transformedBeanName(bd.getParentName());
if (!beanName.equals(parentBeanName)) {
pbd = getMergedBeanDefinition(parentBeanName);
} else {
BeanFactory parent = getParentBeanFactory();
if (parent instanceof ConfigurableBeanFactory) {
pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
} else {
throw new NoSuchBeanDefinitionException(parentBeanName,
"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
"': cannot be resolved without a ConfigurableBeanFactory parent");
}
}
} catch (NoSuchBeanDefinitionException ex) {
throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
}
// Deep copy with overridden values.
mbd = new RootBeanDefinition(pbd);
//mbd是父类合并后的RootBeanDefinition
//bd是本次要获取到的BeanDefinition
//基于合并的父类的ParentBeanDefinition
// 然后使用子类的属性去覆盖ParentBeanDefinition
//从而达到合并BeanDefinition的目的
mbd.overrideFrom(bd);
}
// Set default singleton scope, if not configured before.
if (!StringUtils.hasLength(mbd.getScope())) {
mbd.setScope(SCOPE_SINGLETON);
}
// A bean contained in a non-singleton bean cannot be a singleton itself.
// Let's correct this on the fly here, since this might be the result of
// parent-child merging for the outer bean, in which case the original inner bean
// definition will not have inherited the merged outer bean's singleton status.
if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
mbd.setScope(containingBd.getScope());
}
// Cache the merged bean definition for the time being
// (it might still get re-merged later on in order to pick up metadata changes)
if (containingBd == null && isCacheBeanMetadata()) {
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
return mbd;
}} ```
5.5.2.2处理BeanDefinitionRegistryPPNames
5.5.2.2.1遍历BeanDefinitionRegistryPPNames
5.5.2.2.2doGetBean创建BDRPP
5.5.2.2.3循环遍历执行BDRPP的方法
1.遍历上面返回的BeanDefinitionRegistryPostProcessorNames
2.doGetBean去创建BeanDefinitionRegistryPostProcessor
3.执行BeanDefinitionRegistryPostProcessor的processConfigBeanDefinitions方法
4.执行顺序:PriorityOrdered---》Ordered---》没有PriorityOrdered和Ordered
for (String ppName : postProcessorNames) {
//先放入优先级高的
//即实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//beanFactory.getBean(ppName,BeanDefinitionRegistryPostProcessor.class)
//这里会执行doGetBean 创建对应的BeanDefinitionRegistryPostProcessor！
//这里会执行doGetBean 创建对应的BeanDefinitionRegistryPostProcessor！
//这里会执行doGetBean 创建对应的BeanDefinitionRegistryPostProcessor！
//这里会执行doGetBean 创建对应的BeanDefinitionRegistryPostProcessor！
//这里会执行doGetBean 创建对应的BeanDefinitionRegistryPostProcessor！
currentRegistryProcessors.add(beanFactory.getBean(ppName,BeanDefinitionRegistryPostProcessor.class));
//提前加入已经执行过的集合processedBeans
processedBeans.add(ppName);
}
}
//排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
//先放入registryProcessors
registryProcessors.addAll(currentRegistryProcessors);
//再执行BeanDefinitionRegistryPostProcessor的
//postProcessBeanDefinitionRegistry方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//清空currentRegistryProcessors
currentRegistryProcessors.clear();5.5.2.3执行优先级最高的BDRPP
5.5.2.3.0执行ConfigurationClassPostProcessor
此处的BeanDefinitionRegistryPostProcessor只有一个即ConfigurationClassPostProcessor
进入ConfigurationClassPostProcessor#processConfigBeanDefinitions
```java public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) { List configCandidates = new ArrayList<>(); //当前registry就是DefaultListableBeanFactory //获取已经注册的BeanDefinitionName String[] candidateNames = registry.getBeanDefinitionNames(); / * 0="org.springframework.context.annotation.internalConfigurationAnnotationProcessor" 1="org.springframework.context.annotation.internalAutowiredAnnotationProcessor" 2="org.springframework.context.annotation.internalCommonAnnotationProcessor" 3 = "org.springframework.context.event.internalEventListenerProcessor" 4 = "org.springframework.context.event.internalEventListenerFactory" 5 = "beanConfig" */ //筛选被注解@Configuration @Component,@ComponentScan,@Import,@ImportResource修饰的BD //只有1个我们自己的配置类beanConfig for (String beanName : candidateNames) { //根据beanName获取BeanDefinition对象 BeanDefinition beanDef = registry.getBeanDefinition(beanName); / BeanDefinition中有这么一个变量 Map attributes = new LinkedHashMap<>(); 用来存储属性值，如果该attributes中存在configurationClass这个键 且对应的值是full或者lite,意味着已经处理过了，直接跳过。 后面处理BeanDefinition时会给bd设置一个属性 key为configurationClass，value为full或者lite */ if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) || ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) { //如果已经有FULL或者LITE说明被执行过 }
// checkConfigurationClassCandidate()会判断是否是一个配置类
// 并为BeanDefinition设置属性为lite或者full。
// 在这儿为BeanDefinition设置lite和full属性值是为了后面在使用
// 如果加了@Configuration，那么对应的BeanDefinition为full;
// 如果加了@Component,@ComponentScan,@Import,@ImportResource这些注解 // 或者有@Bean注解的方法 则为lite。
//lite和full均表示这个BeanDefinition对应的类是一个配置类
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
/*
GenericBeanDefinition:通用的bean实现.
自2.5以后新加入的bean文件配置属性定义类.
它是ChildBeanDefinition和RootBeanDefinition更好的替代者。
AnnotatedGenericBeanDefinition：存储@Configuration注解注释的类
ScannedGenericBeanDefinition：存储@Component、@Service、@Controller等注解注释的类
*/
// 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);
});
//获取命名生成器
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();
}
// 解析每个配置类
// 会创建一个ComponentScanAnnotationParser
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());
//目前configCandidates 配置类集合
//只有1个beanConfig:class [orange.BeanConfig]
do {
//ConfigurationClassParser#processConfigurationClass
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());
}
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();
}
}```
5.5.2.3.1遍历所有的BeanDefinition
0 = "org.springframework.context.annotation.internalConfigurationAnnotationProcessor"
1 = "org.springframework.context.annotation.internalAutowiredAnnotationProcessor"
2 = "org.springframework.context.annotation.internalCommonAnnotationProcessor"
3 = "org.springframework.context.event.internalEventListenerProcessor"
4 = "org.springframework.context.event.internalEventListenerFactory"
5 = "beanConfig"5.5.2.3.2判断BeanDefinition是否是配置类
//筛选被注解@Configuration @Component,@ComponentScan,@Import,@ImportResource 修饰的BD
//只有1个我们自己的配置类beanConfig5.5.2.3.3将符合条件的BeanDefinition排序
java configCandidates.sort((bd1, bd2) -> { int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition()); int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition()); return Integer.compare(i1, i2); });
5.5.2.3.4获取命名生成器
java 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(); }
5.5.2.3.5构建解析器
java ConfigurationClassParser parser = new ConfigurationClassParser( this.metadataReaderFactory, this.problemReporter, this.environment, this.resourceLoader, this.componentScanBeanNameGenerator, registry);
5.5.2.3.6解析配置类集合
```java Set
candidates = new LinkedHashSet<>(configCandidates); Set
alreadyParsed = new HashSet<>(configCandidates.size()); do { //解析的是一个集合 //将解析的集合加入parser的configurationClasses parser.parse(candidates); parser.validate(); //解析器中解析出来的配置类 Set
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()); } /
* 将下面这些配置类以及通过配置类的上的 @Import和 ImportBeanDefinitionRegistrar接口和@ImportResource导入的配置文件中 @Bean注解的方法 通过this.registry.registerBeanDefinition(beanName, beanDefToRegister); 加入BeanDefinitionMap 主要有下面的 beanName 'aop',Aop.class beanName 'aopLog', AopLog.class beanName 'transactionManager', MyPlatformTransactionManager.class beanName 'testRegisterResolvableDependency',
TestRegisterResolvableDependency.class beanName 'null', ProxyTransactionManagementConfiguration.class beanName 'beanConfig', orange.BeanConfig */ //加载configClasses中的definition this.reader.loadBeanDefinitions(configClasses); alreadyParsed.addAll(configClasses); //上面都解析完了 所以这里直接清除 candidates.clear(); //如果BeanDefinition 数量大于 候选配置类数量 if (registry.getBeanDefinitionCount() > candidateNames.length) { String[] newCandidateNames = registry.getBeanDefinitionNames(); Set
oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames)); Set
alreadyParsedClasses = new HashSet<>(); for (ConfigurationClass configurationClass : alreadyParsed) { alreadyParsedClasses.add (configurationClass.getMetadata().getClassName()); } //遍历新扫描的出来的newCandidateNames 判断是否是配置类 并且没有被解析 for (String candidateName : newCandidateNames) { if (!oldCandidateNames.contains(candidateName)) { BeanDefinition bd = registry.getBeanDefinition(candidateName); if (ConfigurationClassUtils .checkConfigurationClassCandidate (bd, this.metadataReaderFactory) && !alreadyParsedClasses.contains (bd.getBeanClassName())) { //如果是配置类 并且没有被解析过 那么放入candidates进入下一轮循环 candidates.add (new BeanDefinitionHolder(bd, candidateName)); } } } candidateNames = newCandidateNames; } } while (!candidates.isEmpty());
解析配置类集合的结构,伪代码
public void parse(Set<BeanDefinitionHolder> configCandidates) {
//循环遍历解析candidates
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
ConfigurationClass configClass = new ConfigurationClass
(bd.getMetadata(), holder.getBeanName())
//解析candidate以及candidate的父类
do {
sourceClass = doProcessConfigurationClass(configClass, sourceClass);
}while (sourceClass != null);
}
}```
```java public void parse(Set configCandidates) { //for循环 遍历解析 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) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
}
}
this.deferredImportSelectorHandler.process();
}```
java protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException { processConfigurationClass(new ConfigurationClass(metadata, beanName)); }
```java
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException { //判断是否需要跳过 比如有@Conditional注解就要跳过 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); } } // Recursively process the configuration class and its superclass hierarchy. SourceClass sourceClass = asSourceClass(configClass); do { //真正解析的地方 sourceClass = doProcessConfigurationClass(configClass, sourceClass); } while (sourceClass != null); this.configurationClasses.put(configClass, configClass); } ```
5.5.2.3.7真正解析配置类parse
```java @Nullable 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); } /* 处理@PropertySource 使用@PropertySource加载配置文件 对于这种加载自定义配置文件的需求 可以使用@PropertySource注解结合@Configuration注解配置类的方式来实现。 @PropertySource注解用于指定自定义配置文件的具体位置和名称。 同时，为了保证Spring Boot能够扫描该注解 还需要类上添加@Configuration注解将实体类作为自定义配置类。 */ for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable( sourceClass.getMetadata(), PropertySources.class, org.springframework.context.annotation.PropertySource.class)) { if (this.environment instanceof ConfigurableEnvironment) { processPropertySource(propertySource); } else { } }
//处理 @ComponentScan注解
//获取配置类上的@ComponentScan注解属性
Set<AnnotationAttributes> componentScans =
AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(),
ComponentScans.class,
ComponentScan.class);
if (!componentScans.isEmpty() &&
!this.conditionEvaluator.shouldSkip
(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
//处理@ComponentScan注解属性
for (AnnotationAttributes componentScan : componentScans) {
//配置类上有@ComponentScan,立刻扫描
//构造一个Classpath扫描器 解析BasePackage获取需要扫描的包
// 然后根据classpath扫描器中的过滤器进行过滤
// 如果include过滤器返回的是true && exclude过滤器返回的是false
//那么就加入candidates并返回
Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan,
sourceClass.getMetadata().getClassName());
//扫描的是所有的class 返回的并不是所有的
//首先beanConfig配置类会被排除,因为注册了一个beanConfig的排除过滤器
//没有加@Conponent的也会被排除 排除了 TestOrangeCondition 和 Mybean
//因此剩下了4个
/**
0 = Aop.class
1 = AopLog.class
4 = MyPlatformTransactionManager.class
6 = TestRegisterResolvableDependency.class
*/
//遍历扫描到的BeanDefinitions 判断是否需要解析
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition()
.getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
//判断是否属于候选类
//判断是否存在@Configuration注解
//判断是否存在@Bean修饰的方法
/*
candidateIndicators.add(Component.class.getName());
candidateIndicators.add(ComponentScan.class.getName());
candidateIndicators.add(Import.class.getName());
candidateIndicators.add(ImportResource.class.getName());
*/
if (ConfigurationClassUtils
.checkConfigurationClassCandidate(bdCand,
this.metadataReaderFactory)) {
//解析 解析出来的BeanDefinition
//这里是一个递归处理 又进入了processConfigurationClass方法
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// Process any @Import annotations
// getImports(sourceClass) 获取所有带@Import注解的类
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);
}
}
// 处理 @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;} ```
5.5.2.3.7.1递归解析配置类的内部类
1.判断内部类是不是配置类
2.for循环遍历解析内部类
3.如果内部类还有内部类继续递归处理
java 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); //1)出现配置类循环导入,直接报错 for (SourceClass candidate : candidates) { if (this.importStack.contains(configClass)) { this.problemReporter.error(new CircularImportProblem(configClass, this.importStack)); } else { //将配置类入栈 this.importStack.push(configClass); try { // 递归调用processConfigurationClass方法，也许内部类还有内部类 //其实，工作中我们不会内部类嵌套内部类再嵌套内部类再嵌套。。。 processConfigurationClass (candidate.asConfigClass(configClass)); } finally { //解析完出栈 this.importStack.pop(); } } } } }
5.5.2.3.7.2处理@PropertySource配置文件
1.获取配置类的@PropertySource
2.读取@PropertySource的value属性对应的配置文件键值
3.将键值放入environment
java // Process any @PropertySource annotations /** 使用@PropertySource加载配置文件对于这种加载自定义配置文件的需求，可以使用@PropertySource注解结合@Configuration注解配置类的方式来实现。 @PropertySource注解用于指定自定义配置文件的具体位置和名称。 同时，为了保证Spring Boot能够扫描该注解，还需要类上添加@Configuration注解将实体类作为自定义配置类。 */ for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable( sourceClass.getMetadata(), PropertySources.class, org.springframework.context.annotation.PropertySource.class)) { if (this.environment instanceof ConfigurableEnvironment) { /** 只能加载指定格式的属性文件(如*.properties,必须是key=value。yaml格式的解析的可能有问题) 到 Spring 的 Environment 中。可以配合 @Value 和@ConfigurationProperties 使用。 @PropertySource 和 @Value 组合使用，可以将自定义属性文件中的属性变量值注入到当前类的使用@Value注解的成员变量中。 @PropertySource 和 @ConfigurationProperties 组合使用，可以将属性文件与一个Java类绑定，将属性文件中的变量值注入到该Java类的成员变量中。 这里主要是加载读取配置文件(*.properties)中的key value populateBean() -> AutowiredAnnotationBeanPostProcessor对象后置处理 -> postProcessProperties()后置处理属性会用到 */ processPropertySource(propertySource); }else { //rz日志 } } //只能加载指定格式的属性文件(如*.properties,必须是key=value。yaml格式的就不行) //观察处理完配置文件以后的environment Environment environment = this.environment;
5.5.2.3.7.3递归处理@CompentScan
处理@CompentScan/@CompentScans
1.获取配置类上的@CompentScan/@CompentScans
2.构造一个Classpath扫描器
注册一个类型过滤器@Component,@Component包含 @Controller @Repository @Service。
注册一个排他过滤器,排除当前正在解析的配置类
3.获取并解析BasePackage属性 获取需要扫描的包
4.根据classpath扫描器中的过滤器对需要扫描的包进行扫描和过滤
5.如果是@Component\@Controller @Repository @Service且不是配置类本身
6.读取Lazy Primary DependsOn Role Description属性
7.最后加入集合scannedBeanDefinitions
8.遍历scannedBeanDefinitions
9.递归解析扫描出来的scannedBeanDefinitions
```java // Process any @ComponentScan annotations //获取配置类上的@ComponentScan注解属性 Set 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 //构造一个Classpath扫描器 注册了1个类型过滤器@Component,@Component包含 @Controller @Repository @Service // 获取并解析BasePackage属性 获取需要扫描的包 // 然后根据classpath扫描器中的过滤器进行过滤 // 如果include过滤器返回的是true && exclude过滤器返回的是false //那么就加入candidates并返回 Set scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName()); // Check the set of scanned definitions for any further config classes and parse recursively if needed //扫描的是所有的class 返回的并不是所有的 //首先beanConfig配置类会被排除,因为注册了一个beanConfig的排除过滤器 //没有加@Conponent的也会被排除 排除了 TestOrangeCondition 和 Mybean //因此剩下了4个 / * 0 = Aop.class 1 = AopLog.class 4 = MyPlatformTransactionManager.class 6 = TestRegisterResolvableDependency.class */ //遍历扫描到的BeanDefinitions 判断是否需要解析 for (BeanDefinitionHolder holder : scannedBeanDefinitions) { BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition(); if (bdCand == null) { bdCand = holder.getBeanDefinition(); } //判断是否属于候选类 //判断是否存在@Configuration注解 //判断是否存在@Bean修饰的方法 //判断是否被下面这些注解修饰过 //如果是继续被当成配置类解析 / candidateIndicators.add(Component.class.getName()); candidateIndicators.add(ComponentScan.class.getName()); candidateIndicators.add(Import.class.getName()); candidateIndicators.add(ImportResource.class.getName()); */ if (ConfigurationClassUtils.checkConfigurationClassCandidate (bdCand, this.metadataReaderFactory)) { //解析 解析出来的BeanDefinition //这里是一个递归处理 又进入了processConfigurationClass方法 parse(bdCand.getBeanClassName(), holder.getBeanName()); } } } } ```
```java
public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
/*
注册了3个类型过滤器 这也是为什么可以扫描到下面这些注解的原因
其中 @Component 包含 @Controller @Repository @Service
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
//但是下面2个因为没有添加相关依赖 所以并不会加入对应的filter
this.includeFilters.add(javax.inject.ManagedBean)
this.includeFilters.add(javax.inject.Named)
*/
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
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"));
//这里也是一个扩展点 可以指定includeFilters属性来扫描自定义的注解
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<>();
//获取basePackages属性
String[] basePackagesArray = componentScan.getStringArray("basePackages");
for (String pkg : basePackagesArray) {
//解析basePackage中的 ,; \t\n
//解析成数组格式
String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
//加入basePackages
Collections.addAll(basePackages, tokenized);
}
//获取basePackageClasses属性
for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
basePackages.add(ClassUtils.getPackageName(clazz));
}
//取当前配置类所在的包 SpringBoot就是这么干的 解析当前包以及当前包下的子包
if (basePackages.isEmpty()) {
basePackages.add(ClassUtils.getPackageName(declaringClass));
}
//这行代码的意思增加一个排他过滤器，配置类本身不需要添加到容器中，他只是用作解析。
//declaringClass 就是 orange.BeanConfig
scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
@Override
protected boolean matchClassName(String className) {
return declaringClass.equals(className);
}
});
//doScan返回的是当前类的父类
return scanner.doScan(StringUtils.toStringArray(basePackages));
}```
```java
protected Set doScan(String... basePackages) { Assert.notEmpty(basePackages, "At least one base package must be specified"); Set beanDefinitions = new LinkedHashSet<>(); for (String basePackage : basePackages) { //根据basePackage 去扫描下面的所有的class //然后根据classPath解析器中注册的过滤器过滤 //include过滤器返回true exclude过滤器返回false //那么就加入candidates并返回 //循环遍历candidates 读取Lazy Primary DependsOn Role Description属性 放入对应的BD Set candidates = findCandidateComponents(basePackage); for (BeanDefinition candidate : candidates) { ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate); candidate.setScope(scopeMetadata.getScopeName()); String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry); if (candidate instanceof AbstractBeanDefinition) { postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName); } //读取Lazy Primary DependsOn Role Description属性 放入对应的BD if (candidate instanceof AnnotatedBeanDefinition) { AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate); } //如果存在同名beanName 的BD 使用? if (checkCandidate(beanName, candidate)) { BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName); definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); beanDefinitions.add(definitionHolder); registerBeanDefinition(definitionHolder, this.registry); } } } return beanDefinitions; } ```
5.5.2.3.7.4递归处理@Import
@Import注解注入Bean的解析方式有如下三种
- 作为Configuration Class被解析
- 作为ImportSelector\&DeferredImportSelector接口的实现类被解析
- 作为ImportBeanDefinitionRegistrar接口的实现类被解析
ImportSelector、DeferredImportSelector、ImportBeanDefinitionRegistrar都必须依赖于@Import一起使用，而@Import可以单独使用.
基于ImportSelector接口和ImportBeanDefinitionRegistrar接口的方式都可以从方法上获取AnnotationMetadata(注解元信息)，那么基于Configuration Class的方式该如何获取AnnotationMetadata呢？
只需要实现ImportAware就可以了。
java public class MyImportAware implements ImportAware { @Override public void setImportMetadata(AnnotationMetadata importMetadata) { System.out.println(1); } }
接下来使用1个案例说明
```java package importselector;
import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.EnableAspectJAutoProxy; import org.springframework.context.annotation.Import;
@Import({AopLog.class,DopLog.class}) @EnableAspectJAutoProxy(proxyTargetClass = false) @ComponentScan() public class BeanConfig {
} ```
```java package importselector; import org.springframework.context.annotation.Import; @Import(BopLog.class) public class AopLog {
} ```
```java package importselector;
import org.springframework.context.annotation.Import;
@Import(CopLog.class) public class BopLog {
} ```
```java package importselector;
public class CopLog {
} ```
java package importselector; import org.springframework.context.annotation.Import; public class DopLog { }
processImports(configClass, sourceClass, getImports(sourceClass), true);`
getImports(sourceClass)返回sourceClass上被@Import导入的类
1.for循环判断这些类
2.实现了ImportSelector接口,会先实例化。
3.然后判断具体实现的是DeferredImportSelector接口还是ImportSelector接口。
4.如果实现的是DeferredImportSelector接口,将DeferredImportSelector封装为DeferredImportSelectorHolder加入当前配置类ConfigurationClass的集合deferredImportSelectorHandler延迟处理。
5.如果实现的是ImportSelector接口,直接调用ImportSelector接口的selectImports方法。
遍历selectImports方法导入的类名,递归调用processImports()
6.在每次parse方法结束后调用this.deferredImportSelectorHandler.process();
最后调用deferredImportSelector的selectImports方法获取所有被导入的类,然后递归调用
processImports();将导入的类当做配置类处理。
7.实现了ImportBeanDefinitionRegistrar接口,会先实例化,然后会把实例作为key,当前配置类的注解元数据作为value加入到当前配置类ConfigurationClass的Map集合importBeanDefinitionRegistrars。
最后统一在loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());处理！
8.@Import注解导入的普通类被当做配置类和配置类一起处理:
处理的入口:this.reader.loadBeanDefinitions(configClasses);
1.循环遍历配置类调用以下方法:
loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
2.判断配置类是否被@Import注解导入的,如果是注入对应的bd
3.遍历配置类中带有@Bean的方法,注入对应的bd
4.处理ImportedResource,
先从配置类获取importedResources
通过reader.loadBeanDefinitions(resource)加载bd,
5.处理ImportBeanDefinitionRegistrar:
从配置类先获取ImportBeanDefinitionRegistrars集合
先遍历Map集合importBeanDefinitionRegistrars
获取实例和当前配置类的注解元数据
通过实例调用registerBeanDefinitions方法,将元数据和this.registry作为参数传入
具体实现:
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
入口方法:
```java
// sourceClass是AopConfig
// getImports(sourceClass)递归获取的是:
// AopConfig上所有被@Import注解导入的类AopLog BopLog
processImports(configClass, sourceClass, getImports(sourceClass), true);先看getImports:递归调用获取sourceClass上所有被@Import导入的类
java private Set<SourceClass> getImports(SourceClass sourceClass) throws IOException { Set<SourceClass> imports = new LinkedHashSet<>(); Set<SourceClass> visited = new LinkedHashSet<>(); //递归调用获取所有被@Import导入的类 collectImports(sourceClass, imports, visited); return imports; }
```java private void collectImports(SourceClass sourceClass, Set imports, Set visited) throws IOException {
if (visited.add(sourceClass)) {
/***
获取配置类AopConfig上的注解
@Import({AopLog.class,DopLog.class})
@EnableAspectJAutoProxy(proxyTargetClass = false)
@ComponentScan()
循环遍历判断是否是@Import
如果不是,那么递归调用collectImports(annotation, imports, visited);
0.for循环开始
1.@Import({AopLog.class,DopLog.class})不符合条件跳过
2.@EnableAspectJAutoProxy(proxyTargetClass = false)符合条件
-递归进入collectImports(annotation, imports, visited);
-EnableAspectJAutoProxy上有注解@Import(AspectJAutoProxyRegistrar.class)
-不符合条件
-将AspectJAutoProxyRegistrar加入imports返回
3.@ComponentScan()符合条件但是没有导入任何类 直接返回
4.for循环结束
5.将AopLog和DopLog加入集合imports返回
result:
0 = AspectJAutoProxyRegistrar
1 = AopLog
2 = DopLog
***/
for (SourceClass annotation : sourceClass.getAnnotations()) {
String annName = annotation.getMetadata().getClassName();
if (!annName.equals(Import.class.getName())) {
//如果不是@Import注解 递归调用处理collectImports
collectImports(annotation, imports, visited);
}
}
//将@Import注解导入的类返回
imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value"));
}} ```
```java private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,Collection importCandidates, boolean checkForCircularImports) {
if (importCandidates.isEmpty()) {
return;
}
//检测Import循环依赖
if (checkForCircularImports && isChainedImportOnStack(configClass)) {
this.problemReporter.error(new CircularImportProblem(configClass,
this.importStack));
}else {
this.importStack.push(configClass);
try {
//遍历的importCandidates 是@Import导入的类集合
for (SourceClass candidate : importCandidates) {
//如果导入的类是实现了ImportSelector接口
if (candidate.isAssignable(ImportSelector.class)) {
// 处理 ImportSelector
Class<?> candidateClass = candidate.loadClass();
//实例化
ImportSelector selector = BeanUtils.instantiateClass
(candidateClass, ImportSelector.class);
//设置aware接口相关属性
ParserStrategyUtils.invokeAwareMethods(
selector,
this.environment,
this.resourceLoader,
this.registry);
//判断是否是DeferredImportSelector 延迟加载的selector
if (selector instanceof DeferredImportSelector) {
//会在每次parse方法结束后调用
//this.deferredImportSelectorHandler.process();
//最后调用deferredImportSelector的selectImports
this.deferredImportSelectorHandler.handle
(configClass, (DeferredImportSelector) selector);
}else {
//否则就是ImportSelector 立即加载的selector
//普通的ImportSelector ,执行其selectImports方法
//获取需要导入的类的全限定类名数组
//事务对应的处理类
//TransactionManagementConfigurationSelector
//就是在这里
String[] importClassNames
= selector.selectImports
(currentSourceClass.getMetadata());
//遍历selectImports方法导入的类名
Collection<SourceClass> importSourceClasses
= asSourceClasses(importClassNames);
// 递归调用作为配置类解析
processImports(configClass,
currentSourceClass,
importSourceClasses, false);
}
}
else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
// 处理实现ImportBeanDefinitionRegistrar接口的类
Class<?> candidateClass = candidate.loadClass();
//实例化
ImportBeanDefinitionRegistrar registrar =
BeanUtils.instantiateClass
(candidateClass, ImportBeanDefinitionRegistrar.class);
//设置aware接口对应属性
ParserStrategyUtils.invokeAwareMethods
(registrar,
this.environment,
this.resourceLoader,
this.registry);
//只是加入了集合中
//只是加入了集合中
//只是加入了集合中
//统一在loadBeanDefinitionsFromRegistrars
// (configClass.getImportBeanDefinitionRegistrars());
//进行处理
configClass.addImportBeanDefinitionRegistrar
(registrar, currentSourceClass.getMetadata());
}else {
//如果导入的类
//既没有实现ImportSelector接口
//也没有实现ImportBeanDefinitionRegistrar接口
//也就是ImportSelector和ImportBeanDefinitionRegistrar都没实现
//导入的类一定会被当做配置类解析
// Candidate class not an ImportSelector or
//ImportBeanDefinitionRegistrar ->
// process it as an @Configuration class
// 当成是普通 @Configuration class处理
this.importStack.registerImport(
currentSourceClass.getMetadata(),
candidate.getMetadata().getClassName());
// 解析导入的@Configuration class
processConfigurationClass
(candidate.asConfigClass(configClass));
}
}
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to process import candidates for configuration class [" +
configClass.getMetadata().getClassName() + "]", ex);
}
finally {
this.importStack.pop();
}
}} ```
5.5.2.3.7.5处理@ImportResource注解
只是将解析出来的配置文件加入了configClass
java //处理@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的集合中 //最后统一在loadBeanDefinitionsFromImportedResources // (configClass.getImportedResources()); //进行处理 configClass.addImportedResource(resolvedResource, readerClass); } }
java public void addImportedResource(String importedResource, Class<? extends BeanDefinitionReader> readerClass) { this.importedResources.put(importedResource, readerClass); }
5.5.2.3.7.6处理加了@Bean的方法
java Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass); //只是解析了加了@Bean的方法 封装为MethodMetadata 加入configClass for (MethodMetadata methodMetadata : beanMethods) { configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass)); }
5.5.2.3.7.7递归处理接口@Bean默认方法
java // Process default methods on interfaces //处理接口中带@Bean的default方法 processInterfaces(configClass, sourceClass);
5.5.2.3.7.8如果配置类有父类,返回配置类的父类
如果配置类有父类 返回配置类的父类 继续do While
java //判断配置类是否有父类 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;
5.2.3.8this.reader.loadBeanDefinitions(configClasses);
```java
//解析的是一个集合 parser.parse(candidates); parser.validate(); //将解析过的Classe移除 Set
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()); } /
* 将下面这些配置类以及这些配置类 通过 ImportBeanDefinitionRegistrar和ImportedResource和 Import 接口导入的类 以及 @Bean注解的方法 通过 this.registry.registerBeanDefinition (beanName, beanDefToRegister); 加入BeanDefinitionMap beanName 'aop',Aop.class beanName 'aopLog', AopLog.class beanName 'transactionManager', MyPlatformTransactionManager.class beanName 'testRegisterResolvableDependency',
TestRegisterResolvableDependency.class beanName 'null', ProxyTransactionManagementConfiguration.class beanName 'beanConfig', orange.BeanConfig */ this.reader.loadBeanDefinitions(configClasses); ```
```java public void loadBeanDefinitions(Set configurationModel) { TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator(); for (ConfigurationClass configClass : configurationModel) { loadBeanDefinitionsForConfigurationClass (configClass, trackedConditionEvaluator); } }
```
```java 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;
}
if (configClass.isImported()) {
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
//处理@Bean对应的方法
//将他们注册到beanDefinitionMap中
//其实是注册了一个bean
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
loadBeanDefinitionsForBeanMethod(beanMethod);
}
//导入ImportedResources
//解析文件导入beanDefinition
loadBeanDefinitionsFromImportedResources
(configClass.getImportedResources());
//导入Registrars
loadBeanDefinitionsFromRegistrars
(configClass.getImportBeanDefinitionRegistrars());} ```
切面是在这里导入的AspectJAutoProxyRegistrar,从而注册了AnnotationAwareAspectJAutoProxyCreator
5.5.2.4执行优先级第二高的BDRPP
没有 跳过
5.5.2.5执行优先级最低的BDRPP
没有 跳过
5.5.2.6执行ConfigurationClassPP
这里是把是BeanDefinitionRegistryPostProcessor当做 BeanFactoryPostProcessor执行
```java while (reiterate) { reiterate = false; postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { if (!processedBeans.contains(ppName)) { //最后获取没有实现Ordered和 PriorityOrdered的 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.
//可能会奇怪 registryProcessors中的 processors不是执行过吗？
//为什么还要在执行？
//因为BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子集
//上面执行的是BeanDefinitionRegistryPostProcessor 这里是当做 BeanFactoryPostProcessor执行
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
//执行的是真正的BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);} ```
此处只有一个即ConfigurationClassPostProcessor
ConfigurationClassPostProcessor实现了BeanDefinitionRegistryPostProcessor
BeanDefinitionRegistryPostProcessor 是 BeanFactoryPostProcessor的子接口
上面是作为BeanDefinitionRegistryPostProcessor 处理
这里是作为BeanFactoryPostProcessor处理
进入ConfigurationClassPostProcessor#postProcessBeanFactory
执行顺序:PriorityOrdered---》Ordered---》没有PriorityOrdered和Ordered
java @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { System.out.println("tyrant postProcessBeanFactory"); int factoryId = System.identityHashCode(beanFactory); if (this.factoriesPostProcessed.contains(factoryId)) { throw new IllegalStateException("postProcessBeanFactory already called on this post-processoragainst " + beanFactory); } this.factoriesPostProcessed.add(factoryId); if (!this.registriesPostProcessed.contains(factoryId)) { // BeanDefinitionRegistryPostProcessor hook apparently not supported... // Simply call processConfigurationClasses lazily at this point then. processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory); } //用于增强配置类 给FULL类型的配置类BD增加2个增强回调 enhanceConfigurationClasses(beanFactory); //这里注册了一个ImportAwareBeanPostProcessor 也是一个BeanPostProcessor //用于处理实现了ImportAware接口并且带有@Configuration的类 beanFactory.addBeanPostProcessor (new ImportAwareBeanPostProcessor(beanFactory)); }
5.5.2.6执行优先级最高的BFPP
没有跳过
5.5.2.7执行优先级第二高的BFPP
没有跳过
5.5.2.9执行优先级最低的BFPP
5.5.2.8.1EventListenerMethodProcessor
java @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { this.beanFactory = beanFactory; Map<String, EventListenerFactory> beans = beanFactory.getBeansOfType(EventListenerFactory.class, false, false); List<EventListenerFactory> factories = new ArrayList<>(beans.values()); AnnotationAwareOrderComparator.sort(factories); this.eventListenerFactories = factories; }
5.2.8.2.2TestRegisterResolvableDependency
自定义的BeanFactoryPostProcessor
java @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { beanFactory.registerResolvableDependency(MyComponent.class, new ComponentBImple()); }
3500
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
