Spring Framework 源碼閱讀（六）：BeanFactory自頂向下

​

​BeanFactory​

​​接口是通路​

​Spring bean​

​​容器的根接口。它是​

​Spring bean​

​​容器的基本視圖； 子接口​

​HierarchicalBeanFactory​

​​、​

​ListableBeanFactory​

​​、以及​

​AutowireCapableBeanFactory​

​可用于特定目的，下文會進行介紹。

​

​BeanFactory​

​接口的源碼：

public interface BeanFactory {

  String FACTORY_BEAN_PREFIX = "&";

  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;

  <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

  <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
  
  <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

  boolean containsBean(String name);

  boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

  boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

  boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

  boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

  @Nullable
  Class<?> getType(String name) throws NoSuchBeanDefinitionException;

  @Nullable
  Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;

  String[] getAliases(String name);
}      

• ​

  ​FACTORY_BEAN_PREFIX​

  ​​：如果名為​

  ​myBean​

  ​​的​

  ​bean​

  ​​是​

  ​FactoryBean​

  ​​，則擷取​

  ​&myBean​

  ​​将傳回工廠，而不是工廠傳回的執行個體（通過​

  ​getObject​

  ​​方法），想要更加詳細的了解​

  ​FactoryBean​

  ​，可以閱讀：​​Spring Framework 源碼閱讀（三）：認識FactoryBean​​。
• ​

  ​getBean​

  ​​：傳回指定​

  ​bean​

  ​​的一個執行個體，​

  ​name​

  ​​是要擷取的​

  ​bean​

  ​​的名稱、​

  ​requiredType​

  ​​是要擷取的​

  ​bean​

  ​​的類型（可以是接口或超類）、​

  ​args​

  ​​是使用顯式參數建立​

  ​bean​

  ​時使用的參數（僅在建立新執行個體而不是檢索現有執行個體時應用）。
• ​

  ​getBeanProvider​

  ​​：傳回指定​

  ​bean​

  ​​的提供者。​

  ​requiredType​

  ​​是指定​

  ​bean​

  ​​的類型（​

  ​Class<T>​

  ​​和​

  ​ResolvableType​

  ​​隻是不同的指定形式而已，​

  ​ResolvableType​

  ​​封裝了​

  ​Java​

  ​​ 中的​

  ​Type​

  ​）。
• ​

  ​containsBean​

  ​​：是否存在給定名稱的​

  ​bean​

  ​。
• ​

  ​isSingleton​

  ​​和​

  ​isPrototype​

  ​​：給定名稱的​

  ​bean​

  ​​是否是單例​

  ​bean​

  ​​和是否是原型​

  ​bean​

  ​。
• ​

  ​isTypeMatch​

  ​​：檢查給定名稱的​

  ​bean​

  ​是否與指定的類型比對。
• ​

  ​getType​

  ​​：傳回給定名稱的​

  ​bean​

  ​​的類型，​

  ​allowFactoryBeanInit​

  ​​表示如果沒有可用的類型資訊，可以對未初始化的​

  ​FactoryBean​

  ​進行初始化。
• ​

  ​getAliases​

  ​​：傳回給定名稱的​

  ​bean​

  ​的别名。

可見​

​BeanFactory​

​​接口對​

​Spring bean​

​容器的通用方法做了定義（基于業務的抽象）。

​

​BeanFactory​

​接口的子接口如下圖所示：

HierarchicalBeanFactory

​

​HierarchicalBeanFactory​

​​接口的主要作用是對​

​bean​

​​工廠進行分層，像​

​Java​

​​類有父子關系，以及​

​bean​

​​也存在父子關系，其實​

​BeanFactory​

​​也有父子關系，這種父子關系的好處，可以類比​

​Java​

​​類與​

​bean​

​​，類通過繼承，子類可以很友善的擁有父類的方法和屬性，而​

​bean​

​​通過父子關系，可以很友善的擁有父​

​bean​

​​的一些配置。而​

​BeanFactory​

​​的父子關系，可以很容易想到的好處，就是子​

​BeanFactory​

​​可以通路父​

​BeanFactory​

​​中的資訊，比如建立的​

​bean​

​​以及注冊的​

​bean​

​​定義等資訊。其實到更大的範疇也存在父子關系，比如應用上下文（​

