ApplicationContextConfiguration为核心配置类
ApplicationContext applicationContext =
new AnnotationConfigApplicationContext(ApplicationContextConfiguration.class);
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this(); // 实例化IOC容器
register(annotatedClasses);
refresh();
}
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this(); // 实例化IOC容器
// 获取核心配置类注解，获取注解元数据，封装成BeanDefinition，放入IOC容器
register(annotatedClasses);
refresh();
}
定义的BeanDefinitionReader，调用doRegisterBean
1、通过class.getAnnotations,获取核心配置类上的所有注解
2、解析核心配置类上的注解元数据，判断是singleton还是prototype
3、判断是否需要scope代理
4、将核心配置类，封装成的BeanDefinition，注册到IOC容器的BeanDefinitionMap中
<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(instanceSupplier);
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
if (qualifiers != null) {
for (Class<? extends Annotation> qualifier : qualifiers) {
if (Primary.class == qualifier) {
abd.setPrimary(true);
}
else if (Lazy.class == qualifier) {
abd.setLazyInit(true);
}
else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
customizer.customize(abd);
}
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this(); // 实例化IOC容器
register(annotatedClasses);
refresh();
}
调用refresh方法
1、刷新前预处理
2、获取之前创建的BeanFactory，默认实现DefaultListableBeanFactory
3、BeanFactory的预准备⼯作（BeanFactory进⾏⼀些设置，设置类加载器，默认的BeanPostProcess，环境等等。
4、invokeBeanFactoryPostProcessors(beanFactory); 实例化并调用默认配置，和自定义的BeanFactoryPostProcessor,实现核心配置类解析，包组件扫描封装BeanDefinition.
4.1、调用ConfigurationClassPostProcessor，处理@Configuration 定义的类，
注意：此时IOC容器的BeanDefinitionMap中只有核心配置类ApplicationContextConfiguration标识了@Configuration，因为首先识别的是核心配置类，因此以核心配置类为起点，进行解析。
（调用实现了PriorityOrdered的BeanDefinitionRegistryPostProcessors，例如ConfigurationClassPostProcessor）
4.1.1、@Configuration配置类解析流程
4.2、调用实现了Order的BeanDefinitionRegistryPostProcessors
4.3、调用实现剩余的其它全部BeanDefinitionRegistryPostProcessors
4.4、获取所有实现了BeanFactoryPostProcessor的后置处理器，通过PriorityOrdered-》Order-》Other 依次调用（先反射实例化，放入Spring一级缓存池中（单例池），然后调用对应的方法）
而我们自己实现BeanFactoryPostProcessor，在这里被实例化，并调用
5、registerBeanPostProcessors(beanFactory); 注册默认的，自定义的BeanPostProcessor，实现Bean-init前后的调用。注册顺序PriorityOrdered-》Order-》Other
6、initMessageSource(); 初始化MessageSource组件（做国际化功能；消息绑定，消息解析）
7、initApplicationEventMulticaster(); 初始化事件派发器
8、onRefresh(); ⼦类重写这个⽅法，在容器刷新的时候可以⾃定义逻辑
9、registerListeners(); 注册监听器，就是注册实现了ApplicationListener接⼝的监听器
10、finishBeanFactoryInitialization(beanFactory); 实例化所有单例bean，放入一级缓存池中
11、finishRefresh(); 完成context的刷新。主要是调⽤LifecycleProcessor的onRefresh()⽅法，并且发布事件（ContextRefreshedEvent）
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 刷新前预处理
prepareRefresh();
// 获取之前创建的BeanFactory，默认实现DefaultListableBeanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// BeanFactory的预准备⼯作（BeanFactory进⾏⼀些设置，设置类加载器，环境等等。
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// 实例化并调用默认配置，和自定义的BeanFactoryPostProcessor,实现核心配置类解析，包组件扫描封装BeanDefinition.
invokeBeanFactoryPostProcessors(beanFactory);
// 注册默认配置的和自定义的BeanPostProcessor , 实现bean创建赋值之后 init 方法前后调用
registerBeanPostProcessors(beanFactory);
// 初始化MessageSource组件，实现 国际化功能，消息绑定，消息解析
initMessageSource();
// 初始化应用事件派发器
initApplicationEventMulticaster();
// 子类重写
onRefresh();
// 注册实现了ApplicationListener接⼝的监听器
registerListeners();
// 实例化剩下的所有单例bean
finishBeanFactoryInitialization(beanFactory);
// 发布事件，交由其它组件触发对应响应，例如springMVC初始化
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
1、创建IOC容器，并实例化BeanDefinitionReader，BeanDefinitionScanner
2、通过BeanDefinitionReader，简单解析核心配置类，注册到IOC容器的BeanDefiniton中
3、调用refresh方法