Spring BeanFactory 生命週期

首先放一張圖:

 

說明:

1.對於spring的BeanFactory生命週期.咱們能夠根據bean的建立來定製化實現咱們須要的功能.

容器後處理器定製化使用方法:

@Component
public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {


    /**
     * 預測最終今後返回的bean的類型
     * 處理器的{@link #postProcessBeforeInstantiation}回調。
     * <p>默認實現返回{@code null}。</p>
     *
     * @param beanClass bean的原始類
     * @param beanName  bean的名稱
     * @return bean的類型，若是不可預測，則返回{@code null}
     * @throws org.springframework.beans.BeansException，發成錯誤拋出
     */
    @Override
    public Class<?> predictBeanType(Class<?> beanClass, String beanName) {
        if ("userService".equals(beanName))
            System.out.println("開始調用:predictBeanType" + beanClass.getName() + "--->" + beanName);
        return super.predictBeanType(beanClass, beanName);
    }

    /**
     * 肯定用於給定bean的候選構造函數。
     * <p>默認實現返回{@code null}。</p>
     *
     * @param beanClass bean的原始類（從不{@code null}）
     * @param beanName  bean的名稱
     * @return 候選構造函數，若是沒有指定，則爲{@code null}
     * @throws org.springframework.beans.BeansException，若是有錯誤
     */
    @Override
    public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
        if ("userService".equals(beanName))
            System.out.println("開始調用:determineCandidateConstructors" + beanName);
        return super.determineCandidateConstructors(beanClass, beanName);
    }

    /**
     * 獲取早期訪問指定bean的引用，
     * 一般用於解析循環引用。
     * <p>此回調使後處理器有機會公開包裝器早期 - 也就是說，在目標bean實例徹底初始化以前,暴露的物體應該等同於什麼</p>
     * {@link #postProcessBeforeInitialization}或{@link #postProcessAfterInitialization}
     * 不然會暴露。請注意，此方法返回的對象將是
     * 用做bean引用，除非後處理器返回不一樣的內容
     * 來自所述後處理回調的包裝器。換句話說：那些後期處理
     * 回調可能最終暴露相同的引用或者替代
     * 從後續回調中返回原始bean實例（若是是包裝器
     * 已經構建了受影響的bean，用於調用此方法，
     * 默認狀況下它將做爲最終bean引用公開）。
     * <p>默認實現按原樣返回給定的{@code bean}。</p>
     *
     * @param bean     原始bean實例
     * @param beanName bean的名稱
     * @return 將對象公開爲bean引用 （一般使用傳入的bean實例做爲默認值）
     * @throws org.springframework.beans.BeansException，若是有錯誤
     */
    @Override
    public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName))
            System.out.println("開始調用:getEarlyBeanReference" + beanName);
        return super.getEarlyBeanReference(bean, beanName);
    }


    /**
     * 在目標bean實例化以前應用此BeanPostProcessor 。
     * 返回的bean對象能夠是代替目標bean使用的代理,有效地抑制目標bean的默認實例化。
     * <p>若是此方法返回非null對象，則爲bean建立過程將被短路。應用的惟一進一步處理是</p>
     * {@link #postProcessAfterInitialization}來自配置的回調
     * {@link org.springframework.beans.factory.config.BeanPostProcessor BeanPostProcessors}。
     * <p>此回調僅適用於具備bean類的bean定義。
     * 特別是，它不會應用於具備工廠方法的bean。
     * </p>後處理器能夠實現擴展
     * {@link org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor}接口按順序排列
     * 預測它們將在這裏返回的bean對象的類型。
     * <p>默認實現返回{@code null}。</p>
     *
     * @param beanClass 要實例化的bean的類
     * @param beanName  bean的名稱
     * @return bean對象公開而不是目標bean的默認實例或{@code null}繼續進行默認實例化
     * @throws org.springframework.beans.BeansException，若是有錯誤
     * @see #postProcessAfterInstantiation
     * @see org.springframework.beans.factory.support.AbstractBeanDefinition #hasBeanClass
     */
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if ("userService".equals(beanName))
            System.out.println("開始調用:postProcessBeforeInstantiation" + beanName);
        return super.postProcessBeforeInstantiation(beanClass, beanName);
    }


    /**
     * 經過構造函數或工廠方法實例化bean以後執行操做，
     * 可是在Spring屬性人口（來自顯式屬性或自動裝配）以前發生。
     * <p>這是在給定bean上執行自定義字段注入的理想回調
     * 實例，就在Spring的自動裝配開始以前。
     * </p>默認實現返回{@code true}。
     *
     * @param bean     建立的bean實例，其屬性還沒有設置
     * @param beanName bean的名稱
     * @return {@code true}若是要在bean上設置屬性; {@code false}
     * 若是應該跳過財產人口。 正常實現應返回{@code true}。
     * 返回{@code false}也會阻止任何後續的 InstantiationAwareBeanPostProcessor
     * 在此bean實例上調用實例。
     * @throws org.springframework.beans.BeansException，若是有錯誤
     * @see #postProcessBeforeInstantiation
     */
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName))
            System.out.println("開始調用:postProcessAfterInstantiation" + beanName);
        return super.postProcessAfterInstantiation(bean, beanName);
    }


    /**
     * 在工廠應用以前對給定的屬性值進行後處理
     * 到給定的bean，不須要屬性描述符。
     * <p>若是實現提供自定義，則實現應返回{@code null}（默認值）</p>
     * {@link #postProcessPropertyValues}實現，不然{@code pvs}。
     * 在此界面的將來版本中（刪除了{@link #postProcessPropertyValues}），
     * 默認實現將直接返回給定的{@code pvs}。
     *
     * @param pvs      工廠即將應用的屬性值（從不{@code null}）
     * @param bean     建立了bean實例，但其屬性還沒有設置
     * @param beanName bean的名稱
     * @return 要應用於給定bean的實際屬性值（能夠是傳入的 PropertyValues實例），或{@code null}繼續使用現有屬性
     * 但特別是繼續調用{@link #postProcessPropertyValues}（要求爲當前bean類初始化{@code PropertyDescriptor}）
     * @throws org.springframework.beans.BeansException，若是有錯誤
     * @see #postProcessPropertyValues
     * @since 5.1
     */
    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName))
            System.out.println("開始調用:postProcessPropertyValues" + beanName);
        return super.postProcessPropertyValues(pvs, pds, bean, beanName);
    }


    /**
     * 在任何bean以前，將此BeanPostProcessor應用於給定的新bean實例
     * 初始化回調（如InitializingBean的{@code afterPropertiesSet}或自定義init方法）。 bean已經填充了屬性值。
     * 返回的bean實例多是原始實例的包裝器。
     * <p>默認實現按原樣返回給定的{@code bean}。</p>
     *
     * @param bean     新的bean實例
     * @param beanName bean的名稱
     * @return 要使用的bean實例，不管是原始實例仍是包裝實例; 若是{@code null}，則不會調用後續的BeanPostProcessors
     * @throws org.springframework.beans.BeansException，若是有錯誤
     * @see org.springframework.beans.factory.InitializingBean #afterPropertiesSet
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName))
            System.out.println("開始調用:postProcessBeforeInitialization" + beanName);
        return super.postProcessBeforeInitialization(bean, beanName);
    }


    /**
     * 在任何bean以後，將此BeanPostProcessor應用於給定的新bean實例
     * 初始化回調(如InitializingBean的{@code afterPropertiesSet}或自定義init方法)。 bean已經填充了屬性值。
     * 返回的bean實例多是原始實例的包裝器。
     * <p>若是是FactoryBean，將爲FactoryBean調用此回調實例和FactoryBean建立的對象（從Spring 2.0開始）。
     * 該後處理器能夠決定是應用於FactoryBean仍是建立
     * 對象或二者經過相應的{@code bean instanceof FactoryBean}檢查。</p>
     * <p>在a觸發短路後也會調用此回調</p>
     * {@link org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor＃postProcessBeforeInstantiation}方法，與全部其餘BeanPostProcessor回調相反。
     * <p>默認實現按原樣返回給定的{@code bean}。</p>
     *
     * @param bean     新的bean實例
     * @param beanName bean的名稱
     * @return 要使用的bean實例，不管是原始實例仍是包裝實例;
     * 若是{@code null}，則不會調用後續的BeanPostProcessors
     * @throws org.springframework.beans.BeansException，若是有錯誤
     * @see org.springframework.beans.factory.InitializingBean #afterPropertiesSet
     * @see org.springframework.beans.factory.FactoryBean
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName))
            System.out.println("開始調用:postProcessAfterInitialization" + beanName);
        return super.postProcessAfterInitialization(bean, beanName);
    }
}

 

整理一下:

bean生命週期接口有:

BeanNameAware, BeanFactoryAware, InitializingBean, DisposableBean

bean容器後處理器通常繼承:

InstantiationAwareBeanPostProcessorAdapter

 

簡要描述就是,啓動容器: 預測bean返回的類型 --> 實例化前處理 --> 肯定bean構造函數  --> 構造bean --> 實例化後處理 --> 設置bean屬性值 --> 調用bean初始化的生命週期接口 --> spring緩存池準備就緒. --> 調用bean生命週期的銷燬方法 -> 銷燬.