​ApplicationContext​

​）的父子關系，這裡先不讨論，以後部落客會詳細介紹應用上下文的内容。

​

​HierarchicalBeanFactory​

​接口源碼：

public interface HierarchicalBeanFactory extends BeanFactory {

    // 傳回父bean工廠，如果沒有，則傳回null
    @Nullable
    BeanFactory getParentBeanFactory();

    // 傳回本地bean工廠是否包含給定名稱的bean
    // 這是containsBean的替代方法，忽略來自祖先bean工廠中給定名稱的bean
    boolean containsLocalBean(String name);
}      

ListableBeanFactory

​

​BeanFactory​

​​接口的擴充，可以枚舉其所有​

​bean​

​​的​

​BeanFactory​

​​實作，而不是通過名稱逐一嘗試查找​

​bean​

​​。預加載所有​

​bean​

​​定義的​

​BeanFactory​

​​實作（例如基于​

​XML​

​的工廠）可以實作此接口。

​

​ListableBeanFactory​

​接口源碼：

public interface ListableBeanFactory extends BeanFactory {

    // 檢查此bean工廠是否包含給定名稱的bean定義
    boolean containsBeanDefinition(String beanName);

    // 傳回工廠中bean定義的數量
    int getBeanDefinitionCount();
    
    // 傳回工廠中所有bean定義的名稱
    String[] getBeanDefinitionNames();

    // 傳回與給定類型（包括子類）比對的bean的名稱
    String[] getBeanNamesForType(ResolvableType type);
    String[] getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit);
    String[] getBeanNamesForType(@Nullable Class<?> type);
    String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);

    // 傳回與給定類型（包括子類）比對的bean
    <T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;
    <T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
            throws BeansException;
            
    // 查找使用annotationType類型注解的所有bean的名稱，而不建立相應的bean
    String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);
    
    // 查找使用annotationType類型注解的所有bean，傳回帶有相應bean的bean名稱的Map
    Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;
    
    // 在指定的bean上找到annotationType類型的Annotation注解
    @Nullable
    <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
            throws NoSuchBeanDefinitionException;
}      

AutowireCapableBeanFactory

​

​BeanFactory​

​​接口的擴充，能夠自動裝配的​

​BeanFactory​

​​。其他架構的內建代碼可以利用此接口來裝配和填充​

​Spring​

​​無法控制其生命周期的現有​

​bean​

​執行個體。

主要是為了裝配​

​ApplicationContext​

​​管理之外的​

​bean​

​。

​

​AutowireCapableBeanFactory​

​接口源碼：

public interface AutowireCapableBeanFactory extends BeanFactory {
    // 表示沒有外部定義的自動裝配的常量
    int AUTOWIRE_NO = 0;

    // 按名稱自動裝配bean屬性的常量
    int AUTOWIRE_BY_NAME = 1;
  
    // 按類型自動裝配bean屬性的常量
    int AUTOWIRE_BY_TYPE = 2;

    // 通過構造函數自動裝配bean屬性的常量
    int AUTOWIRE_CONSTRUCTOR = 3;

    // 表示通過bean類的内部檢測來确定适當的自動裝配bean屬性政策的常量
    @Deprecated
    int AUTOWIRE_AUTODETECT = 4;

    // 初始化現有bean執行個體時，“原始執行個體”約定的字尾：附加到完全限定的bean類名，例如“com.mypackage.MyClass.ORIGINAL”，以強制傳回給定的執行個體，即沒有代理等
    String ORIGINAL_INSTANCE_SUFFIX = ".ORIGINAL";

    // 完整地建立給定類的新bean執行個體
    // 執行bean的完整初始化，包括所有适用的BeanPostProcessors
    <T> T createBean(Class<T> beanClass) throws BeansException;

    // 通過應用after-instantiation callbacks和bean property post-processing（例如，用于注解驅動的注入）填充給定的bean執行個體
    void autowireBean(Object existingBean) throws BeansException;
    
    // 配置給定的原始bean：自動裝配bean屬性、應用bean屬性值、應用工廠回調（例如setBeanName和setBeanFactory) ，以及應用所有bean後處理器
    Object configureBean(Object existingBean, String beanName) throws BeansException;

    // 使用指定的自動裝配政策完整建立給定類的新bean執行個體
    Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

