2. 程式人生 > >Spring SingletonBeanRegistry 單例 Bean 註冊管理

Spring SingletonBeanRegistry 單例 Bean 註冊管理

阿新 • • 發佈：2019-01-20
會銷 efi 對象 實例化 如果 tro nullable 還在 ntb

Spring SingletonBeanRegistry 單例 Bean 註冊管理

技術分享圖片

在 Spring 中 Bean 有單例和多例之分，只有單例的 bean 才會被 BeanFactory 管理，這個工作就是由 SingletonBeanRegistry 完成的。

public interface SingletonBeanRegistry {
    void registerSingleton(String beanName, Object singletonObject);
    Object getSingleton(String beanName);

    boolean containsSingleton(String beanName);
    String[] getSingletonNames();
    int getSingletonCount();
    
    // 暴露所有的 singletonObjects 給外部
    Object getSingletonMutex();
}

SingletonBeanRegistry 的默認實現為 DefaultSingletonBeanRegistry，主要功能如下：

  1. 單例 bean 的註冊和查找。
  2. 擴展了 SingletonBeanRegistry 的功能，還管理 bean 的生命周期，包括 bean 的創建和銷毀。與 bean 生命周期有關的方法如下：
// 1. 創建 bean。先從緩存中獲取 bean，allowEarlyReference=true 時會嘗試從 singletonFactories 獲取提暴露的 bean 
//    緩存中沒有就調用 singletonFactory 方法創建 bean
public Object getSingleton(String beanName);
protected Object getSingleton(String beanName, boolean allowEarlyReference)
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory);

// 2. 銷毀 bean。可以銷毀全部的 bean，也可以銷毀指定的 bean，最終都是調用 destroyBean 完成的。
//    銷毀 bean 之前需要先銷毀依賴它的所有 bean，再調用 bean.destroy() 銷毀自己
public void destroySingletons();
public void destroySingleton(String beanName);
protected void destroyBean(String beanName, @Nullable DisposableBean bean);

一、相關屬性

(1) 與單例對象保存有關的四個集合

我們先從下面四個和單例有關的集合說起。前三個集合和 bean 的創建有關，其中 singletonObjects 保存已經創建成功的 bean 的集合，singletonFactories 和 earlySingletonObjects 屬於中間過程，一旦 bean 創建成功就會刪除對應的記錄，用於解決 bean 屬性註入過程中的循環依賴的問題。最後一個用來保存當前所有已註冊的 bean。

// 1.1 保存最終創建成功的單例 beanName -> beanInstance
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 1.2 中間變量，beanName -> Objectfactory
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
// 1.3 中間變量，bean 還在創建的時候就可以獲取，用於檢測循環引用 
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

// 2. 用來保存當前所有已註冊的 bean
private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

這裏涉及用於存儲 bean 的不同的 Map，可能讓人感到崩潰，簡單解釋如下：

  1. singletonObjects：用於保存 beanName 和創建 bean 實例之間的關系，beanName -> beanInstance
  2. singletonfactories：用於保存 beanname 和創建 bean 的工廠之間的關系，beanName -> Objectfactory
  3. earlySingletonObjects：也是保存 beanName 和創建 bean 實例之間的關系，與 singletonObjects 的不同之處在於，當一個單例 bean 被放到這裏面後，那麽當 bean 還在創建過程中，就可以通過 getBean 方法獲取到了，其目的是用來檢測循環引用。
  4. registeredsingletons：用來保存當前所有已註冊的 bean

(2) 與單例對象創建有關的幾個屬性

// 1. 保存正在創建的 bean
private final Set<String> singletonsCurrentlyInCreation =
            Collections.newSetFromMap(new ConcurrentHashMap<>(16));
// 2. 保存已經創建的 bean 集合，這樣進行依賴循環檢查時
//    如果已經 bean 在 inCreationCheckExclusions 中了，就不用再檢查 singletonsCurrentlyInCreation 了
private final Set<String> inCreationCheckExclusions =
        Collections.newSetFromMap(new ConcurrentHashMap<>(16));
