最後的記憶——Spring BeanFactory

時間 2019-11-05

原文原文鏈接

本文嘗試分析一下Spring 的BeanFactory 體系的接口設計，嘗試理解爲何這麼作，爲何接口這麼設計、爲何這麼去實現，爲何須要有這個方法，爲何這樣命名？接口、類、方法的大體用途是什麼？是不是最合理的？是否有完善的空間？是否讓一個一樣頂級人才來設計，是否會獲得同樣的設計和實現？java

簡稱：web

BeanFactory 簡稱bfspring

ApplicationContext 簡稱ac
ServletContext 簡稱sc
BeanDefinition 簡稱bd數組

接口/類圖

bf的 uml 接口/類圖以下：安全

接口說明

================================================================== BeanFactory ====================================================================================================

BeanFactory（簡稱bf，下同）無疑是Spring最最最基礎的bean工廠，因此呢，它提供了最最最基礎、最最最經常使用(也是必須的)的接口： app

經過名字獲取bean，經過類型獲取bean，經過名字、參數獲取bean，經過類型、參數獲取bean，
是否包含給定名字的bean，經過bean名字判斷其是否單例，經過bean名字獲取類型
判斷給定名字的bean是否具備對應類型（ResolvableType、Class），經過名字獲取別名
———— 注意到bf 的get接口返回的都是單個bean ，並且返回的是實例！
———— 注意到bf 幾乎全是get接口，沒有set，why？讓bf簡單化，純粹化。只管獲取，具體的建立等工做交由了子接口、具體類去實現。。

ps：我的認爲這個接口設計得很是好！方法很少很多，毫無多餘，毫無遺漏！參數、返回值，很少很多，命名極爲工整、規範！

public interface BeanFactory {
String FACTORY_BEAN_PREFIX = "&";框架

Object getBean(String var1) throws BeansException;ide

<T> T getBean(String var1, @Nullable Class<T> var2) throws BeansException;post

Object getBean(String var1, Object... var2) throws BeansException;ui

<T> T getBean(Class<T> var1) throws BeansException;

<T> T getBean(Class<T> var1, Object... var2) throws BeansException;

boolean containsBean(String var1);

boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;

boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;

boolean isTypeMatch(String var1, ResolvableType var2) throws NoSuchBeanDefinitionException;

boolean isTypeMatch(String var1, @Nullable Class<?> var2) throws NoSuchBeanDefinitionException;

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

String[] getAliases(String var1);
}

================================================================== ListableBeanFactory ============================================================================================

ListableBeanFactory 有2個屬性：
Listable？可list？可列舉的；可列表的。什麼可列舉？能夠認爲BeanName 可列舉，還有就是：它有哪些bean，什麼名字，個數多少，哪些bean definition，各個類型bean ，有什麼樣的註解..
ListableBeanFactory 涉及到BeanDefinition，（簡稱bd，下同）爲何。這個Listable 應該同 DefaultListableBeanFactory, 主要針對 bean definition

具體來講：
是否包含給定名字的bd，獲取bd個數，獲取bd names數組集合，
經過類型獲取名字集合，經過類型獲取名字&實例集合，存在多個重載的方法，後面兩個boolean 參數分別是表示？
經過註解獲取名字集合，經過註解獲取名字&實例集合，
經過類型、參數獲取bean上的註解

allowEagerInit 有些很差解釋，留到後面再說
// public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit)

———— 爲何沒有獲取bd 的方法，而是僅僅獲取bd names數組集合？由其餘的bf 提供
———— 爲何這些接口，不移動部分到bf中去？我的感受可能不必，讓接口的方法精簡會更好！分工要明確，這樣，接口的實現纔會更加方便！

？？ResolvableType 和 Class 什麼區別，爲何會 ResolvableType？