    // 使用指定的自動裝配政策執行個體化給定類的新bean執行個體
    Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

    // 按名稱或類型自動裝配給定bean執行個體的bean屬性
    void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
            throws BeansException;

    // 将給定名稱的bean定義的屬性值應用于給定的bean執行個體
    void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;

    // 初始化給定的原始bean，應用工廠回調（例如setBeanName和setBeanFactory），還應用所有BeanPostProcessors
    Object initializeBean(Object existingBean, String beanName) throws BeansException;

    // 将BeanPostProcessors應用于給定的現有bean執行個體，調用它們的postProcessBeforeInitialization方法
    // 傳回的bean執行個體可能是原始執行個體的包裝器
    Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
            throws BeansException;

    // 将BeanPostProcessors應用于給定的現有bean執行個體，調用它們的postProcessAfterInitialization方法
    // 傳回的bean執行個體可能是原始執行個體的包裝器
    Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException;
            
    // 銷毀給定的bean執行個體
    void destroyBean(Object existingBean);

    // 解析與給定對象類型唯一比對的bean執行個體（如果有），包括其bean名稱
    <T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;

    // 為給定的bean名稱解析bean執行個體，提供用于暴露目标工廠方法的依賴項描述符
    Object resolveBeanByName(String name, DependencyDescriptor descriptor) throws BeansException;

    // 針對此工廠中定義的bean解析指定的依賴項
    @Nullable
    Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;
    @Nullable
    Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
            @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;

}      

目前介紹了​

​BeanFactory​

​​接口以及三個子接口（​

​HierarchicalBeanFactory​

​​、​

​ListableBeanFactory​

​​和​

​AutowireCapableBeanFactory​

​​）。​

​BeanFactory​

​​接口定義了​

​bean​

​​工廠的統一視圖（通用方法的定義），而三個子接口在此基礎上分别定義了​

​bean​

​​工廠分層（通過繼承關系）、​

​bean​

​​清單式管理以及自動裝配的功能。而這些還隻是一些定義，一般在應用上下文中使用的是​

​DefaultListableBeanFactory​

​類。它的繼承與實作關系如下圖所示：

接下來介紹​

​DefaultListableBeanFactory​

​類的其他超類和超接口。

SingletonBeanRegistry

為共享​

​bean​

​​執行個體定義系統資料庫的接口。可以通過​

​BeanFactory​

​​的實作來實作，以便以統一的方式公開它們的單例​

​bean​

​​管理工具。​

​ConfigurableBeanFactory​

​接口擴充了這個接口。

public interface SingletonBeanRegistry {

    // 在給定的bean名稱下，在bean系統資料庫中将給定的現有對象注冊為單例
    void registerSingleton(String beanName, Object singletonObject);

    // 傳回在給定名稱下注冊的（原始）單例對象
    @Nullable
    Object getSingleton(String beanName);

    // 檢查此系統資料庫是否包含具有給定名稱的單例執行個體
    // 隻檢查已經執行個體化的單例，對于尚未執行個體化的單例bean定義，不傳回true 
    boolean containsSingleton(String beanName);

    // 傳回在此系統資料庫中注冊的單例bean的名稱
    String[] getSingletonNames();
   
    // 傳回在此系統資料庫中注冊的單例bean的數量
    int getSingletonCount();

    // 傳回此系統資料庫使用的單例互斥鎖（用于外部協作者）
    Object getSingletonMutex();

}      

AliasRegistry

用于管理别名的通用接口。作為​

​BeanDefinitionRegistry​

​的超級接口。

public interface AliasRegistry {

    // 給定一個名稱，為其注冊一個别名
    void registerAlias(String name, String alias);
    
    // 從此系統資料庫中删除指定的别名
    void removeAlias(String alias);
    
    // 确定給定的名稱是否定義為别名
    boolean isAlias(String name);

    // 傳回給定名稱的别名
    String[] getAliases(String name);
}      

BeanDefinitionRegistry

持有​

​bean​

​​定義的系統資料庫的接口，例如​

​RootBeanDefinition​

​​和​

​ChildBeanDefinition​

​​執行個體。 通常由在内部使用 ​

​AbstractBeanDefinition​

​​層次結構的​

​BeanFactory​

​實作。