// 3. 保存 bean 創建過程時的異常
private Set<Exception> suppressedExceptions;

(3) 與單例對象銷毀有關的四個集合

// 1. 一旦調用 destroySingletons() 銷毀所有的 bean 時就修改為 true 
private boolean singletonsCurrentlyInDestruction = false;

// 2. 下面四個集合都和 bean 的銷毀有關
// 2.1 保存每個 bean 的 destroy 方法
private final Map<String, Object> disposableBeans = new LinkedHashMap<>();

// 3.1 保存當前 bean 內的所有 bean 信息。containingBean -> containedBean
//      當註冊 containedBeanMap 的同時也會註冊 dependentBeanMap 和 dependenciesForBeanMap
private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);

// 3.2 保存依賴這個 bean 的所有 bean 的集合，依賴我的。containedBean -> containingBean
//     所以銷毀這個 bean 的同時也要銷毀依賴它的所有 bean
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
// 3.3 保存當前 bean 依賴的所有 bean 的集合，我依賴的。containingBean -> containedBean
//     所以銷毀這個 bean 只要清空對應的記錄即可，而不會銷毀該 bean 依賴的其它 bean
private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);

二、bean 的註冊與刪除

@Override
public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
    synchronized (this.singletonObjects) {
        Object oldObject = this.singletonObjects.get(beanName);
        if (oldObject != null) {
            throw new IllegalStateException();
        }
        addSingleton(beanName, singletonObject);
    }
}

// 這個方法只有在本類中才調用，bean 屬性註入完成，直接添加 singletonObject
protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        this.singletonObjects.put(beanName, singletonObject);
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}

// AbstractAutowireCapableBeanFactory#doCreateBean 調用。註冊 singletonFactory
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

這個沒什麽可說的，主要是要理清這四個集合的功能。可以看到有兩種方法註冊單例，這兩種情況都會將 bean 註冊到 registeredSingletons 中：

  • 一是 bean 創建完成直接註冊 singletonObjects。此時 bean 已經創建完成，直接註冊到 singletonObjects 集合中，同時清理創建過程中所記錄的各種輔助狀態。
  • 二是 bean 創建開始前先註冊其引用對象 singletonFactory。此時先註冊到 singletonFactories 中，通過 allowEarlyReference=true 可以查找到提前暴露的這個對象，一旦創建完成調用 addSingleton(String beanName, Object singletonObject) 將其註冊到 singletonObjects 中，這段代碼的邏輯見 getSingleton(String beanName, ObjectFactory<?> singletonFactory) 方法。

三、bean 的生周期

DefaultSingletonBeanRegistry 不僅管理了 bean 的註冊，還管理 bean 的生命周期，包括 bean 的創建和銷毀。

3.1 bean 的創建

Spring 中單例只會被創建一次，後續再獲取 bean 直接從單例緩存中獲取。

  1. 嘗試從緩存中查找。getSingleton(beanName) 直接從緩存中獲取 bean，也可以指定是否查找提前暴露的 bean(也就是正在創建的 bean)。allowEarlyReference=true 時會查找正在創建的 bean。
  2. 直接創建 bean。當從緩存中獲取不到時，直接會調用 getSingleton(beanName, singletonFactory) 方法創建單例 bean。因為創建的時候會存在依賴註入的情況，為了解決可能存在的循環依賴問題，Spring 創建 bean 的原則是不等 bean 創建完成就會將創建 bean 的 ObjectFactory 提早曝光加入到緩存中，這樣通過 getSingleton(beanName, true) 就可以在緩存中直接查找到這個 bean 的 ObjectFactory。

3.1.1 從緩存中獲取

public Object getSingleton(String beanName) {
    // 參數 true 設置標識允許時期依賴
    return getSingleton(beanName, true);
}

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 1. 在已經創建完成的 singletonObjects 集合中查找
    Object singletonObject = this.singletonObjects.get(beanName);
    // 2. 如果這個 bean 正在創建，則繼續嘗試從 earlySingletonObjects 中查找
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                // 3. 當某些方法需要提前初始化的時候則會調用 addSingletonFactory 方法
                // 將對應的 ObjectFactory 初始化策略存儲在 singletonFactories
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    // 調用預先設定的 getObject 方法
                    singletonObject = singletonFactory.getObject();
                    // 記錄在緩存中，earlySingletonObjects 與 singletonFactories 互斥
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
}