public interface ListableBeanFactory extends BeanFactory {

boolean containsBeanDefinition(String var1);

int getBeanDefinitionCount();

String[] getBeanDefinitionNames();

String[] getBeanNamesForType(ResolvableType var1);

String[] getBeanNamesForType(@Nullable Class<?> var1);

String[] getBeanNamesForType(@Nullable Class<?> var1, boolean includeNonSingletons, boolean allowEagerInit);

<T> Map<String, T> getBeansOfType(@Nullable Class<T> var1) throws BeansException;

<T> Map<String, T> getBeansOfType(@Nullable Class<T> var1, boolean includeNonSingletons, boolean allowEagerInit) throws BeansException;

String[] getBeanNamesForAnnotation(Class<? extends Annotation> var1);

Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> var1) throws BeansException;

@Nullable
<A extends Annotation> A findAnnotationOnBean(String var1, Class<A> var2) throws NoSuchBeanDefinitionException;

================================================================== ConfigurableBeanFactory ============================================================================================

ConfigurableBeanFactory 繼承了 HierarchicalBeanFactory, SingletonBeanRegistry。另外 ClassLoader ，爲何要有ClassLoader 並且TempClassLoader ？

這個Configurable bf呢，什麼東西 Configurable呢？以下。另外須要注意的是他默認提供了 2個 scope 的支持。分別是單例、原型。並且還能夠註冊 scope，這個在 web ac中有用到。

簡單屬性有：

parentBeanFactory: BeanFactory
beanClassLoader: ClassLoader
tempClassLoader: ClassLoader
cacheBeanMetadata: boolean
beanExpressionResolver: BeanExpressionResolver
conversionService: ConversionService
typeConverter: TypeConverter
beanPostProcessorCount: int // getter
registeredScopeNames: String[]
accessControlContext: AccessControlContext // getter

簡單方法有：增長PropertyEditorRegistrar、CustomEditor、EmbeddedValueResolver、BeanPostProcessor、scope、Alias
addPropertyEditorRegistrar
registerCustomEditor
copyRegisteredEditorsTo
addEmbeddedValueResolver
hasEmbeddedValueResolver
resolveEmbeddedValue //
addBeanPostProcessor
registerScope //
getRegisteredScope
copyConfigurationFrom
registerAlias //
resolveAliases //
getMergedBeanDefinition //
isFactoryBean // 工廠bean
setCurrentlyInCreation //
isCurrentlyInCreation
registerDependentBean //
getDependentBeans //
getDependenciesForBean //
destroyBean // 此方法有兩個參數
destroyScopedBean
destroySingletons

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

void setParentBeanFactory(BeanFactory var1) throws IllegalStateException;

void setBeanClassLoader(@Nullable ClassLoader var1);

@Nullable
ClassLoader getBeanClassLoader();

void setTempClassLoader(@Nullable ClassLoader var1);

@Nullable
ClassLoader getTempClassLoader();

void setCacheBeanMetadata(boolean var1);

boolean isCacheBeanMetadata();

void setBeanExpressionResolver(@Nullable BeanExpressionResolver var1);

@Nullable
BeanExpressionResolver getBeanExpressionResolver();

void setConversionService(@Nullable ConversionService var1);

@Nullable
ConversionService getConversionService();

void addPropertyEditorRegistrar(PropertyEditorRegistrar var1);

void registerCustomEditor(Class<?> var1, Class<? extends PropertyEditor> var2);

void copyRegisteredEditorsTo(PropertyEditorRegistry var1);

void setTypeConverter(TypeConverter var1);

TypeConverter getTypeConverter();

void addEmbeddedValueResolver(StringValueResolver var1);

boolean hasEmbeddedValueResolver();

@Nullable
String resolveEmbeddedValue(String var1);

void addBeanPostProcessor(BeanPostProcessor var1);

int getBeanPostProcessorCount();

void registerScope(String var1, Scope var2);

String[] getRegisteredScopeNames();

@Nullable
Scope getRegisteredScope(String var1);

AccessControlContext getAccessControlContext();

void copyConfigurationFrom(ConfigurableBeanFactory var1);

void registerAlias(String var1, String var2) throws BeanDefinitionStoreException;

void resolveAliases(StringValueResolver var1);

BeanDefinition getMergedBeanDefinition(String var1) throws NoSuchBeanDefinitionException;

boolean isFactoryBean(String var1) throws NoSuchBeanDefinitionException;

void setCurrentlyInCreation(String var1, boolean var2);

boolean isCurrentlyInCreation(String var1);