public interface BeanDefinitionRegistry extends AliasRegistry {

    // 使用此系統資料庫注冊一個新的bean定義
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException;

    // 删除給定名稱的bean定義
    void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    // 傳回給定bean名稱的bean定義
    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    // 檢查此系統資料庫是否包含具有給定名稱的bean定義
    boolean containsBeanDefinition(String beanName);

    // 傳回此系統資料庫中定義的所有bean的名稱
    String[] getBeanDefinitionNames();

    // 傳回系統資料庫中定義的bean數量
    int getBeanDefinitionCount();
    
    // 确定給定的bean名稱是否已在此系統資料庫中使用，即是否有本地bean或别名注冊在此名稱下
    boolean isBeanNameInUse(String beanName);
}      

SimpleAliasRegistry

​

​AliasRegistry​

​​接口的簡單實作。作為​

​BeanDefinitionRegistry​

​的實作的基類。

public class SimpleAliasRegistry implements AliasRegistry {

    /** Logger */
    protected final Log logger = LogFactory.getLog(getClass());

    /** 從别名映射到規範名稱 */
    private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);


    @Override
    public void registerAlias(String name, String alias) {
        ...
    }

    // 确定是否允許别名覆寫
    // 預設為true 
    protected boolean allowAliasOverriding() {
        return true;
    }

    // 确定給定的名稱是否已注冊給定的别名
    public boolean hasAlias(String name, String alias) {
        String registeredName = this.aliasMap.get(alias);
        return ObjectUtils.nullSafeEquals(registeredName, name) || (registeredName != null
                && hasAlias(name, registeredName));
    }

    @Override
    public void removeAlias(String alias) {
        synchronized (this.aliasMap) {
            String name = this.aliasMap.remove(alias);
            if (name == null) {
                throw new IllegalStateException("No alias '" + alias + "' registered");
            }
        }
    }

    @Override
    public boolean isAlias(String name) {
        return this.aliasMap.containsKey(name);
    }

    @Override
    public String[] getAliases(String name) {
        List<String> result = new ArrayList<>();
        synchronized (this.aliasMap) {
            retrieveAliases(name, result);
        }
        return StringUtils.toStringArray(result);
    }

    // 檢索給定名稱的所有别名
    private void retrieveAliases(String name, List<String> result) {
        ...
    }

    // 解析在此系統資料庫中注冊的所有别名目标名稱和别名，将給定的StringValueResolver應用于它們
    // 例如，值解析器可以解析目标bean名稱甚至别名中的占位符
    public void resolveAliases(StringValueResolver valueResolver) {
        ...
    }

    // 檢查給定的名稱是否已經作為另一個方向的别名指向給定的别名，預先捕獲循環引用并抛出相應的 IllegalStateException
    protected void checkForAliasCircle(String name, String alias) {
        ...
    }

    // 确定原始名稱，将别名解析為規範名稱
    public String canonicalName(String name) {
        ...
    }
}      

DefaultSingletonBeanRegistry

共享​

​bean​

​​執行個體的通用系統資料庫，實作​

​SingletonBeanRegistry​

​接口，方法太多了，主要看看裡面的屬性，就能大概知道它的作用了。

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    /** 單例對象緩存：bean名稱到bean執行個體 */
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

    /** 單例工廠緩存：bean名稱到ObjectFactory */
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

    /** 早期單例對象的緩存：bean名稱到bean執行個體 */
    private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);

    /** 已注冊的單例，包含按注冊順序排列的bean名稱 */
    private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

    /** 目前正在建立的bean的名稱 */
    private final Set<String> singletonsCurrentlyInCreation =
            Collections.newSetFromMap(new ConcurrentHashMap<>(16));

    /** 目前從建立檢查中排除的bean的名稱 */
    private final Set<String> inCreationCheckExclusions =
            Collections.newSetFromMap(new ConcurrentHashMap<>(16));

    /** 訓示目前是否在destroySingletons中的标志 */
    private boolean singletonsCurrentlyInDestruction = false;

    /** Disposable bean執行個體：bean名稱到Disposable bean執行個體*/
    private final Map<String, Object> disposableBeans = new LinkedHashMap<>();

    /** 包含bean名稱之間的映射：bean名稱到bean包含的bean名稱集 */
    private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);

    /** 依賴bean名稱之間的映射：bean名稱到依賴bean名稱集 */
    private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);

    /** 依賴bean名稱之間的映射：bean名稱到bean依賴項的bean名稱集 */
    private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
    
    ...
}      