這個方法步驟如下：

  1. 首先嘗試從 singletonObjects 裏面獲取實例
  2. 如果獲取不到再從 earlySingletonObjects 裏面獲取
  3. 如果還獲取不到，再嘗試從 singletonFactories 裏面獲取 beanName 對應的 ObjectFactory，然後調用這個 ObjectFactory 的 getObject 來創建 bean，並放到 earlySingletonObjects 裏面去，並且從 earlySingletonObjects 裏面 remove 掉這個 ObjectFactory

而對於後續的所有內存操作都只為了循環依賴檢測時候使用，也就是在 allowEarlyReference=true 的情況下才會使用。

3.1.2 直接創建 bean

上面講解了從緩存中獲取單例的過程，那麽，如果緩存中不存在已經加載的單例 bean 就需要從頭開始 bean 的加載過程了，而 Spring 中使用 getSingleton 的重載方法 getSingleton(beanName, singletonFactory) 實現 bean 的加載過程。

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "‘beanName‘ must not be null");
    synchronized (this.singletonObjects) {
        // 1. 首先檢查對應的 bean 是否已經加載過
        //    因為 singleton 模式其實就是復用已創建的 bean，所以這一步是必須的
        Object singletonObject = this.singletonObjects.get(beanName);
        // 2. 進行 singleton 的 bean 的初始化
        if (singletonObject == null) {
            // 2.1 容器正在銷毀拋出異常
            if (this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException(beanName);
            }
            // 2.2 將這個 bean 添加到 singletonsCurrentlyInCreation 集合中，這樣就可以判斷 bean 是否存在創建
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet<Exception>();
            }
            try {
                // 2.3 初始化 bean，委托給 ObjectFactory 完成 
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            } catch (IllegalStateException ex) {
                // 2.4 ?????????
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    throw ex;
                }
            } catch (BeanCreationException ex) {
                if (recordSuppressedExceptions) {
                    for (Exception suppressedException : this.suppressedExceptions) {
                        ex.addRelatedCause(suppressedException);
                    }
                }
                throw ex;
            } finally {
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }
                // 2.5 從 singletonsCurrentlyInCreation 移除該 bean
                afterSingletonCreation(beanName);
            }
            if (newSingleton) {
                // 2.6 創建成功，加入緩存
                addSingleton(beanName, singletonObject);
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }
}

上述代碼中其實是使用了回調方法，使得程序可以在單例創建的前後做一些準備及處理操作，而真正的獲取單例 bean 的方法其實並不是在此方法中實現的，其實現邏輯是在 ObjectFactory 類型的實例 singletonFactory 中實現的。而這些準備及處理操作包括如下內容：

(1) 檢查緩存是否已經加載過

(2) 若沒有加載，則記錄 beanName 的正在加載狀態。

(3) 加載單例前記錄加載狀態。可能你會覺得 beforeSingletonCreation 方法是個空實現，裏面沒有任何邏輯，但其實不是，這個函數中做了一個很重要的操作：記錄加載狀態，也就是通過 this.singletonsCurrentlyInCreation.add(beanName) 將當前正要創建的 bean 記錄在緩存中，這樣便可以對循環依賴進行檢測。

protected void beforeSingletonCreation(String beanName) {
    if (!this.inCreationCheckExclusions.contains(beanName) && 
        !this.singletonsCurrentlyInCreation.add(beanName)) {
        throw new BeanCurrentlyInCreationException(beanName);
    }
}

(4) 通過調用參數傳入的 ObjectFactory 的個體 Object 方法實例化 bean

(5) 加載單例後的處理方法調用。同步驟 (3) 的記錄加載狀態相似，當 bean加載結東後需要移除緩存中對該 bean 的正在加載狀態的記錄。