void registerDependentBean(String var1, String var2);

String[] getDependentBeans(String var1);

String[] getDependenciesForBean(String var1);

void destroyBean(String var1, Object var2);

void destroyScopedBean(String var1);

void destroySingletons();
}

================================================================== HierarchicalBeanFactory ============================================================================================

HierarchicalBeanFactory 很簡單，它至關於僅僅一個 parentBeanFactory 屬性，以及檢查是否本地（就是本身！）就包含了某個name的bean
public interface HierarchicalBeanFactory extends BeanFactory {
@Nullable
BeanFactory getParentBeanFactory();

boolean containsLocalBean(String var1);
}

================================================================== AutowireCapableBeanFactory ============================================================================================

AutowireCapable ，支持 Autowire 特性，主要是 3種的Autowire 方式（非註解）。。

是否是隻要 autowire 相關的方法就足夠了呢？其餘的方法，有何須要？

createBean 的首次定義，正是此接口。爲何定義此處？
另外還有方法configureBean？

autowire 無疑是很是關鍵的方法，
autowireBeanProperties 表示自動的注入bean屬性
applyBeanPropertyValues 二者的名字，做用看起來這麼的接近。。我估計autowireBeanProperties 應該是調用了本方法。
initializeBean applyBeanPostProcessorsBeforeInitialization applyBeanPostProcessorsAfterInitialization 幾個方法定義了 bean 初始化前、中、後的基本行爲模式，
destroyBean bean使用完後銷燬
resolveDependency 經過 DependencyDescriptor requestingBeanName，
爲何要定義兩個resolveDependency方法？由於 ... autowire 的時候，可能很複雜，須要計算依賴關係吧。
resolveNamedBean 是經過一個Class返回

爲何createBean、initializeBean、applyBeanPostProcessorsBeforeInitialization、applyBeanPostProcessorsAfterInitialization、destroyBean 等方法定義於此？由於定義在其餘接口也不太方便吧。。並且它有autowireBean，天然可以createBean，從而也能夠destroy..

public interface AutowireCapableBeanFactory extends BeanFactory {
int AUTOWIRE_NO = 0;
int AUTOWIRE_BY_NAME = 1;
int AUTOWIRE_BY_TYPE = 2;
int AUTOWIRE_CONSTRUCTOR = 3;
/** @deprecated */
@Deprecated
int AUTOWIRE_AUTODETECT = 4;

<T> T createBean(Class<T> beanClass) throws BeansException;

void autowireBean(Object existingBean) throws BeansException;

Object configureBean(Object existingBean, String beanName) throws BeansException;

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;

void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;

Object initializeBean(Object existingBean, String beanName) throws BeansException;

Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException;

Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException;

void destroyBean(Object existingBean);

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

@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;
}

================================================================== ConfigurableListableBeanFactory ============================================================================================

ConfigurableListableBeanFactory 又是Configurable 又是Listable。其實咱們發現Configurable bf、Listable bf 都是存在的，爲何不直接繼承這兩個bf，而是要另外建立一個ConfigurableListable bf呢？它確實繼承了直接繼承這兩個bf，並且繼承了 AutowireCapable bf。看看他有什麼新方法：

有2個ignore方法，

個人理解是繼承Configurable bf、Listable bf以後，還不算是ConfigurableListable，添加了更多的方法以後，纔是真正的 ConfigurableListable 。。

好比ignoreDependencyXxx 、isAutowireCandidate registerResolvableDependency 方法，是否是放到AutowireCapableBeanFactory 中更好？

getBeanDefinition 的首次定義居然在這裏，隱藏的夠深了。。

getBeanNamesIterator 爲何不做爲一個私有方法，而是接口方法？ListableBeanFactory 的get bd names數組集合不是夠了嗎？

preInstantiateSingletons 這個方法無疑是很重要的，能夠預實例化單例，，爲何出如今這裏？

public interface ConfigurableListableBeanFactory extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
void ignoreDependencyType(Class<?> type);

void ignoreDependencyInterface(Class<?> ifc);

void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);

boolean isAutowireCandidate(String var1, DependencyDescriptor var2) throws NoSuchBeanDefinitionException;

BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

