Spring IoC 源碼分析 (基於註解) 之 Bean的解析與註冊
在上一篇文章Spring IoC 源碼分析 (基於註解) 之 包掃描中，咱們介紹了Spring基於註解掃描包獲取bean的過程。本文咱們將一塊兒探討spring對bean解析，並註冊到IOC容器的過程。spring
咱們先接着看下面這段代碼：安全
ClassPathBeanDefinitionScanner類數據結構
//類路徑Bean定義掃描器掃描給定包及其子包
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
//建立一個集合，存放掃描到的BeanDefinition封裝類
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
//遍歷掃描全部給定的包路徑
for (String basePackage : basePackages) {
//調用父類ClassPathScanningCandidateComponentProvider的方法
//掃描給定類路徑，獲取符合條件的Bean定義
10 Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
//遍歷掃描到的Bean
for (BeanDefinition candidate : candidates) {
//獲取@Scope註解的值，即獲取Bean的做用域
14 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
//爲Bean設置做用域
candidate.setScope(scopeMetadata.getScopeName());
//爲Bean生成名稱
18 String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
//若是掃描到的Bean不是Spring的註解Bean，則爲Bean設置默認值，
//設置Bean的自動依賴注入裝配屬性等
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
//若是掃描到的Bean是Spring的註解Bean，則處理其通用的Spring註解
if (candidate instanceof AnnotatedBeanDefinition) {
//處理註解Bean中通用的註解，在分析註解Bean定義類讀取器時已經分析過
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
//根據Bean名稱檢查指定的Bean是否須要在容器中註冊，或者在容器中衝突
30 if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
//根據註解中配置的做用域，爲Bean應用相應的代理模式
33 definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
//向容器註冊掃描到的Bean
37 registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
上篇文章咱們主要分析了第10行的 findCandidateComponents(basePackage)方法， 該方法主要是從給定的包路徑中掃描符合過濾規則的Bean，並存入集合beanDefinitions中。
接下來的步驟能夠分爲如下幾個方面：併發
-
遍歷bean集合app
-
獲取@Scope註解的值，即獲取Bean的做用域框架
-
爲Bean生成名稱ide
-
給Bean的一些屬性設置默認值源碼分析
-
檢查Bean是否已在IOC容器中註冊post
-
根據Bean的做用域，生成相應的代理模式ui
-
把Bean放入IOC容器中
第二步、獲取@Scope註解的值，即獲取Bean的做用域
首先來看下 獲取Bean做用域的過程，主要是上面第14行ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);這段代碼，咱們繼續跟蹤進去：
AnnotationScopeMetadataResolver類
public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
//默認是singleton
ScopeMetadata metadata = new ScopeMetadata();
if (definition instanceof AnnotatedBeanDefinition) {
AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition;
//獲取@Scope註解的值
AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(
annDef.getMetadata(), this.scopeAnnotationType);
//將獲取到的@Scope註解的值設置到要返回的對象中
if (attributes != null) {
metadata.setScopeName(attributes.getString("value"));
//獲取@Scope註解中的proxyMode屬性值，在建立代理對象時會用到
ScopedProxyMode proxyMode = attributes.getEnum("proxyMode");
//若是@Scope的proxyMode屬性爲DEFAULT或者NO
if (proxyMode == ScopedProxyMode.DEFAULT) {
//設置proxyMode爲NO
proxyMode = this.defaultProxyMode;
}
//爲返回的元數據設置proxyMode
metadata.setScopedProxyMode(proxyMode);
}
}
//返回解析的做用域元信息對象
return metadata;
}
Bean的做用域是經過@Scope註解實現的，咱們先來看下@Scope註解的屬性：
能夠看到@Scope註解有三個屬性，
-
value屬性就是咱們經常使用的用來設置Bean的單例/多例 -
proxyMode是用來設置代理方式的
關於@Scope註解原理的詳細分析，請看這篇文章<>，這裏就不詳細講了。
這裏的AnnotationAttributes是註解屬性key-value的封裝類，繼承了LinkedHashMap，因此也是key-value形式的數據結構。 經過debug看一下，這個變量拿到的值：
能夠看到獲取到了3個屬性的值，其中value = prototype就是該Bean的做用域，這裏我設置的是多例，而後再把獲取到的註解屬性值賦值給ScopeMetadata。
第三步、爲Bean生成名稱
再回到上面ClassPathBeanDefinitionScanner類的doScan()方法中的第18行， 把咱們獲取到的Bean的做用域賦值給Bean。
而後爲Bean生成名字，代碼String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
跟蹤進去，在AnnotationBeanNameGenerator類中：
public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
if (definition instanceof AnnotatedBeanDefinition) {
String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
if (StringUtils.hasText(beanName)) {
// Explicit bean name found.
return beanName;
}
}
// Fallback: generate a unique default bean name.
return buildDefaultBeanName(definition, registry);
}
這段代碼很好理解，先從註解中獲取Bean的名稱，若是註解中沒有設置，那麼生成一個默認的Bean的名稱，經過ClassUtils.getShortName(beanClassName)生成一個類名的小寫開頭駝峯的名字，如studentController。
第四步、給Bean的一些屬性設置默認值
主要是doScan()中的以下兩個方法：
//若是掃描到的Bean不是Spring的註解Bean，則爲Bean設置默認值，
//設置Bean的自動依賴注入裝配屬性等
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
//若是掃描到的Bean是Spring的註解Bean，則處理其通用的Spring註解
if (candidate instanceof AnnotatedBeanDefinition) {
//處理註解Bean中通用的註解，在分析註解Bean定義類讀取器時已經分析過
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
首先看postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName)：
跟蹤進去會到以下方法：
public void applyDefaults(BeanDefinitionDefaults defaults) {
//懶加載
setLazyInit(defaults.isLazyInit());
//加載模式
setAutowireMode(defaults.getAutowireMode());
//依賴檢查
setDependencyCheck(defaults.getDependencyCheck());
//bean初始化方法
setInitMethodName(defaults.getInitMethodName());
setEnforceInitMethod(false);
//bean銷燬方法
setDestroyMethodName(defaults.getDestroyMethodName());
setEnforceDestroyMethod(false);
}
這裏應該很清晰了，給bean設置一些默認值，BeanDefinitionDefaults是一個Bean屬性默認值的封裝類，從該類獲取各個屬性的默認值，賦值給bean。
接着咱們看AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate)方法。
跟蹤進去：
static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
//若是Bean定義中有@Lazy註解，則將該Bean預實例化屬性設置爲@lazy註解的值
if (lazy != null) {
abd.setLazyInit(lazy.getBoolean("value"));
}
else if (abd.getMetadata() != metadata) {
lazy = attributesFor(abd.getMetadata(), Lazy.class);
if (lazy != null) {
abd.setLazyInit(lazy.getBoolean("value"));
}
}
//若是Bean定義中有@Primary註解，則爲該Bean設置爲autowiring自動依賴注入裝配的首選對象
if (metadata.isAnnotated(Primary.class.getName())) {
abd.setPrimary(true);
}
//若是Bean定義中有@ DependsOn註解，則爲該Bean設置所依賴的Bean名稱，
//容器將確保在實例化該Bean以前首先實例化所依賴的Bean
AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
if (dependsOn != null) {
abd.setDependsOn(dependsOn.getStringArray("value"));
}
if (abd instanceof AbstractBeanDefinition) {
AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;
AnnotationAttributes role = attributesFor(metadata, Role.class);
if (role != null) {
absBd.setRole(role.getNumber("value").intValue());
}
AnnotationAttributes description = attributesFor(metadata, Description.class);
if (description != null) {
absBd.setDescription(description.getString("value"));
}
}
}
這裏主要是處理bean上一些經常使用的註解，如@Lazy、@Primary、@DependsOn。
註釋很清晰，這裏就不贅言了。
第五步、檢查Bean是否已在IOC容器中註冊
跟蹤doScan()中的第30行if (checkCandidate(beanName, candidate))方法:
protected boolean checkCandidate(String beanName, BeanDefinition beanDefinition) throws IllegalStateException {
//是否包含beanName了
if (!this.registry.containsBeanDefinition(beanName)) {
return true;
}
//若是容器中已經存在同名bean
//獲取容器中已存在的bean
BeanDefinition existingDef = this.registry.getBeanDefinition(beanName);
BeanDefinition originatingDef = existingDef.getOriginatingBeanDefinition();
if (originatingDef != null) {
existingDef = originatingDef;
}
//新bean舊bean進行比較
if (isCompatible(beanDefinition, existingDef)) {
return false;
}
throw new ConflictingBeanDefinitionException("Annotation-specified bean name '" + beanName +
"' for bean class [" + beanDefinition.getBeanClassName() + "] conflicts with existing, " +
"non-compatible bean definition of same name and class [" + existingDef.getBeanClassName() + "]");
}
能夠看到，實際上是經過調用IOC容器的containsBeanDefinition(beanName)方法，來判斷該beanName是否已存在，而IOC容器其實是一個map，這裏底層其實就是經過調用map.containsKey(key)來實現的。
第六步、爲Bean應用相應的代理模式
跟蹤doScan()中的 definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);方法
static BeanDefinitionHolder applyScopedProxyMode(
ScopeMetadata metadata, BeanDefinitionHolder definition, BeanDefinitionRegistry registry) {
//獲取註解Bean定義類中@Scope註解的proxyMode屬性值
ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode();
//若是配置的@Scope註解的proxyMode屬性值爲NO，則不該用代理模式
if (scopedProxyMode.equals(ScopedProxyMode.NO)) {
return definition;
}
//獲取配置的@Scope註解的proxyMode屬性值，若是爲TARGET_CLASS
//則返回true，若是爲INTERFACES，則返回false
boolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS);
//爲註冊的Bean建立相應模式的代理對象
return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
}
這裏就用到第二步中我門獲取到的@Scope註解的proxyMode屬性，而後爲bean設置代理模式。
第七步、註冊Bean到IOC容器中
跟蹤doScan()中的第37行registerBeanDefinition(definitionHolder, this.registry);方法
//將解析的BeanDefinitionHold註冊到容器中
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// Register bean definition under primary name.
//獲取解析的BeanDefinition的名稱
String beanName = definitionHolder.getBeanName();
//向IOC容器註冊BeanDefinition
第9行 registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// Register aliases for bean name, if any.
//若是解析的BeanDefinition有別名，向容器爲其註冊別名
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
直接看第9行的代碼，繼續跟蹤進去：
//向IOC容器註冊解析的BeanDefiniton
@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");
//校驗解析的BeanDefiniton
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
BeanDefinition oldBeanDefinition;
// 從容器中獲取指定 beanName 的 BeanDefinition
oldBeanDefinition = this.beanDefinitionMap.get(beanName);
// 若是已經存在
if (oldBeanDefinition != null) {
// 若是存在可是不容許覆蓋，拋出異常
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
"': There is already [" + oldBeanDefinition + "] bound.");
}
// 覆蓋 beanDefinition 大於 被覆蓋的 beanDefinition 的 ROLE ，打印 info 日誌
else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (this.logger.isWarnEnabled()) {
this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
oldBeanDefinition + "] with [" + beanDefinition + "]");
}
}
else if (!beanDefinition.equals(oldBeanDefinition)) {
if (this.logger.isInfoEnabled()) {
this.logger.info("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + oldBeanDefinition +
"] with [" + beanDefinition + "]");
}
}
else {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + oldBeanDefinition +
"] with [" + beanDefinition + "]");
}
}
// 容許覆蓋，直接覆蓋原有的 BeanDefinition 到 beanDefinitionMap 中。
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
// 檢測建立 Bean 階段是否已經開啓，若是開啓了則須要對 beanDefinitionMap 進行併發控制
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
//註冊的過程當中須要線程同步，以保證數據的一致性（由於有put、add、remove操做）
64 synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
// 從 manualSingletonNames 移除 beanName
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;
}
//檢查是否有同名的BeanDefinition已經在IOC容器中註冊
88 if (oldBeanDefinition != null || containsSingleton(beanName)) {
//更新beanDefinitionNames 和 manualSingletonNames
resetBeanDefinition(beanName);
}
}
這裏就是向IOC容器中註冊bean的核心代碼，這段代碼很長，咱們分開來看，主要分爲幾個步驟：
-
beanName和beanDefinition的合法性校驗 -
根據
beanName從IOC容器中判斷是否已經註冊過
根據isAllowBeanDefinitionOverriding變量來判斷是否覆蓋 -
若是存在根據覆蓋規則，執行覆蓋或者拋出異常
-
若是不存在，則put到IOC容器
beanDefinitionMap中
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
到這裏，註冊bean到IOC容器的過程就基本結束了，實際上IOC註冊不是什麼神祕的東西，說白了就是把beanName和bean存入map集合中
此時咱們再返回看第七步的代碼BeanDefinitionReaderUtils類的registerBeanDefinition()方法，能夠看到 registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());咱們已經分析完了，剩下的就是把bean的別名也註冊進去就大功告成了。
//將解析的BeanDefinitionHold註冊到容器中
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {
// Register bean definition under primary name.
//獲取解析的BeanDefinition的名稱
String beanName = definitionHolder.getBeanName();
//向IOC容器註冊BeanDefinition
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// Register aliases for bean name, if any.
//若是解析的BeanDefinition有別名，向容器爲其註冊別名
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
總結：
IoC容器其實就是DefaultListableBeanFactory,它裏面有一個map類型的beanDefinitionMap變量，來存儲註冊的bean
IoC容器初始化過程：
-
一、資源定位
掃描包路徑下.class文件，將資源轉爲Resource -
二、資源加載
經過ASM框架獲取class元數據，封裝到BeanDefinition -
三、資源解析
獲取bean上註解的屬性值。如@Scope -
四、生成Bean
生成beanName，設置Bean默認值(懶加載、初始化方法等)、代理模式 -
五、註冊Bean
把BeanDefinition放入IoC容器DefaultListableBeanFactory
最後思考幾個小疑問：
-
beanDefinitionMap是ConcurrentHashMap類型的，應該是線程安全的，可是爲何在代碼64行的地方，還要加sync鎖呢？ -
以前已經檢查過容器中是否有重名bean了，爲何在88行還要再檢查一次呢？
相關文章
- 1. Spring 中 bean 註冊的源碼解析
- 2. spring源碼閱讀之BeanDefinition，解析文件，讀取Bean，解析Bean，註冊Bean
- 3. SpringMVC 源代碼深度解析 IOC容器（Bean 解析、註冊）
- 4. Spring源碼-IOC容器(二)-Bean的定位解析註冊
- 5. Spring IoC 源碼分析 (基於註解) 之 包掃描
- 6. Spring 之 IoC 源碼分析 (基於註解方式)
- 7. Spring Bean註冊解析(二)
- 8. Spring源碼深度解析-bean標籤的解析及註冊
- 9. Spring IOC 源碼-bean解析
- 10. Spring IOC 之註冊解析的 BeanDefinition
- 更多相關文章...
- • XML DOM 解析器 - XML DOM 教程
- • Spring基於Annotation裝配Bean - Spring教程
- • Spring Cloud 微服務實戰(三) - 服務註冊與發現
- • 互聯網組織的未來：剖析GitHub員工的任性之源
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. Appium入門
- 2. Spring WebFlux 源碼分析(2)-Netty 服務器啓動服務流程 --TBD
- 3. wxpython入門第六步（高級組件）
- 4. CentOS7.5安裝SVN和可視化管理工具iF.SVNAdmin
- 5. jedis 3.0.1中JedisPoolConfig對象缺少setMaxIdle、setMaxWaitMillis等方法，問題記錄
- 6. 一步一圖一代碼，一定要讓你真正徹底明白紅黑樹
- 7. 2018-04-12—（重點）源碼角度分析Handler運行原理
- 8. Spring AOP源碼詳細解析
- 9. Spring Cloud（1）
- 10. python簡單爬去油價信息發送到公衆號
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Spring 中 bean 註冊的源碼解析
- 2. spring源碼閱讀之BeanDefinition，解析文件，讀取Bean，解析Bean，註冊Bean
- 3. SpringMVC 源代碼深度解析 IOC容器（Bean 解析、註冊）
- 4. Spring源碼-IOC容器(二)-Bean的定位解析註冊
- 5. Spring IoC 源碼分析 (基於註解) 之 包掃描
- 6. Spring 之 IoC 源碼分析 (基於註解方式)
- 7. Spring Bean註冊解析(二)
- 8. Spring源碼深度解析-bean標籤的解析及註冊
- 9. Spring IOC 源碼-bean解析
- 10. Spring IOC 之註冊解析的 BeanDefinition