protected void afterSingletonCreation(String beanName) {
    if (!this.inCreationCheckExclusions.contains(beanName) && 
        !this.singletonsCurrentlyInCreation.remove(beanName)) {
        throw new IllegalStateException("Singleton ‘" + beanName + "‘ isn‘t currently in creation");
    }
}

(6) 將結果記錄至緩存並刪除加載 bean 過程中所記錄的各種輔助狀態。

3.1.3 ObjectFactory 參數

在創建 bean 的過程中，很多工作都交給 ObjectFactory 這個工廠類完成，那它到底是什麽呢？

public interface ObjectFactory<T> {
    T getObject() throws BeansException;
}

在方法 getSingleton(beanName, singletonFactory) 和 addSingletonFactory(beanName, singletonFactory) 兩種都用到了 ObjectFactory，這兩處的 ObjectFactory 功能並不是一樣的。 前者的 ObjectFactory 是用於創建 bean，屬於創建型 ObjectFactory，而後者只是簡單的持有 bean，屬於引用型 ObjectFactory，保存在 singletonFactories 集合中用於解決循環依賴的問題。

(1) 創建型 ObjectFactory

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
        @Override
        public Object getObject() throws BeansException {
            try {
                return createBean(beanName, mbd, args);
            } catch (BeansException ex) {
                destroySingleton(beanName);
                throw ex;
            }
        }
    });
}

(2) 引用型 ObjectFactory

在 createBean 創建 bean 的過程中，在實例化 bean 後就會將這個 bean 提前暴露出來，這樣就可以提前在緩存中拿到正在創建的 bean。

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) {
    // 1. 反射創建 bean
    BeanWrapper instanceWrapper = null;
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = instanceWrapper.getWrappedInstance();

    // 2. 將這個 bean 通過 addSingletonFactory 暴露到緩存中，這樣指定 allowEarlyReference=true 就可以提前查找到
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
            isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        // getEarlyBeanReference 默認直接將這個 bean 返回了
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // 3. 之後再進行屬性註入和初始化等操作
    Object exposedObject = bean;
    populateBean(beanName, mbd, instanceWrapper);
    exposedObject = initializeBean(beanName, exposedObject, mbd);
}

3.1.4 bean 的狀態管理

bean 進行循環依賴檢查與兩個集合有關：

  • inCreationCheckExclusions 如果 bean 創建完成則添加到該集合中，這樣如果包含要檢查的 bean 就不用再檢查 singletonsCurrentlyInCreation 了。
  • singletonsCurrentlyInCreation bean 創建開始時先添加到這個集合中，創建成功後刪除
// 如果 inCreation=false 則說明對象已經創建成功，直接添加到 inCreationCheckExclusions 集合中，否則就刪除
// 這樣在進行循環依賴檢查時，當這個集合包含該 bean 時就不用檢查 singletonsCurrentlyInCreation
public void setCurrentlyInCreation(String beanName, boolean inCreation) {
    Assert.notNull(beanName, "Bean name must not be null");
    if (!inCreation) {
        this.inCreationCheckExclusions.add(beanName);
    } else {
        this.inCreationCheckExclusions.remove(beanName);
    }
}

// isCurrentlyInCreation 和 isSingletonCurrentlyInCreation 區別還是沒看明白？？？
public boolean isCurrentlyInCreation(String beanName) {
    Assert.notNull(beanName, "Bean name must not be null");
    return (!this.inCreationCheckExclusions.contains(beanName) && isActuallyInCreation(beanName));
}
// isActuallyInCreation 方法只有在 isCurrentlyInCreation 中調用，不明白為什麽還要單獨抽出來
protected boolean isActuallyInCreation(String beanName) {
    return isSingletonCurrentlyInCreation(beanName);
}
public boolean isSingletonCurrentlyInCreation(String beanName) {
    return this.singletonsCurrentlyInCreation.contains(beanName);
}

3.2 bean 的依賴管理