FactoryBeanRegistrySupport

​

​FactoryBeanRegistrySupport​

​​抽象類繼承了​

​DefaultSingletonBeanRegistry​

​​類。支援需要處理​

​FactoryBean​

​​執行個體的單例系統資料庫的基類，作為​

​AbstractBeanFactory​

​基類。

ConfigurableBeanFactory

大多數​

​bean​

​​工廠要實作的配置接口。 除了​

​BeanFactory​

​​接口中的​

​bean​

​​工廠方法之外，還提供配置​

​bean​

​​工廠的工具。 這個擴充接口隻是為了允許架構内部的即插即用和對​

​bean​

​​工廠配置方法的特殊通路。該接口繼承了​

​HierarchicalBeanFactory​

​​和​

​SingletonBeanRegistry​

​這兩個接口。

​

​ConfigurableBeanFactory​

​接口源碼（删除了部分方法定義）：

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {

    // 标準單例作用域的辨別符“singleton”
    // 可以通過registerScope方法添加自定義作用域
    String SCOPE_SINGLETON = "singleton";

    // 标準原型作用域的辨別符“prototype”
    String SCOPE_PROTOTYPE = "prototype";

    // 設定這個bean工廠的父bean工廠
    void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;
    
    // 設定用于加載bean類的類加載器
    // 預設是線程上下文類加載器
    void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);

    // 指定用于類型比對目的的臨時類加載器， 預設為none，隻需使用标準bean ClassLoader
    // 如果涉及load-time weaving，通常隻指定臨時ClassLoader，以確定盡可能延遲加載實際的bean類
    // 一旦BeanFactory完成其引導階段，臨時加載器就會被删除
    void setTempClassLoader(@Nullable ClassLoader tempClassLoader);

    // 設定是否緩存bean中繼資料，例如給定的bean 定義（以合并方式）和解析的bean類
    // 預設開啟
    void setCacheBeanMetadata(boolean cacheBeanMetadata);

    // 為bean定義值中的表達式指定解析政策
    // 預設情況下，BeanFactory中沒有激活的表達式支援
    // ApplicationContext通常會在此處設定标準表達式政策，支援統一EL相容樣式中的“#{...}”表達式
    void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);

    // 添加一個新的BeanPostProcessor，它将應用于此工廠建立的bean
    void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);

    // 從給定的其他工廠複制所有相關配置
    // 應包括所有标準配置設定以及BeanPostProcessors、作用域和工廠特定的内部設定
    // 不應包含實際bean定義的任何中繼資料，例如BeanDefinition對象和bean名稱别名
    void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

    // 傳回給定bean名稱的合并BeanDefinition，如有必要，将子bean定義與其父級合并
    // 還要考慮祖先工廠中的bean定義
    BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    // 确定給定名稱的bean是否為FactoryBean
    boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;

    // 為給定的bean注冊一個依賴bean
    void registerDependentBean(String beanName, String dependentBeanName);

    // 傳回依賴于指定bean的所有bean的名稱
    String[] getDependentBeans(String beanName);

    // 傳回指定bean所依賴的所有bean的名稱
    String[] getDependenciesForBean(String beanName);
    
    // 根據其bean定義銷毀給定的bean執行個體
    void destroyBean(String beanName, Object beanInstance);
    
    // 銷毀此工廠中的所有單例bean
    void destroySingletons();
}      

ConfigurableListableBeanFactory

大多數​

​bean​

​​清單式管理的​

​bean​

​​工廠要實作的配置接口。 除了​

​ConfigurableBeanFactory​

​​接口的功能外，它還提供了分析和修改​

​bean​

​​定義以及預執行個體化單例的工具，繼承了​

​ListableBeanFactory​

​​、 ​

​AutowireCapableBeanFactory​

​​以及​

​ConfigurableBeanFactory​

​這三個接口。

​

​ConfigurableListableBeanFactory​

​接口源碼：

