溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本篇內容主要講解“Spring Ioc中Bean加載的方法”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“Spring Ioc中Bean加載的方法”吧!
在之前的文章中，我們分析了Spring的Ioc的初始化過程，實際上就是把beanName和BeanDefinition注冊到DefaultListableBeanFactory的map中。
在完成 bean 的注冊之后，refresh()還調用了很多后處理器的方法，其中有一個方法 finishBeanFactoryInitialization()，注釋上面寫著 Instantiateall remaining(non-lazy-init)singletons，意味著非延遲加載的類，將在這一步實例化，完成類的加載。
而我們使用到 context.getBean("beanName")方法，如果對應的 bean 是非延遲加載的，那么直接就能拿出來進行使用，而延遲加載的 bean 就需要上面的步驟進行類的加載，加載完之后才能進行使用。
我們接著分析一下Ioc的bean實例化過程：
當我們顯示或者隱式地調用 BeanFactory#getBean(String name) 方法時，則會觸發加載 Bean 階段。代碼如下：
// AbstractBeanFactory.java
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}內部調用 doGetBean(String name, final Class<T> requiredType, Object[] args, boolean typeCheckOnly) 方法，其接受四個方法參數：
name ：要獲取 Bean 的名字
requiredType ：要獲取 bean 的類型
args ：創建 Bean 時傳遞的參數。這個參數僅限于創建 Bean 時使用。
typeCheckOnly ：是否為類型檢查。
//真正實現向IOC容器獲取Bean的功能，也是觸發依賴注入功能的地方
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
//根據指定的名稱獲取被管理Bean的名稱，剝離指定名稱中對容器的相關依賴
// 如果指定的是別名，將別名轉換為規范的Bean名稱
<1> final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 從緩存中獲取已被創建過的單例Bean
<2> Object sharedInstance = getSingleton(beanName);
//如果緩存中有
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//注意：BeanFactory是管理容器中Bean的工廠
// FactoryBean是創建創建對象的工廠Bean，兩者之間有區別
//獲取給定Bean的實例對象，該對象要么是 bean 實例本身，要么就是 FactoryBean 創建的 Bean 對象
//（為什么要再次獲取呢，因為上面獲取的sharedInstance不一定是完整的）
<3> bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
// 因為 Spring 只解決單例模式下的循環依賴，在原型模式下如果存在循環依賴則會拋出異常。
<4> if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
//對IOC容器中是否存在指定名稱的BeanDefinition進行檢查，首先檢查是否
//能在當前的BeanFactory中獲取的所需要的Bean，如果不能則委托當前容器
//的父級容器去查找，如果還是找不到則沿著容器的繼承體系向父級容器查找
BeanFactory parentBeanFactory = getParentBeanFactory();
//當前容器的父級容器存在，且當前容器中不存在指定名稱的Bean
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
//解析指定Bean名稱的原始名稱
String nameToLookup = originalBeanName(name);
// 若為 AbstractBeanFactory 類型，委托父類處理
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
//委派父級容器根據指定名稱和顯式的參數查找
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// No args -> delegate to standard getBean method.
//委派父級容器根據指定名稱和類型查找
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
// 創建的Bean是否需要進行類型驗證，一般不需要
<5> if (!typeCheckOnly) {
//向容器標記指定的Bean已經被創建
markBeanAsCreated(beanName);
}
try {
//從容器中獲取 beanName 相應的 GenericBeanDefinition 對象，并將其轉換為 RootBeanDefinition 對象
// 主要解決Bean繼承時子類合并父類公共屬性問題
<6> final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 檢查給定的合并的 BeanDefinition (是否為抽象類)
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 處理所依賴的 bean @DependsOn()
// 獲取當前Bean所有依賴Bean的名稱
<7> String[] dependsOn = mbd.getDependsOn();
//如果有依賴
if (dependsOn != null) {
for (String dep : dependsOn) {
//校驗該依賴是否已經注冊過給當前 Bean
if (isDependent(beanName, dep)) {
//已注冊，拋出異常
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
//沒有，則先注冊依賴的bean
registerDependentBean(dep, beanName);
//遞歸調用getBean()，先生成依賴的bean
getBean(dep);
}
}
// Create bean instance.
//創建單例Bean
<8> if (mbd.isSingleton()) {
//這里使用了一個匿名內部類，創建Bean實例對象，并且注冊給所依賴的對象
sharedInstance = getSingleton(beanName, () -> {
try {
//創建一個指定Bean實例對象，如果有父級繼承，則合并子類和父類的定義
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
//顯式地從容器單例模式Bean緩存中清除實例對象
destroySingleton(beanName);
throw ex;
}
});
//獲取給定Bean的實例對象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//創建多例Bean
else if (mbd.isPrototype()) {
//原型模式(Prototype)是每次都會創建一個新的對象
Object prototypeInstance = null;
try {
//加載前置處理，默認的功能是注冊當前創建的原型對象
beforePrototypeCreation(beanName);
//創建指定Bean對象實例
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
//加載后置處理，默認的功能告訴IOC容器指定Bean的原型對象不再創建
afterPrototypeCreation(beanName);
}
//獲取給定Bean的實例對象
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//要創建的Bean既不是Singleton也不是Prototype
//如：request、session、application等生命周期
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
//Bean定義資源中沒有配置生命周期范圍，則Bean定義不合法
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
//這里又使用了一個匿名內部類，獲取一個指定生命周期范圍的實例
Object scopedInstance = scope.get(beanName, () -> {
//前置處理
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
//后置處理
afterPrototypeCreation(beanName);
}
});
//獲取給定Bean的實例對象
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// Check if required type matches the type of the actual bean instance.
//對創建的Bean實例對象進行類型檢查
<9> if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}代碼很長，需要一些耐心，下面我們來逐步分析這段代碼：
<1>處：具體分析，見2.1獲取原始beanName
<2>處: 具體分析，見2.2從緩存中獲取單例bean
<3>處: 具體分析，見2.3獲取最終的bean實例對象
<4>處: 具體分析，見2.4原型模式依賴檢查
<5>處: 具體分析，見2.5標記bean為已創建或即將創建
<6>處: 具體分析，見2.6獲取BeanDefinition
<7>處: 具體分析，見2.7bean依賴處理
<8>處: 具體分析，見2.8不同作用域bean的實例化
<9>處: 具體分析，見2.9類型轉換
代碼如下：
final String beanName = transformedBeanName(name);
繼續深入，代碼如下：
protected String transformedBeanName(String name) {
return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}BeanFactoryUtils.transformedBeanName(name)方法主要是去除 FactoryBean 的修飾符
//對FactoryBean的轉義定義，因為如果使用bean的名字檢索FactoryBean得到的對象是工廠生成的對象，
//如果需要得到工廠本身，需要轉義
String FACTORY_BEAN_PREFIX = "&";
public static String transformedBeanName(String name) {
Assert.notNull(name, "'name' must not be null");
String beanName = name;
while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
}
return beanName;
}ps: 如果一個factoryBean的名稱為“student”，獲取factoryBean創建的Bean時，使用getBean("student")，獲取factoryBean本身時，使用getBean("&student")
接著深入，最終代碼如下：
/** Map from alias to canonical name */
private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
//循環處理，從aliasMap中根據aliasName獲取真實beanName，直到獲取到的真實beanName為null
public String canonicalName(String name) {
String canonicalName = name;
// Handle aliasing...
String resolvedName;
do {
resolvedName = this.aliasMap.get(canonicalName);
if (resolvedName != null) {
canonicalName = resolvedName;
}
}
while (resolvedName != null);
return canonicalName;
}主要是一個循環獲取 beanName 的過程，例如，別名 A 指向名稱為 B 的 bean 則返回 B，若 別名 A 指向別名 B，別名 B 指向名稱為 C 的 bean，則返回 C
Spring 對單例模式的 bean 只會創建一次。后續，如果再獲取該 Bean ，則是直接從單例緩存中獲取，該過程就體現在 #getSingleton(String beanName) 方法中。代碼如下：
/** Cache of singleton objects: bean name --> bean instance */
//單例bean的緩存
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/** Cache of singleton factories: bean name --> ObjectFactory */
//單例對象工廠緩存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/** Cache of early singleton objects: bean name --> bean instance */
//預加載單例bean緩存
//存放的 bean 不一定是完整的
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
//對于單例模式的Bean整個IOC容器中只創建一次，不需要重復創建
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//從單例緩存中獲取單例bean
Object singletonObject = this.singletonObjects.get(beanName);
//如果緩存中沒有 并且 該bean正在創建
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
// earlySingletonObjects 中沒有，且允許提前創建
if (singletonObject == null && allowEarlyReference) {
//從緩存中獲取 ObjectFactory
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
//從單例工廠中獲取bean
singletonObject = singletonFactory.getObject();
//存入early
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}這段代碼很簡單，流程如下：
第一步，從singletonObjects中獲取Bean對象
第二步，如果獲取不到且Bean正在創建中，從earlySingletonObjects獲取Bean對象
第三步，如果獲取不到且允許提前創建,從singletonFactories獲取FactoryBean
第四步，如果不為null，則通過FactoryBean.getObject()獲取Bean，然后將其加入到 earlySingletonObjects ，并且從 singletonFactories 刪除，兩者是互斥的，主要用來解決循環依賴的問題
總結就是：從這三個Map依次去取，取不到就取下一個Map
在上面的代碼中又一個重要的方法isSingletonCurrentlyInCreation(beanName)，代碼如下：
private final Set<String> singletonsCurrentlyInCreation =
Collections.newSetFromMap(new ConcurrentHashMap<>(16));
public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}這個方法是用來判斷當前Bean是否在創建中，看到是個Map，我們可以猜測，應該有一個地方在創建Bean的時候，會把正在創建的BeanName給put到這個Map中。具體我們之后將。
當我們從getSingleton(beanName)拿到bean對象后，會接著調用getObjectForBeanInstance()方法，來獲取最終的Bean實例。
為什么這里要再獲取一次Bean呢，之前明明都拿到了呀？
因為我們從緩存中獲取的 bean 是最原始的 Bean ，并不一定是我們最終想要的 Bean
怎么辦呢？調用 #getObjectForBeanInstance(...) 方法，進行處理，該方法的定義為獲取給定 Bean 實例的對象，該對象要么是 bean 實例本身，要么就是 FactoryBean 創建的 Bean 對象。
看代碼：
//獲取給定Bean的實例對象，主要是完成FactoryBean的相關處理
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// Don't let calling code try to dereference the factory if the bean isn't a factory.
//容器已經得到了Bean實例對象，這個實例對象可能是一個普通的Bean，
//也可能是一個工廠Bean，如果是一個工廠Bean，則使用它創建一個Bean實例對象，
//如果調用本身就想獲得一個容器的引用，則指定返回這個工廠Bean實例對象
//若為工廠類引用（name 以 & 開頭） 且 Bean實例也不是 FactoryBean
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
//拋出異常
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
// Now we have the bean instance, which may be a normal bean or a FactoryBean.
//如果類型不是FactoryBean，直接返回
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
//若 BeanDefinition 為 null，則從緩存中加載 Bean 對象
if (mbd == null) {
//從Bean工廠緩存中獲取給定名稱的Bean實例對象
object = getCachedObjectForFactoryBean(beanName);
}
// 若 object 依然為空，則可以確認，beanInstance 一定是 FactoryBean 。從而，使用 FactoryBean 獲得 Bean 對象
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
// 檢測是否定義 beanName
if (mbd == null && containsBeanDefinition(beanName)) {
//從容器中獲取指定名稱的Bean定義，如果繼承基類，則合并基類相關屬性
mbd = getMergedLocalBeanDefinition(beanName);
}
//如果從容器得到Bean定義信息，并且Bean定義信息不是虛構的，
//則讓工廠Bean生產Bean實例對象
boolean synthetic = (mbd != null && mbd.isSynthetic());
//調用FactoryBeanRegistrySupport類的getObjectFromFactoryBean方法，
//實現工廠Bean生產Bean對象實例的過程
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}首先看下這個方法的流程：
1、類型檢查，判斷是否是FactoryBean
2、對非 FactoryBean 不做處理
3、對 bean 進行轉換
4、處理 FactoryBean 類型：委托給 getObjectFromFactoryBean 方法進行處理。
我們直接看第3步，走到這里，說明這個bean一定是FactoryBean類型的，再從Ioc容器中獲取該beanName對應的BeanDefinition，如果不為null，且不是abstract，則調用getObjectFromFactoryBean方法獲取bean實例
從這里可以看出， getObjectForBeanInstance(Object beanInstance, String name, String beanName,RootBeanDefinition mbd) 方法，分成兩種情況：
第一種，當該實例對象為非 FactoryBean 類型，直接返回給定的 Bean 實例對象 beanInstance 。
第二種，當該實例對象為FactoryBean 類型，從 FactoryBean ( beanInstance ) 中，獲取 Bean 實例對象。
我們接著看第二種情況：
//Bean工廠生產Bean實例對象
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
//為單例模式且緩存中存在
if (factory.isSingleton() && containsSingleton(beanName)) {
//多線程同步，以防止數據不一致
1.1 synchronized (getSingletonMutex()) {
//從緩存中獲取指定的 factoryBean
1.2 Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
// 為空，則從 FactoryBean 中獲取對象
object = doGetObjectFromFactoryBean(factory, beanName);
// Only post-process and store if not put there already during getObject() call above
// (e.g. because of circular reference processing triggered by custom getBean calls)
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
1.3 if (shouldPostProcess) {
try {
// 對從 FactoryBean 獲取的對象進行后處理
// 生成的對象將暴露給 bean 引用
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
}
//將生產的實例對象添加到Bean工廠緩存中
1.4 this.factoryBeanObjectCache.put(beanName, object);
}
}
return object;
}
}
// 為空，則從 FactoryBean 中獲取對象
2 else {
Object object = doGetObjectFromFactoryBean(factory, beanName);
// 需要后續處理
if (shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}1、判斷是否為單例并且緩存中存在 如果存在，則順著1.1往下走，不存在，則走2的流程
1.1、sync加鎖，鎖住的是singletonObjects，和其他單例鎖一樣，保證全局唯一
1.2、從緩存factoryBeanObjectCache中獲取Bean實例 如果獲取不到，則調用doGetObjectFromFactoryBean()方法獲取，實際最后調用的是factory.getObject()方法
1.3、如果需要后續處理( shouldPostProcess = true )，則進行下一步處理 postProcessObjectFromFactoryBean() 方法，對從 FactoryBean 處獲取的 Bean 實例對象進行后置處理。其默認實現是直接返回 object 對象，不做任何處理。代碼如下：
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) throws BeansException {
return object;
}但是子類可以重寫，例如應用后處理器等。
1.4、加入到 factoryBeanObjectCache 緩存中
2、如果緩存中不存在，同樣調用doGetObjectFromFactoryBean()獲取bean實例
到此，相信大家對“Spring Ioc中Bean加載的方法”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
