AnnotationConfigApplicationContext容器初始化目錄
(Spring源碼分析)AnnotationConfigApplicationContext容器初始化 this() && register()
(Spring源碼分析)AnnotationConfigApplicationContext容器初始化 refresh()#invokeBeanFactoryPostProcessors
(Spring源碼分析)AnnotationConfigApplicationContext容器初始化 refresh()#registerBeanPostProcessors
(Spring源碼分析)AnnotationConfigApplicationContext容器初始化 refresh()#finishBeanFactoryInitialization
目錄
- 使用AnnotationConfigApplicationContext容器
- AppConfig配置類
- AnnotationConfigApplicationContext容器方法
- 1、this()
- 2、register(annotatedClasses)
- 2.1、this.reader.register(annotatedClasses)
- 2.1.1、registerBean(annotatedClass)
- 2.1.1.1、doRegisterBean(annotatedClass, null, null, null)
- 2.1.1.1.1、BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry)
- 2.1.1.1.1.1、registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition())
使用AnnotationConfigApplicationContext容器
public static void main(String[] args) {
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
TestService testService = applicationContext.getBean(TestService.class);
System.out.println(testService.sout());
}
AppConfig配置類
@Configuration
@ComponentScan("com.wyj.learning.build.applicationcontext")
public class AppConfig {
}
AnnotationConfigApplicationContext容器方法
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
這段代碼會調用AnnotationConfigApplicationContext類的無參構造方法
/**
* 這個構造方法需要傳入一個javaconfig註解了的配置類
* 然後會把這個被註解了javaconfig的類通過註解讀取器讀取後繼而解析
*/
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
// 這裏由於他有父類,故而會先調用父類的無參構造方法,然後纔會調用自己的無參構造方法
// 在自己構造方法中初始一個讀取器和掃描器
this();
register(annotatedClasses); // 這裏僅僅只是將annotatedClasses作爲bean放入beanDefinitionMap中
refresh(); // AnnotationConfigApplicationContext容器中最重要的方法,將annotatedClasses中掃描的bean加入beanDefinitionMap中
}
1、this()
this()方法主要是初始化BeanFactory容器
在AnnotationConfigApplicationContext
父類GenericApplicationContext
的無參構造方法中
/**
* 初始化BeanFactory
*/
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}
然後執行AnnotationConfigApplicationContext
自己的無參構造方法
/**
* 初始化註解讀取器和掃描器
*/
public AnnotationConfigApplicationContext() {
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
2、register(annotatedClasses)
register(annotatedClasses)方法主要是將傳入的配置類加入到BeanDefinitionMap中,但是配置類中配置的包掃描路徑下的bean並沒有添加到BeanDefinitionMap中
/**
* 判斷annotatedClasses不爲空,並調用AnnotatedBeanDefinitionReader註解讀取器去讀取配置類annotatedClasses中的配置
*/
public void register(Class<?>... annotatedClasses) {
Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
this.reader.register(annotatedClasses); // 調用AnnotatedBeanDefinitionReader註解讀取器去讀取配置類annotatedClasses中的配置
}
2.1、this.reader.register(annotatedClasses)
/**
* 循環調用AnnotatedBeanDefinitionReader註解讀取器去讀取配置類
*/
public void register(Class<?>... annotatedClasses) {
for (Class<?> annotatedClass : annotatedClasses) {
registerBean(annotatedClass);
}
}
2.1.1、registerBean(annotatedClass)
public void registerBean(Class<?> annotatedClass) {
doRegisterBean(annotatedClass, null, null, null);
}
2.1.1.1、doRegisterBean(annotatedClass, null, null, null)
<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
// 這裏的這個AnnotatedGenericBeanDefinition對象僅僅只是在new AnnotationConfigApplicationContext(傳入的配置類)
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass); // 將Bean的配置信息轉換成AnnotatedGenericBeanDefinition,它繼承了BeanDefinition接口,包含bean的屬性
// @Conditional裝配條件判斷是否需要跳過註冊
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(instanceSupplier);
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd); // 解析bean作用域,如果使有@Scope註解指定了bean的作用域將設置成指定的作用域,否則默認爲singleton(單例)
abd.setScope(scopeMetadata.getScopeName()); // 爲AnnotatedGenericBeanDefinition對象設置scope(作用域)屬性
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry)); // 生成beanName
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd); // 解析AnnotatedGenericBeanDefinition對象中lazy、Primary、DependsOn、Role、Description屬性
if (qualifiers != null) { // @Qualifier特殊限定符處理
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));
}
}
}
// 處理applicationcontext容器加載完成後手動registerBean
for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
customizer.customize(abd);
}
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName); // 將beanName和AnnotatedGenericBeanDefinition封裝在BeanDefinitionHolder中
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); // 創建代理對象
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry); // 將BeanDefinition註冊到BeanDefinitionMap中
}
2.1.1.1.1、BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry)
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// Register bean definition under primary name.
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); // 調用BeanDefinitionRegistry方法對BeanDefinition註冊到ConCurrentHashMap中
// Register aliases for bean name, if any.
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias); // 註冊別名
}
}
}
2.1.1.1.1.1、registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition())
/**
* 對BeanDefinition註冊到ConCurrentHashMap中
*/
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
// 校驗beanName和beanDefinition不能爲空
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
// beanDefinition校驗
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName); // 判斷beanDefinitionMap中是否含有相同beanName的BeanDefinition
// 如果beanDefinitionMap中存在相同beanName的BeanDefinition
if (existingDefinition != null) {
// 判斷是否允許含有同樣的beanName對BeanDefinition進行覆蓋
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
"': There is already [" + existingDefinition + "] bound.");
}
// 參數校驗
else if (existingDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (logger.isWarnEnabled()) {
logger.warn("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
existingDefinition + "] with [" + beanDefinition + "]");
}
}
else if (!beanDefinition.equals(existingDefinition)) {
if (logger.isInfoEnabled()) {
logger.info("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
else {
if (logger.isDebugEnabled()) {
logger.debug("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + existingDefinition +
"] with [" + beanDefinition + "]");
}
}
this.beanDefinitionMap.put(beanName, beanDefinition); // 將beanName和beanDefinition存到beanDefinitionMap中
}
// 如果beanDefinitionMap中不存在相同beanName的BeanDefinition
else {
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
synchronized (this.beanDefinitionMap) { // 同步代碼塊
this.beanDefinitionMap.put(beanName, beanDefinition); // 將beanName和beanDefinition存到beanDefinitionMap中
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
if (this.manualSingletonNames.contains(beanName)) {
Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
}
else {
// Still in startup registration phase
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (existingDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}