public interface ConfigurableListableBeanFactory
        extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
    
    // 忽略給定的自動裝配依賴類型：例如，字元串
    // 預設為空
    void ignoreDependencyType(Class<?> type);

    // 忽略給定的自動裝配依賴接口
    // 這通常由應用上下文用于注冊以其他方式解析的依賴項
    // 例如通過BeanFactoryAware裝配的BeanFactory或通過ApplicationContextAware裝配的ApplicationContext
    // 預設情況下，僅忽略BeanFactoryAware接口
    // 對于要忽略的其他類型，要為每種類型調用此方法
    void ignoreDependencyInterface(Class<?> ifc);

    // 使用相應的自動裝配值注冊一個特殊的依賴類型
    // 這适用于應該是可自動裝配但在工廠中未定義為bean的工廠或上下文
    // 例如，ApplicationContext類型的依賴項解析為bean所在的ApplicationContext執行個體
    void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);

    // 确定指定的bean是否有資格作為自動裝配候選者，以注入到聲明比對類型依賴項的其他bean中
    // 此方法也檢查祖先工廠
    boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
            throws NoSuchBeanDefinitionException;

    // 傳回指定bean的注冊BeanDefinition，允許通路其屬性值和構造函數參數值（可以在bean factory後處理期間修改）
    // 此方法不考慮父工廠，它僅用于通路此工廠的本地bean定義
    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    // 傳回此工廠管理的所有bean名稱的疊代器
    Iterator<String> getBeanNamesIterator();

    // 清除合并的bean定義緩存，删除認為尚不符合完整中繼資料緩存條件的bean的條目
    void clearMetadataCache();

    // 當機所有bean定義，表明注冊的bean定義不會被進一步修改或後處理
    void freezeConfiguration();

    // 傳回這個工廠的bean定義是否被當機，即不應該被進一步修改或後處理
    boolean isConfigurationFrozen();

    // 確定所有非延遲初始化單例都被執行個體化，同時考慮FactoryBean
    // 如果需要，通常在工廠設定結束時調用
    void preInstantiateSingletons() throws BeansException;
}      

AbstractBeanFactory

​

​BeanFactory​

​​的抽象基類，提供了​

​ConfigurableBeanFactory SPI​

​​ 的全部功能。 不假設為​

​bean​

​​清單式管理的​

​bean​

​​工廠，是以也可以用作​

​bean​

​​工廠實作的基類，這些實作從某些資源中擷取​

​bean​

​​定義（其中​

​bean​

​定義通路是一項昂貴的操作）。

此類提供單例緩存（通過基類​

​DefaultSingletonBeanRegistry​

​​) 、 ​

​FactoryBean​

​​處理、别名管理、​

​bean​

​​定義合并和​

​bean​

​​銷毀（ ​

​DisposableBean​

​​接口以及自定義銷毀方法） 。此外，它可以通過實作​

​HierarchicalBeanFactory​

​​接口來管理​

​bean factory​

​層次結構。

子類要實作的主要模闆方法是​

​getBeanDefinition​

​​和​

​createBean​

​​ ，分别為給定的​

​bean​

​​名稱檢索​

​bean​

​​定義和為給定的​

​bean​

​​定義建立​

​bean​

​​執行個體。 這些操作的預設實作可以在​

​DefaultListableBeanFactory​

​​和​

​AbstractAutowireCapableBeanFactory​

​找到，下面會進行介紹。

AbstractAutowireCapableBeanFactory

實作了預設的​

​bean​

​​建立方法的抽象​

​bean​

​​工廠超類，具有​

​RootBeanDefinition​

​​類指定的全部功能。 除了實作​

​AbstractBeanFactory​

​​的​

​createBean​

​​方法之外，還實作​

​AutowireCapableBeanFactory​

​接口。

提供​

​bean​

​​建立（具有構造函數解析）、屬性填充、裝配（包括自動裝配）和初始化。 處理運作時​

​bean​

​引用以及調用初始化方法等。支援按構造函數、名稱屬性和類型屬性的自動裝配。

子類要實作的主要模闆方法是​

​resolveDependency(DependencyDescriptor, String, Set, TypeConverter)​

​ ，用于按類型自動裝配。

此類不承擔或實作​

​bean​

​​定義系統資料庫功能。 有關​

​ListableBeanFactory​

​​和​

​BeanDefinitionRegistry​

​​接口的實作，請參閱​

​DefaultListableBeanFactory​