Iterator<String> getBeanNamesIterator();

void clearMetadataCache();

void freezeConfiguration();

boolean isConfigurationFrozen();

void preInstantiateSingletons() throws BeansException;
}

================================================================== SingletonBeanRegistry ============================================================================================

很明顯，提供了對Singleton模式即單例bean 的註冊，亦即get、contains、register，getXxxCount, 其中getXxMutex 的做用是？爲何定義在這個接口裏面呢？

public interface SingletonBeanRegistry {
void registerSingleton(String var1, Object var2);

@Nullable
Object getSingleton(String var1);

boolean containsSingleton(String var1);

String[] getSingletonNames();

int getSingletonCount();

Object getSingletonMutex();
}

實現說明

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 接口的實現 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ AbstractBeanFactory ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

AbstractBeanFactory 實現了 ConfigurableBeanFactory，因此他提供了基礎的各類可配置化特性；外加3個abstract 抽象方法。其中 getBeanDefinition 、containsBeanDefinition 既在抽象類中定義，又在接口裏面定義，並且沒有直接關係，我的感受有設計不良的傾向。。

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {..}

主要的私有的屬性是：

@Nullable
private BeanFactory parentBeanFactory;
@Nullable
private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();
@Nullable
private ClassLoader tempClassLoader;
private boolean cacheBeanMetadata = true;
@Nullable
private BeanExpressionResolver beanExpressionResolver;
@Nullable
private ConversionService conversionService;
private final Set<PropertyEditorRegistrar> propertyEditorRegistrars = new LinkedHashSet(4);
private final Map<Class<?>, Class<? extends PropertyEditor>> customEditors = new HashMap(4);
@Nullable
private TypeConverter typeConverter;
private final List<StringValueResolver> embeddedValueResolvers = new LinkedList();
private final List<BeanPostProcessor> beanPostProcessors = new ArrayList();
private boolean hasInstantiationAwareBeanPostProcessors;
private boolean hasDestructionAwareBeanPostProcessors;
private final Map<String, Scope> scopes = new LinkedHashMap(8);
@Nullable
private SecurityContextProvider securityContextProvider;
private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap(256);
private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap(256));
private final ThreadLocal<Object> prototypesCurrentlyInCreation = new NamedThreadLocal("Prototype beans currently in creation");

全部的方法以下（有點長，僅供快速的瀏覽）：
support.AbstractBeanFactory
getBean(java.lang.String)
getBean(java.lang.String, java.lang.Class<T>)
getBean(java.lang.String, java.lang.Object...)
containsBean
isSingleton
isPrototype
isTypeMatch(java.lang.String, org.springframework.core.ResolvableType)
isTypeMatch(java.lang.String, java.lang.Class<?>)
getType
getAliases
containsLocalBean
getParentBeanFactory
addPropertyEditorRegistrar
registerCustomEditor
copyRegisteredEditorsTo
addEmbeddedValueResolver
hasEmbeddedValueResolver
resolveEmbeddedValue
addBeanPostProcessor
registerScope
getRegisteredScope
copyConfigurationFrom
getMergedBeanDefinition(java.lang.String)
isFactoryBean(java.lang.String)
destroyBean(java.lang.String, java.lang.Object)
destroyScopedBean
setParentBeanFactory
setBeanClassLoader
getBeanClassLoader
setTempClassLoader
getTempClassLoader
setCacheBeanMetadata
isCacheBeanMetadata
setBeanExpressionResolver
getBeanExpressionResolver
setConversionService
getConversionService
setTypeConverter
getTypeConverter
getBeanPostProcessorCount
getRegisteredScopeNames
getAccessControlContext
isActuallyInCreation
AbstractBeanFactory()
AbstractBeanFactory(BeanFactory)
getBean(java.lang.String, java.lang.Class<T>, java.lang.Object...)
doGetBean
hasInstantiationAwareBeanPostProcessors
hasDestructionAwareBeanPostProcessors
isPrototypeCurrentlyInCreation
beforePrototypeCreation
afterPrototypeCreation
destroyBean(java.lang.String, java.lang.Object, support.RootBeanDefinition)
transformedBeanName
originalBeanName
initBeanWrapper
registerCustomEditors
getMergedLocalBeanDefinition
getMergedBeanDefinition(java.lang.String, config.BeanDefinition)
getMergedBeanDefinition(java.lang.String, config.BeanDefinition, config.BeanDefinition)
checkMergedBeanDefinition
clearMergedBeanDefinition
clearMetadataCache
resolveBeanClass
doResolveBeanClass
evaluateBeanDefinitionString
predictBeanType
isFactoryBean(java.lang.String, support.RootBeanDefinition)
getTypeForFactoryBean
markBeanAsCreated
cleanupAfterBeanCreationFailure
isBeanEligibleForMetadataCaching
removeSingletonIfCreatedForTypeCheckOnly
hasBeanCreationStarted
getObjectForBeanInstance
isBeanNameInUse
requiresDestruction
registerDisposableBeanIfNecessary
containsBeanDefinition // abstract 抽象方法
getBeanDefinition // 抽象方法
createBean // abstract 抽象方法