bean 創建成功後需要註冊 bean 之前的依賴關系，這樣銷毀時才能將依賴它的 bean 也同時銷毀

3.2.1 依賴管理

(1) 註冊依賴

// 保存當前 bean 內的所有 bean。containingBeanName -> containedBeanName
public void registerContainedBean(String containedBeanName, String containingBeanName) {
    synchronized (this.containedBeanMap) {
        Set<String> containedBeans =
                this.containedBeanMap.computeIfAbsent(containingBeanName, k -> new LinkedHashSet<>(8));
        if (!containedBeans.add(containedBeanName)) {
            return;
        }
    }
    registerDependentBean(containedBeanName, containingBeanName);
}

// dependentBeans 保存依賴我的所有 bean。containedBeanName -> containingBeanName
// dependenciesForBeanMap 保存我依賴的所有 bean。containingBeanName -> containedBeanName
public void registerDependentBean(String beanName, String dependentBeanName) {
    // 查找 bean 的註冊名稱
    String canonicalName = canonicalName(beanName);

    synchronized (this.dependentBeanMap) {
        // jdk8 如果 key 不存在設置 value，否則返回 oldValue 
        Set<String> dependentBeans =
                this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
        // 如果已經註冊直接返回
        if (!dependentBeans.add(dependentBeanName)) {
            return;
        }
    }
    synchronized (this.dependenciesForBeanMap) {
        Set<String> dependenciesForBean =
                this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
        dependenciesForBean.add(canonicalName);
    }
}

當然如果這個 bean 有銷毀方法，也會註冊其 DisposableBean

public void registerDisposableBean(String beanName, DisposableBean bean) {
    synchronized (this.disposableBeans) {
        this.disposableBeans.put(beanName, bean);
    }
}

(2) 依賴查找

  • isDependent 查找兩個 bean 的依賴關系
  • getDependentBeans 查找依賴這個 bean 的所有 bean
  • getDependenciesForBean 查找這個 bean 依賴的所有 bean

isDependent 查找兩個 bean 的依賴關系。如果 dependentBeanName 依賴 beanName 則返回 true，這其中會存在間接依賴的情況，如 beanA -> beanB -> beanC，查詢 beanA -> beanC 的關系。

protected boolean isDependent(String beanName, String dependentBeanName) {
    synchronized (this.dependentBeanMap) {
        return isDependent(beanName, dependentBeanName, null);
    }
}

private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
    // 1. alreadySeen 是已經查找過的 bean，這裏面的 bean 都不存在依賴關系，如果存在則已經返回 true 了
    if (alreadySeen != null && alreadySeen.contains(beanName)) {
        return false;
    }
    // 2. 獲取 bean 的註冊名稱
    String canonicalName = canonicalName(beanName);
    // 3. 查找依賴 beanName 的所有 bean，如果有則肯定有依賴，否則還要查找間接依賴
    Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
    if (dependentBeans == null) {
        return false;
    }
    if (dependentBeans.contains(dependentBeanName)) {
        return true;
    }
    // 4. 逐個查找間接依賴
    for (String transitiveDependency : dependentBeans) {
        if (alreadySeen == null) {
            alreadySeen = new HashSet<>();
        }
        alreadySeen.add(beanName);
        if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
            return true;
        }
    }
    return false;
}

3.3 bean 的銷毀

// 銷毀所有 bean
public void destroySingletons() {
    synchronized (this.singletonObjects) {
        this.singletonsCurrentlyInDestruction = true;
    }

    String[] disposableBeanNames;
    synchronized (this.disposableBeans) {
        disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
    }
    for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
        destroySingleton(disposableBeanNames[i]);
    }

    this.containedBeanMap.clear();
    this.dependentBeanMap.clear();
    this.dependenciesForBeanMap.clear();

    clearSingletonCache();
}

// 銷毀指定的 bean
public void destroySingleton(String beanName) {
    removeSingleton(beanName);
    DisposableBean disposableBean;
    synchronized (this.disposableBeans) {
        disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
    }
    destroyBean(beanName, disposableBean);
}

