Spring IOC（一）體系結構

Spring IOC（一）體系結構

Spring 系列目錄(http://www.javashuo.com/article/p-kqecupyl-bm.html)

BeanFactory 是Spring IOC 容器的鼻祖，是 IOC 容器的基礎接口，全部的容器都是從它這裏繼承實現而來，可見其地位。BeanFactory 提供了最基本的 IOC 容器的功能，即全部的容器至少須要實現的標準。

1、BeanFactory

public interface BeanFactory {

    String FACTORY_BEAN_PREFIX = "&";

    // 1. getBean
    Object getBean(String name) throws BeansException;
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    Object getBean(String name, Object... args) throws BeansException;
    <T> T getBean(Class<T> requiredType) throws BeansException;

    // 2. @since 5.1
    <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
    <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

    // 3. containsBean
    boolean containsBean(String name);

    // 4. 單例、多例。 bean 的生命週期
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

    // 5. 匹配 bean 的 Class 類型或泛型(ResolvableType)
    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

    // 6. 其它屬性
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    String[] getAliases(String name);
}

這些接口定義勾畫出了 IOC 容器的基本方法特性。BeanFactory 功能以下：

1. BeanFactory 是 Spring 容器的 Root Interface
2. BeanFactory 持有 BeanDefinition，每個 bean 都有獨有的名字。BeanFactory 能夠返回單例或多例的對象，取決於 Bean 定義文件。
3. 能夠經過 setters，constructors 進行依賴注入更好，其實這也是經常使用的方法。
4. BeanFactory 經過載入配置源文件(XML 文件)的方式，來配置 Bean。
5. BeanFactory 支持的 bean 生命週期的順序。有如下接口：
   1. BeanNameAware#setBeanName
   2. BeanClassLoaderAware#setBeanClassLoader
   3. BeanFactoryAware#setBeanFactory
   4. ResourceLoaderAware#setResourceLoader
   5. ApplicationEventPublisherAware#setApplicationEventPublisher
   6. MessageSourceAware#setMessageSource
   7. ApplicationContextAware#setApplicationContext
   8. ServletContextAware#setServletContext
   9. BeanPostProcessors#postProcessBeforeInitialization
   10. InitializingBean#afterPropertiesSet
   11. a custom init-method definition
   12. BeanPostProcessors#postProcessAfterInitialization
   13. DisposableBean#destroy
   14. a custom destroy-method definition

BeanFactory 做爲最頂層的一個接口類，它定義了 IOC 容器的基本功能規範，BeanFactory 有三個直接子類接口：ListableBeanFactory、HierarchicalBeanFactory 和 AutowireCapableBeanFactory，還有一個實現類 SimpleJndiBeanFactory。因此接下來依次分析三個子接口。

2、HierarchicalBeanFactory 可分層次 BeanFactory

從 HierarchicalBeanFactory 接口開始就有了父子工廠的概念。

public interface HierarchicalBeanFactory extends BeanFactory {
    // 1. 獲取父工廠
    BeanFactory getParentBeanFactory();
    // 2. 在當前工廠(不向上查找父工廠)中獲取指定的 bean
    boolean containsLocalBean(String name);
}

3、ListableBeanFactory 可枚舉的 BeanFactory

從 ListableBeanFactory 接口開始能夠枚舉出本工廠生產的全部 bean 了。

public interface ListableBeanFactory extends BeanFactory {
    // 1. 查找 BeanDefinition
    boolean containsBeanDefinition(String beanName);
    int getBeanDefinitionCount();
    String[] getBeanDefinitionNames();

    // 2. 根據類型查找全部 bean 的名稱，包括 FactoryBean
    //    includeNonSingletons=false 表示只取單例；
    //    allowEagerInit=true 表示當即加載，false 表示延遲加載。注意：FactoryBean 都是馬上加載的
    String[] getBeanNamesForType(Class<?> type);
    String[] getBeanNamesForType(Class<?> type, boolean includeNonSingletons, 
        boolean allowEagerInit);

    // 3. 根據類型查找全部 bean，返回 <beanName, bean>
    <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException;
    <T> Map<String, T> getBeansOfType(Class<T> type, boolean includeNonSingletons, 
        boolean allowEagerInit) throws BeansException;

    // 4.1 根據類上的註解類型查找指定的 bean
    String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);
    Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) 
        throws BeansException;
    // 4.2 查找指定 bean 上的註解
    <A extends Annotation> A findAnnotationOnBean(String beanName, 
        Class<A> annotationType) throws NoSuchBeanDefinitionException;
}