//
getPropertyEditorRegistrars
propertyEditorRegistrars
getCustomEditors
customEditors
getBeanPostProcessors
beanPostProcessors
setSecurityContextProvider
securityContextProvider
getCustomTypeConverter
parentBeanFactory
beanClassLoader
tempClassLoader
cacheBeanMetadata
beanExpressionResolver
conversionService
typeConverter
embeddedValueResolvers
hasInstantiationAwareBeanPostProcessors
hasDestructionAwareBeanPostProcessors
scopes
mergedBeanDefinitions
alreadyCreated
prototypesCurrentlyInCreation

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ AbstractAutowireCapableBeanFactory ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

AbstractAutowireCapableBeanFactory 繼承abstract bf, 實現了AutowireCapableBeanFactory，能夠想象它主要提供了 autowire 特性。—— autowire 特性在spring 能夠算得上是很是重要的！一大亮點！

提供了 create 、autowire 、configure apply initialize destroy instantiate populate convert circularReference dependencyCheck 等特性的基本實現，是很是主要的實現。

它提供了 ignoredDependencyXxx 特性
構造器中添加3個：
this.ignoreDependencyInterface(BeanNameAware.class);
this.ignoreDependencyInterface(BeanFactoryAware.class);
this.ignoreDependencyInterface(BeanClassLoaderAware.class);
爲何它們不須要檢查依賴 dependencyCheck？由於他們是框架系統基礎、默認是安全的、、、

—— 可是它的不少方法沒有去實現，好比resolveDependency 重要的方法都沒有實現，能夠認爲它是很是不完整的。

主要的私有的屬性是：

private InstantiationStrategy instantiationStrategy;
@Nullable
private ParameterNameDiscoverer parameterNameDiscoverer;
private boolean allowCircularReferences;
private boolean allowRawInjectionDespiteWrapping;
private final Set<Class<?>> ignoredDependencyTypes;
private final Set<Class<?>> ignoredDependencyInterfaces;
private final NamedThreadLocal<String> currentlyCreatedBean;
private final ConcurrentMap<String, BeanWrapper> factoryBeanInstanceCache;
private final ConcurrentMap<Class<?>, PropertyDescriptor[]> filteredPropertyDescriptorsCache;

簽名是：
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {

}