真正的銷毀在 destroyBean 中完成。

protected void destroyBean(String beanName, @Nullable DisposableBean bean) {
    // 1. 首先將依賴這個 beanName 的全部銷毀
    Set<String> dependencies;
    // ConcurrentHashMap 為什麽還需要同步???
    synchronized (this.dependentBeanMap) {
        dependencies = this.dependentBeanMap.remove(beanName);
    }
    if (dependencies != null) {
        for (String dependentBeanName : dependencies) {
            destroySingleton(dependentBeanName);
        }
    }

    // 2. 真正銷毀該 beanName
    if (bean != null) {
        bean.destroy();
    }

    // 3. 銷毀 containedBeans
    Set<String> containedBeans;
    synchronized (this.containedBeanMap) {
        containedBeans = this.containedBeanMap.remove(beanName);
    }
    if (containedBeans != null) {
        for (String containedBeanName : containedBeans) {
            destroySingleton(containedBeanName);
        }
    }

    // 4. 清理 dependentBeanMap 中殘存的 beanName 記錄
    synchronized (this.dependentBeanMap) {
        for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext();) {
            Map.Entry<String, Set<String>> entry = it.next();
            Set<String> dependenciesToClean = entry.getValue();
            dependenciesToClean.remove(beanName);
            if (dependenciesToClean.isEmpty()) {
                it.remove();
            }
        }
    }

    // 5. 清理 dependenciesForBeanMap
    this.dependenciesForBeanMap.remove(beanName);
}

每天用心記錄一點點。內容也許不重要，但習慣很重要！

Spring SingletonBeanRegistry 單例 Bean 註冊管理

相關推薦

Spring SingletonBeanRegistry 單例 Bean 註冊管理

會銷 efi 對象 實例化 如果 tro nullable 還在 ntb Spring SingletonBeanRegistry 單例 Bean 註冊管理 在 Spring 中 Bean 有單例和多例之分，只有單例的 bean 才會被 BeanFactory 管理，這個

Spring建立單例bean

Spring建立bean是有一個Scope。預設是單例。 如何證明Spring建立的Bean就是單例？Spring單例有什麼意義在？ Spring建立的bean是否是單例很好判斷： ApplicationContext context = new Cl

spring建立單例bean和非單例bean的方式

利用spring建立單例bean，這通常是spring建立bean的預設方式。不過我們可以在建立bean的時候進行顯示宣告，例：在bean的配置檔案中加上scope屬性 1> 建立單例bean <bean id="boss" class="com.zj.Boss

Spring（六）核心容器 - 註冊單例 Bean 例項、SingletonBeanRegistry 簡介

前言 上篇文章我們對註冊 Bean 的核心類 BeanDefinitionRegistry 進行了討論，這裡的註冊 Bean 是指儲存 Bean 的相關資訊，也就是將 Bean 定義成 BeanDefinition，然後放入容器中。除此之外，Spring 還提供一個統一操作單例 Bean 例項的類 Singl

Spring IOC 容器源碼分析 - 創建單例 bean 的過程

event version trac 方法 del lB ctu prepare 先來 1. 簡介 在上一篇文章中，我比較詳細的分析了獲取 bean 的方法，也就是getBean(String)的實現邏輯。對於已實例化好的單例 bean，getBean(String) 方法

Spring源碼分析（十三）緩存中獲取單例bean

ould for 目的 存儲 不同 單例 color 正在 span 摘要：本文結合《Spring源碼深度解析》來分析Spring 5.0.6版本的源代碼。若有描述錯誤之處，歡迎指正。 介紹過FactoryBean的用法後，我們就可以了解bean加載的過程了。前面已

spring bean的單例和多例的使用場景和在單例bean中注入多例（不看後悔，一看必懂）

為什麼用單例或者多例？何時用？ 之所以用單例，是因為沒必要每個請求都新建一個物件，這樣子既浪費CPU又浪費記憶體； 之所以用多例，是為了防止併發問題；即一個請求改變了物件的狀態，此時物件又處理另一個請求，而之前請求對物件狀態的改變導致了物件對另一個請求做了錯誤的處理；  