總結一下：

1. 從這個工廠接口開始，能夠枚舉列出工廠能夠生產的全部實例。便可以只查找 beanName，也能夠查找對應的對象實例。
2. 從這個工廠接口開始，BeanDefinition 登場了。
3. 注意若是是一個層次繼承的工廠，則只會列出當前工廠的實例，而不會列出祖先層的實例。

4、AutowireCapableBeanFactory 可自動裝配的 BeanFactory

從 AutowireCapableBeanFactory 接口開始能夠自動裝配 bean 了。

AutowireCapableBeanFactory 直接繼承自 BeanFacotory，它擴展了自動裝配的功能，根據類定義 BeanDefinition 裝配 Bean、執行後置處理器等。值得注意的是，這個接口並無被 ApplicationContext 繼承，由於應用程序幾乎不用用到這些接口，固然也能夠經過 ApplicationContext#getAutowireCapableBeanFactory() 得到這個 BeanFactory 實例。

public interface AutowireCapableBeanFactory extends BeanFactory {

    // 1. 自動裝配的模式，AUTOWIRE_AUTODETECT 已廢棄
    int AUTOWIRE_NO = 0;
    int AUTOWIRE_BY_NAME = 1;
    int AUTOWIRE_BY_TYPE = 2;
    int AUTOWIRE_CONSTRUCTOR = 3;
    int AUTOWIRE_AUTODETECT = 4;

    //-------------------------------------------------------------------------
    // Typical methods for creating and populating external bean instances
    //-------------------------------------------------------------------------
    // 2. 默認的方式建立、自動裝配、配置 bean
    <T> T createBean(Class<T> beanClass) throws BeansException;
    void autowireBean(Object existingBean) throws BeansException;
    Object configureBean(Object existingBean, String beanName) throws BeansException;

    //-------------------------------------------------------------------------
    // Specialized methods for fine-grained control over the bean lifecycle
    //-------------------------------------------------------------------------
    // 3. 根據給定的策略，建立、自動裝配、配置 bean
    Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
    Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
    void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
            throws BeansException;

    // 4. bean 屬性注入
    void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;

    // 5. bean 生命週期相關的初始化，如 BeanFactoryAware#setBeanFactory、InitializingBean#afterPropertiesSet
    Object initializeBean(Object existingBean, String beanName) throws BeansException;
    void destroyBean(Object existingBean);

    // 6. 後置處理器 BeanPostProcessors 執行
    Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
            throws BeansException;
    Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException;

    // 7. 
    <T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;

    // 8. 屬性注入時根據類型查找依賴，支持 List<BeanA> list 集合類型注入
    Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) 
            throws BeansException;
    Object resolveDependency(DependencyDescriptor descriptor, String beanName,
            Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException;
}

總結一下：

1. 首先幾個屬性，是裝配策略：
   • AUTOWIRE_BY_NAME：把與 Bean 的屬性具備相同的名字的其餘 Bean 自動裝配到這個屬性上。舉個例子就是：當有一個屬性名字爲 person 時，則自動裝配策略選擇 id 爲 person 的 Bean 進行裝配。
   • AUTOWIRE_BY_TYPE：把與 Bean 的屬性具備相同的類型的其餘 Bean 自動裝配到這個屬性。
   • AUTOWIRE_BY_CONSTRUCT：把與 bean 的構造器入參具備相同類型的其餘 Bean 自動裝配到 Bean 構造器的對應參數中。

2. 還有兩類方法，實際上工做中不多直接用這幾個接口

   • Typical methods for creating and populating external bean instances，該類是用來根據典型方法默認建立 Bean 和裝配 Bean 的方法。
   • Specialized methods for fine-grained control over the bean lifecycle，該類是用來根據裝配策略細化裝配，具體控制 Bean 生命週期的方法。

實現類爲 AbstractAutowireCapableBeanFactory。還有兩個配置的接口 ConfigurableBeanFactory 和 ConfigurableListableBeanFactory 也須要關注一下。