全部的方法以下：
AbstractAutowireCapableBeanFactory
AutowireByTypeDependencyDescriptor
getDependencyName
AutowireByTypeDependencyDescriptor
copyConfigurationFrom
predictBeanType
getTypeForFactoryBean
getObjectForBeanInstance
createBean
autowireBean
configureBean
resolveDependency
createBean
autowire
autowireBeanProperties
applyBeanPropertyValues
initializeBean
applyBeanPostProcessorsBeforeInitialization
applyBeanPostProcessorsAfterInitialization
destroyBean
createBean
postProcessObjectFromFactoryBean
removeSingleton
clearSingletonCache
AbstractAutowireCapableBeanFactory
AbstractAutowireCapableBeanFactory
ignoreDependencyType
ignoreDependencyInterface
doCreateBean
determineTargetType
getTypeForFactoryMethod
getTypeForFactoryBeanFromMethod
Holder
Holder
value
getEarlyBeanReference
getSingletonFactoryBeanForTypeCheck
getNonSingletonFactoryBeanForTypeCheck
applyMergedBeanDefinitionPostProcessors
resolveBeforeInstantiation
applyBeanPostProcessorsBeforeInstantiation
createBeanInstance
obtainFromSupplier
determineConstructorsFromBeanPostProcessors
instantiateBean
instantiateUsingFactoryMethod
autowireConstructor
populateBean
autowireByName
autowireByType
unsatisfiedNonSimpleProperties
filterPropertyDescriptorsForDependencyCheck
filterPropertyDescriptorsForDependencyCheck
isExcludedFromDependencyCheck
checkDependencies
applyPropertyValues
convertForProperty
initializeBean
invokeAwareMethods
invokeInitMethods
invokeCustomInitMethod
setInstantiationStrategy
getInstantiationStrategy
instantiationStrategy
setParameterNameDiscoverer
getParameterNameDiscoverer
parameterNameDiscoverer
setAllowCircularReferences
allowCircularReferences
setAllowRawInjectionDespiteWrapping
allowRawInjectionDespiteWrapping
getLogger
ignoredDependencyTypes
ignoredDependencyInterfaces
currentlyCreatedBean
factoryBeanInstanceCache
filteredPropertyDescriptorsCache

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ DefaultListableBeanFactory ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

DefaultListableBeanFactory 是 AbstractAutowireCapableBeanFactory 還要重的實現類； 1473行代碼。

簽名是：
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

主要的私有的屬性是：
@Nullable
private static Class<?> javaxInjectProviderClass;
private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories;
@Nullable
private String serializationId;
private boolean allowBeanDefinitionOverriding = true;
private boolean allowEagerClassLoading = true;
@Nullable
private Comparator<Object> dependencyComparator;
private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();
private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap(16);
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap(256);
private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap(64);
private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap(64);
private volatile List<String> beanDefinitionNames = new ArrayList(256);
private volatile Set<String> manualSingletonNames = new LinkedHashSet(16);
@Nullable
private volatile String[] frozenBeanDefinitionNames;
private volatile boolean configurationFrozen = false;

...

}

比較重要的是 autowireCandidateResolver resolvableDependencies beanDefinitionMap（beanDefinitionMap 在這裏纔出現，也算是等到了你），實現了不少直接操做 BeanDefinition的方法。它實現了全部的上面的 bf，能夠說是很是的完備了！它全部方法都不是抽象的。能夠拿來就用。可是咱們會發現，它仍是不夠方便，好比你本身去手動的 registerBeanDefinition ？ public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)

這個涉及到 BeanDefinition 的獲取，這個是後話，涉及到 xml、javaconfig配置，也就是 XmlBeanFactory，等等

———— 爲何名字是 DefaultListableBeanFactory，而不是 DefaultBeanFactory ？listable代表了可列舉，那指的是什麼可列舉？bd嗎，bean name嗎，bean實例嗎？不太好理解。