Spring bean 和單例bean的執行緒安全

Bean的作用域  　　Spring 3中為Bean定義了5中作用域，分別為singleton（單例）、prototype（原型）、request、session和global session，5種作用域說明如下： singleton：單例模式，Spring I

普通Java類獲取spring 容器的bean的5種方法 Spring注入非單例bean以及scope的作用範圍

本文轉載自：http://www.cnblogs.com/duanxz/archive/2014/06/18/3794075.html 方法一：在初始化時儲存ApplicationContext物件方法二：通過Spring提供的工具類獲取ApplicationContext物件方法三：繼承自抽象類Appli

20--Spring例項化單例bean的準備工作

上一節分析了Spring從快取中獲取單例bean的過程，相對於建立一個全新的單例bean，該過程還是很簡單的，本節接著分析建立單例bean的準備工作。 引 protected <T> T doGetBean(final String name, @N

spring深入學習（十五） IOC 之從單例快取中獲取單例 bean

從這篇部落格開始我們開始載入 bean 的第一個步驟，從快取中獲取 bean，程式碼片段如下： Object sharedInstance = getSingleton(beanName); if (sharedInstance != null &&

【Spring原始碼閱讀】 preInstantiateSingletons方法分析，單例Bean獲取/例項化流程

在初始化ClassPathXmlApplicatonContext過程中，核心初始化邏輯在AbstractApplicationContext的refresh函式中： public void refresh() throws BeansException, IllegalStateE

spring 在單例類中使用註解注入bean

/** * @author: jerry * @Email: * @Company: * @Action: 日誌處理工具類 * @DATE: 2016-9-19 */ @Component//泛指元件，當元件不好歸類的時候，我們可以使用這個註解進行標註 p

Spring方法注入非單例bean的呼叫

引用 在大部分情況下，容器中的bean都是singleton型別的。如果一個singleton bean要引用另外一個singleton bean，或者一個非singleton bean要引用另外一個非singleton bean時，通常情況下將一個bean定義為另一個be

spring原始碼（10）從快取中獲取到單例bean的後續操作（對FactoryBean的處理）

從快取中獲取到例項，doGetBean第一步就是對我們輸入的name做了處理。 去除FactoryBean的修飾符，也就是name=”&a”，最終處理為name=”a” 取指定別名最終所指向的beanName 在從快取中獲取例項時，getSi

Spring注入非單例bean以及scope的作用範圍

一、 問題描述 在大部分情況下，容器中的bean都是singleton型別的。 如果一個singleton bean要引用另外一個singleton bean，或者一個非singleton bean要引用另外一個非singleton bean時，通常情況下將一個b

spring注入非單例bean及scope的作用範圍

一、 問題描述 在大部分情況下，容器中的bean都是singleton型別的。 如果一個singleton bean要引用另外一個singleton bean，或者一個非singleton bean要引用另外一個非singleton bean時，通常情況下將一個b

Spring 原始碼學習 - 單例bean的例項化過程

> 本文作者：geek，一個聰明好學的同事 ## 1. 簡介 開發中我們常用@Commpont，@Service，@Resource等註解或者配置xml去宣告一個類，使其成為spring容器中的bean，以下我將用從原始碼角度看以AnnotationConfigApplicationContext

死磕Spring之IoC篇 - 單例 Bean 的迴圈依賴處理

> 該系列文章是本人在學習 Spring 的過程中總結下來的，裡面涉及到相關原始碼，可能對讀者不太友好，請結合我的原始碼註釋 [Spring 原始碼分析 GitHub 地址](https://github.com/liu844869663/spring-framework) 進行閱讀 > > Spring 版

Spring -11 -單例設計模式 -懶漢式/餓漢式(idea預設的)

單例設計模式 作用: 在應用程式有保證最多隻能有一個例項. 好處: 　　2.1 提升執行效率. 　　2.2 實現資料共享. 案例:application 物件 懶漢式 　　3.1 物件只有被呼叫時才去建立.