5、ConfigurableBeanFactory 配置 BeanFactory

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
    String SCOPE_SINGLETON = "singleton";
    String SCOPE_PROTOTYPE = "prototype";

    // 1. 父工廠 
    void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;

    // 2. ClassLoader
    void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);
    ClassLoader getBeanClassLoader();

    void setTempClassLoader(@Nullable ClassLoader tempClassLoader);
    ClassLoader getTempClassLoader();

    // 3. 緩存
    void setCacheBeanMetadata(boolean cacheBeanMetadata);
    boolean isCacheBeanMetadata();

    // 4. Spring el 表達式解析器
    void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);
    BeanExpressionResolver getBeanExpressionResolver();

    // 5.1 ConversionService  類型轉換
    void setConversionService(@Nullable ConversionService conversionService);
    ConversionService getConversionService();

    // 5.2 PropertyEditor 類型轉換
    void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);
    void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);
    void copyRegisteredEditorsTo(PropertyEditorRegistry registry);

    // 5.3 類型轉換
    void setTypeConverter(TypeConverter typeConverter);
    TypeConverter getTypeConverter();

    // 6. ${key} 佔位符解析
    void addEmbeddedValueResolver(StringValueResolver valueResolver);
    boolean hasEmbeddedValueResolver();
    String resolveEmbeddedValue(String value);

    // 7. 後置處理器
    void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
    int getBeanPostProcessorCount();

    // 8. 
    void registerScope(String scopeName, Scope scope);
    String[] getRegisteredScopeNames();
    Scope getRegisteredScope(String scopeName);

    AccessControlContext getAccessControlContext();

    // 9. copy 配置
    void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

    // 10. bean 別名註冊
    void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;
    void resolveAliases(StringValueResolver valueResolver);

    // 11. BeanDefinition
    BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    // 12. FactoryBean
    boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;

    // 13. bean 建立狀態
    void setCurrentlyInCreation(String beanName, boolean inCreation);
    boolean isCurrentlyInCreation(String beanName);

    // 14. 註冊依賴
    void registerDependentBean(String beanName, String dependentBeanName);
    String[] getDependentBeans(String beanName);
    String[] getDependenciesForBean(String beanName);

    // 15. 銷燬 bean
    void destroyBean(String beanName, Object beanInstance);
    void destroyScopedBean(String beanName);
    void destroySingletons();
}

實現類爲 AbstractBeanFactory。

6、ConfigurableListableBeanFactory 集大成者

提供解析，修改 bean定義，並與初始化單例。

public interface ConfigurableListableBeanFactory
        extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {

    // 1. 忽略依賴檢查，如 String/BeanFacory
    void ignoreDependencyType(Class<?> type);
    void ignoreDependencyInterface(Class<?> ifc);

    // 2. 註冊依賴關係
    void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);

    // 3. 依賴注入時查找是不是能夠依賴的 bean
    boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
            throws NoSuchBeanDefinitionException;

    // 4. BeanDefinition 和 bean 遍歷
    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    Iterator<String> getBeanNamesIterator();

    // 5. 清除不能緩存的 BeanDefinition，當 configurationFrozen=true 時能夠緩存
    void clearMetadataCache();
    // 5.2 configurationFrozen=true 時緩存 BeanDefinition 信息
    void freezeConfiguration();
    boolean isConfigurationFrozen();

    // 6. 實例化非懶加載的 bean
    void preInstantiateSingletons() throws BeansException;
}

實現類爲 DefaultListableBeanFactory。

此外 Spring BeanFactory 的實現還有三個重要的實現類，功能以下：

• AbstractBeanFactory 實現了 BeanFactory、 HierarchicalBeanFactory、ConfigurableBeanFactory 三個接口，最重要的方法是實現了 getBean(beanName) 接口，這個方法的最重要的步驟-建立 bean 則委託給模板方法 createBean 完成。

• AbstractAutowireCapableBeanFactory 實現了 AutowireCapableBeanFactory 接口，也就是依賴注入。同時實現了 crcreateBean(beanName, mbd, args) 建立 bean 的三個重要過程：實例化(createBeanInstance)、依賴注入(populateBean)、初始化(initializeBean)。其中依賴注入又分爲 autowireByName 和 autowireByType 二種，其中名稱查找很簡單，而類型查找就複雜了不少。Spring 將類型查找委託給了子類的 resolveDependency 完成。

• DefaultListableBeanFactory 實現了 ConfigurableListableBeanFactory、BeanDefinitionRegistry 兩個接口，提供了 Bean 和 BeanDefinition 查找註冊的功能。 這個類一個很重要的功能是實現了模板方法 resolveDependency，這樣就能夠根據類型查找依賴。

---

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