support.DefaultListableBeanFactory
FactoryAwareOrderSourceProvider
FactoryAwareOrderSourceProvider#getOrderSource
FactoryAwareOrderSourceProvider#FactoryAwareOrderSourceProvider
FactoryAwareOrderSourceProvider#getRootBeanDefinition
FactoryAwareOrderSourceProvider#instancesToBeanNames
Jsr330ProviderFactory
Jsr330ProviderFactory#Jsr330ProviderFactory
Jsr330ProviderFactory#createDependencyProvider
Jsr330DependencyProvider
Jsr330DependencyProvider#Jsr330DependencyProvider
Jsr330DependencyProvider#get
DependencyObjectProvider
DependencyObjectProvider#getObject()
DependencyObjectProvider#getObject(java.lang.Object...)
DependencyObjectProvider#getIfAvailable
DependencyObjectProvider#getIfUnique
DependencyObjectProvider#DependencyObjectProvider
DependencyObjectProvider#getValue
DependencyObjectProvider#descriptor
DependencyObjectProvider#optional
DependencyObjectProvider#beanName
MultiElementDescriptor
MultiElementDescriptor#MultiElementDescriptor
NestedDependencyDescriptor
NestedDependencyDescriptor#NestedDependencyDescriptor
SerializedBeanFactoryReference
SerializedBeanFactoryReference#SerializedBeanFactoryReference
SerializedBeanFactoryReference#readResolve
SerializedBeanFactoryReference#id
null
copyConfigurationFrom
destroySingletons
getBean(java.lang.Class<T>)
getBean(java.lang.Class<T>, java.lang.Object...)
containsBeanDefinition
getBeanNamesForType(org.springframework.core.ResolvableType)
getBeanNamesForType(java.lang.Class<?>)
getBeanNamesForType(java.lang.Class<?>, boolean, boolean)
getBeansOfType(java.lang.Class<T>)
getBeansOfType(java.lang.Class<T>, boolean, boolean)
getBeanNamesForAnnotation
getBeansWithAnnotation
findAnnotationOnBean
registerBeanDefinition
removeBeanDefinition
getBeanDefinitionCount
getBeanDefinitionNames
registerResolvableDependency
isAutowireCandidate(java.lang.String, config.DependencyDescriptor)
getBeanDefinition
clearMetadataCache
freezeConfiguration
preInstantiateSingletons
getBeanNamesIterator
isConfigurationFrozen
isBeanEligibleForMetadataCaching
allowAliasOverriding
registerSingleton
destroySingleton
resolveNamedBean(java.lang.Class<T>)
resolveDependency
toString
DefaultListableBeanFactory()
DefaultListableBeanFactory(BeanFactory)
doGetBeanNamesForType
requiresEagerInitForType
isAutowireCandidate(java.lang.String, config.DependencyDescriptor, support.AutowireCandidateResolver)
isAutowireCandidate(java.lang.String, support.RootBeanDefinition, config.DependencyDescriptor, support.AutowireCandidateResolver)
resetBeanDefinition
clearByTypeCache
resolveNamedBean(java.lang.Class<T>, java.lang.Object...)
doResolveDependency
resolveMultipleBeans
isRequired
indicatesMultipleBeans
adaptDependencyComparator
createFactoryAwareOrderSourceProvider
findAutowireCandidates
addCandidateEntry
determineAutowireCandidate
determinePrimaryCandidate
determineHighestPriorityCandidate
isPrimary
getPriority
matchesBeanName
isSelfReference
raiseNoMatchingBeanFound
checkBeanNotOfRequiredType
createOptionalDependency
readObject
writeReplace
setSerializationId
getSerializationId
serializationId
setAllowBeanDefinitionOverriding
isAllowBeanDefinitionOverriding
allowBeanDefinitionOverriding
setAllowEagerClassLoading
isAllowEagerClassLoading
allowEagerClassLoading
setDependencyComparator
getDependencyComparator
dependencyComparator
setAutowireCandidateResolver
getAutowireCandidateResolver
autowireCandidateResolver
javaxInjectProviderClass
serializableFactories
resolvableDependencies
beanDefinitionMap
allBeanNamesByType
singletonBeanNamesByType
beanDefinitionNames
manualSingletonNames
frozenBeanDefinitionNames
configurationFrozen

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ XmlBeanFactory ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

XmlBeanFactory 是 DefaultListableBeanFactory 的子類，惟一的子類。可想而知，主要提供了xml 配置文件的方式設置 bd。。

———— 爲何 DefaultListableBeanFactory 只有一個子類？ javaconfig、annotation 那一套呢？那就是 AnnotationConfigApplicationContext , 爲何沒有 AnnotationConfig bf 呢？

public class XmlBeanFactory extends DefaultListableBeanFactory {

private final XmlBeanDefinitionReader reader;

public XmlBeanFactory(Resource resource) throws BeansException {
this(resource, (BeanFactory)null);
}

public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
super(parentBeanFactory);
this.reader = new XmlBeanDefinitionReader(this);
this.reader.loadBeanDefinitions(resource);
}
}

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 其餘 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

// AliasRegistry SingletonBeanRegistry SimpleAliasRegistry DefaultSingletonBeanRegistry FactoryBeanRegistrySupport 就不說了，主要解決註冊、循環依賴的問題；