​​ ，它們分别代表此類工廠的​

​API​

​​和​

​SPI​

​視圖。

DefaultListableBeanFactory

​

​Spring​

​​對​

​ConfigurableListableBeanFactory​

​​和​

​BeanDefinitionRegistry​

​​這兩個接口的預設實作：一個基于​

​bean​

​​定義中繼資料的成熟 ​

​bean​

​​工廠，可通過後處理器（​

​post-processor​

​）擴充。

典型用法是在通路​

​bean​

​​之前首先注冊所有​

​bean​

​​定義（從​

​bean​

​​定義配置檔案中讀取）。 是以，按名稱查找​

​bean​

​​是在本地​

​bean​

​​定義表中的廉價操作，對預先解析的​

​bean​

​定義中繼資料對象進行操作。

​

​bean​

​​定義配置的讀取器通常是單獨實作的，而不是作為 ​

​bean​

​​工廠子類實作：例如​

​XmlBeanDefinitionReader​

​​、​

​AnnotatedBeanDefinitionReader​

​​以及​

​ClassPathBeanDefinitionScanner​

​​。因為​

​bean​

​​定義配置的讀取不屬于​

​BeanFactory​

​​的職責，基于單一職責的原則，這些讀取器通常是單獨實作的（基于​

​bean​

​​定義配置的類型，比如注解和​

​XML​

​）。

而這些讀取器通常在應用上下文中使用，比如​

​AnnotationConfigApplicationContext​

​​類中的​

​AnnotatedBeanDefinitionReader​

​​和​

​ClassPathBeanDefinitionScanner​

​：

​

​XmlWebApplicationContext​

​​類中的​

​XmlBeanDefinitionReader​

​：

​

​DefaultListableBeanFactory​

​類源碼（隻保留了屬性值）：

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

    /** 從序列化id映射到工廠執行個體 */
    private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =
            new ConcurrentHashMap<>(8);

    /** 此工廠的可選id，用于序列化目的 */
    @Nullable
    private String serializationId;

    /** 是否允許重新注冊具有相同名稱的不同bean定義 */
    private boolean allowBeanDefinitionOverriding = true;

    /** 即使對于lazy-init bean，是否也允許立即加載bean類 */
    private boolean allowEagerClassLoading = true;

    /** 依賴清單和數組的可選OrderComparator */
    @Nullable
    private Comparator<Object> dependencyComparator;

    /** 用于檢查bean定義是否是自動裝配候選者的解析器 */
    private AutowireCandidateResolver autowireCandidateResolver = SimpleAutowireCandidateResolver.INSTANCE;

    /** 從依賴類型映射到相應的自動裝配值 */
    private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);

    /** bean定義對象的映射，以bean名稱為鍵 */
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

    /** 從bean名稱映射到合并的BeanDefinitionHolder */
    private final Map<String, BeanDefinitionHolder> mergedBeanDefinitionHolders = new ConcurrentHashMap<>(256);

    /** 單例和非單例bean名稱的映射，以依賴類型為鍵 */
    private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);

    /** 單例bean名稱映射，以依賴類型為鍵 */
    private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64);

    /** bean定義名稱清單，按注冊順序排列 */
    private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

    /** 手動注冊的單例的名稱清單，按注冊順序排列 */
    private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);

    /** 在當機配置的情況下緩存的bean定義名稱數組 */
    @Nullable
    private volatile String[] frozenBeanDefinitionNames;

    /** 是否可以為所有bean緩存bean定義中繼資料 */
    private volatile boolean configurationFrozen;
    
    ...
}      

是以​

​DefaultListableBeanFactory​

​​類集合了非常多的功能，包括工廠分層管理、可配置工廠、​

​bean​

​​清單式管理、​

​bean​

​​定義管理、單例​

​bean​

​​管理、​

​bean​

​​别名管理、自動裝配以及​

​FactoryBean​

​​管理等。是以在應用上下文中通常使用​

​DefaultListableBeanFactory​

​​類作為預設的​

​bean​

​工廠。

​

​AbstractRefreshableApplicationContext​

​​抽象類（它是​

​XmlWebApplicationContext​

​類的超類）：

​

​GenericApplicationContext​

​​類（它是​

​AnnotationConfigApplicationContext​

​類的父類）：