先通过UML图总体了解下Spring的BeanFactory的整体结构，先了解整体架构脉络
接口
接口就是规范，通过接口可以了解其具有哪些功能，先来看下几个主要的接口定义。
BeanFactory
访问 Spring bean 容器的根接口，该接口的实现类会持有许多 bean 定义，每个bean定义由一个字符串名称唯一标识。
其他的子接口可用于特定目的，如
- ListableBeanFactory用来枚举bean的实例，而不是客户端通过名称一个一个的查询得出所有的实例等
- ConfigurableBeanFactory提供对BeanFactory配置的能力，如类加载器,类型转化,属性编辑器,BeanPostProcessor,作用域,bean定义,处理bean依赖关系等；
- HierarchicalBeanFactory接口使容器具备了父子层级(parent BeanFactory)功能。
通常最好依靠Dependency Injection依赖注入（“推”的配置方式）通过setter或构造器来配置应用程序的对象，而不是使用任何形式的“拉”配置，如 BeanFactory 查找。Spring 的依赖注入功能是使用这个 BeanFactory 接口及其子接口实现的。
通常，BeanFactory 会加载存储在配置源（例如 XML 文档）中的 bean 定义。
Bean 工厂实现应尽可能支持标准的 bean 生命周期接口。 全套初始化方法及其标准顺序是：
* BeanNameAware's {@code setBeanName}
* BeanClassLoaderAware's {@code setBeanClassLoader}
* BeanFactoryAware's {@code setBeanFactory}
* EnvironmentAware's {@code setEnvironment}
* EmbeddedValueResolverAware's {@code setEmbeddedValueResolver}
* ResourceLoaderAware's {@code setResourceLoader}
(only applicable when running in an application context)
* ApplicationEventPublisherAware's {@code setApplicationEventPublisher}
(only applicable when running in an application context)
* MessageSourceAware's {@code setMessageSource}
(only applicable when running in an application context)
* ApplicationContextAware's {@code setApplicationContext}
(only applicable when running in an application context)
* ServletContextAware's {@code setServletContext}
(only applicable when running in a web application context)
* {@code postProcessBeforeInitialization} methods of BeanPostProcessors
* InitializingBean's {@code afterPropertiesSet}
* a custom init-method definition
* {@code postProcessAfterInitialization} methods of BeanPostProcessors上述这些BeanFactory的扩展点，都在spring的BeanFactory实现了，具体见Spring刷新refresh过程流程图了解各个扩展点的触发时间。
boolean containsBean(String name);
Object getBean(String name) throws BeansException;
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
Class<?> getType(String name) throws NoSuchBeanDefinitionException;SingletonBeanRegistry
此接口是针对Spring中的单例Bean设计的，对外提供了统一访问单例Bean的功能。
void registerSingleton(String beanName, Object singletonObject);
Object getSingleton(String beanName);
int getSingletonCount();
boolean containsSingleton(String beanName);BeanDefinitionRegistry
提供bean定义的注册功能。
Spring 的 bean definition readers 在该接口的实现类上工作，用来读取bean的定义，如XmlBeanDefinitionReader。
Spring 核心中的已知的BeanDefinitionRegistry接口实现类 DefaultListableBeanFactory 和 GenericApplicationContext。
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException;
void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
boolean containsBeanDefinition(String beanName);
String[] getBeanDefinitionNames();
int getBeanDefinitionCount();ListableBeanFactory
提供枚举bean的实例的功能，而不是客户端通过名称一个一个的查询得出所有的实例等
//检查是否含有指定名称的BeanDefinition
boolean containsBeanDefinition(String beanName);
//返回工厂的BeanDefinition总数
int getBeanDefinitionCount();
//返回工厂中所有Bean的名字
String[] getBeanDefinitionNames();
//返回指定类型的Bean（包括子类）的所有名字
String[] getBeanNamesForType(ResolvableType type);
//返回与给定对象类型（包括子类）匹配的bean实例，根据bean定义或工厂Bean的getObjectType的值来判断。
<T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;
//查找Class具有提供的Annotation类型的所有 bean 名称
String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);
//查找Class具有提供的Annotation类型的所有bean，返回bean名称和相应bean实例的Map。
Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;
//根据指定的bean和Annotation类型，返回该注解
<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType) throws NoSuchBeanDefinitionException;ConfigurableBeanFactory
提供对BeanFactory配置的能力，如类加载器ClassLoader,类型转化TypeConverter,属性编辑器PropertyEditor,**BeanPostProcessor**,作用域Scope,bean定义,处理bean依赖关系等；
//设置类加载器以用于加载 bean 类
void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);
//添加一个新的 BeanPostProcessor，它将应用于此工厂创建的 bean。
void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
//根据给定bean名称，返回合并后的BeanDefinition，如有必要，将子 bean 定义与其父合并。
BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;AutowireCapableBeanFactory
提供自动装配能力，并且想把这种能力暴露给外部应用的BeanFactory类需要实现此接口。
//完全创建给定类的新bean实例，执行bean的完整初始化，包括所有适用的BeanPostProcessors
//这旨在创建一个新实例，填充待注解的字段和方法，并调用所有的bean初始化回调方法
<T> T createBean(Class<T> beanClass) throws BeansException;
void destroyBean(Object existingBean);
//初始化给定的原始bean，应用工厂回调，如setBeanName，还应用所有的BeanPostProcessor
Object initializeBean(Object existingBean, String beanName) throws BeansException;
//通过应用after-instantiation回调和bean属性post-processing来填充给定的 bean 实例
void autowireBean(Object existingBean) throws BeansException;
//调用bean的postProcessBeforeInitialization，返回的bean可能是原始bean的包装类
Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException;
//调用bean的postProcessAfterInitialization，返回的bean可能是原始bean的包装类
Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException;ConfigurableListableBeanFactory
提供了分析和修改bean定义的能力，以及实例化非懒加载的bean单例
- ignoreDependencyType：设置在自动装配时忽略给定的依赖类型。在使用ByType类型的方式注入属性时，如果工厂提前设置了ignoredDependencyTypes(ABC.class),那么其他类中如果仅使用byType的方式注入ABC对象作为属性时是获取不到的【有局限性，就是必须是byType的方式注入的,【而Autowired是先byType类型在byName,所以如果byName能拿到通过反射调用set方法还是会注入进去】
- registerResolvableDependency：使用相应的自动装配值，装配指定的依赖类型，这样当容器中需要注入该依赖类型时，就会使用指定的值注入。
Spring的普通bean的依赖注入时从容器中寻找符合条件的Bean注入进来，但对于特殊的bean如容器ApplicationContext，BeanFactory本身，是无法在容器中找到的，这种Bean需要特定的方法来进行注入，即通过ApplicationContextAware和BeanFactoryAware来注入。
//设置在自动装配时忽略给定的依赖类型
void ignoreDependencyType(Class<?> type);
//设置在自动装配时忽略给定的依赖接口
void ignoreDependencyInterface(Class<?> ifc);
//使用相应的自动装配值，装配指定的依赖类型
//当容器中要注入XX接口时，直接使用该方法指定的的实现类即可
void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);
//返回该bean工厂管理的所有bean名称
Iterator<String> getBeanNamesIterator();
//冻结所有bean定义，表示所有已注册的bean定义将不会被修改或被post-processed进一步处理。
void freezeConfiguration();
//确保实例化所有非懒初始化的bean单例，如果需要，通常在工厂设置结束时调用
void preInstantiateSingletons() throws BeansException;实现类
DefaultSingletonBeanRegistry
单例bean 实例的通用注册表，实现 SingletonBeanRegistry接口。允许注册单例，这些单例为所有调用者共享，通过 bean 名称获取。
也就是该实现类**通过三级缓存解决单例的循环引用等问题**，具体内容参考另一篇博文，Spring getBean和createBean的过程及三级缓存。
AbstractBeanFactory
`AbstractBeanFactory`是bean工厂最核心的实现，具体内容参考另一篇博文，Spring getBean和createBean的过程及三级缓存。
需要子类实现的三个接口
//判断当前工厂是否包含给定bean名称的bean定义
protected abstract boolean containsBeanDefinition(String beanName);
//根据给定的bean名称返回bean定义
protected abstract BeanDefinition getBeanDefinition(String beanName) throws BeansException;
//为给定的合并后的bean定义（和参数）创建一个bean实例。如果是子定义，则该bean定义已经与父定义合并。
protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException;AbstractAutowireCapableBeanFactory
提供 bean 创建（使用构造函数解析）、属性填充、装配（包括自动装配）和初始化。 处理运行时 bean 引用、解析托管集合、调用初始化方法等。
- 实现了AbstractBeanFactory 的 {@link #createBean} 方法
- 实现了{@link org.springframework.beans.factory.config.AutowireCapableBeanFactory} 接口
- 子类要实现的主要模板方法是{@link #resolveDependency(DependencyDescriptor, String, Set, TypeConverter)}，用于按类型自动装配。
请注意，此类不实现 bean 定义注册表功能。请参阅 {@link DefaultListableBeanFactory} 以了解 {@link org.springframework.beans.factory.ListableBeanFactory} 和 {@link BeanDefinitionRegistry} 接口的实现。
DefaultListableBeanFactory
{@link org.springframework.beans.factory.ListableBeanFactory} 和 {@link BeanDefinitionRegistry} 接口的默认实现，也是spring的默认工厂实现类。
典型用法是在访问 bean 之前首先注册所有 bean 定义（可能从 bean 定义文件中读取），对预构建的 bean 定义元数据对象进行操作。
可以用作独立的 bean 工厂，也可以用作自定义 bean 工厂的父类。
请注意，特定 bean 定义格式的reader通常单独实现，而不是作为 bean 工厂子类：例如参见 {@link PropertiesBeanDefinitionReader} 和 {@link org.springframework.beans.factory.xml.XmlBeanDefinitionReader}
//从依赖类型映射到相应的自动装配值
private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);
//bean定义对象的映射，以 bean 名称为键
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
//bean 定义名称列表，按注册顺序排列
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
//单例和非单例bean名称的映射，以依赖类型为键
private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);
//仅单例 bean 名称的映射，以依赖类型为键
private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64);
//手动注册单例的名称列表，按注册顺序
private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);
//在冻结配置的情况下缓存 bean 定义名称数组
private volatile String[] frozenBeanDefinitionNames;
//是否可以为所有 bean 缓存 bean 定义元数据
private volatile boolean configurationFrozen = false;- 实现AbstractBeanFactory类的containsBeanDefinition，getBeanDefinition方法
- 实现BeanFactory接口的getBean方法
- 实现ListableBeanFactory接口的containsBeanDefinition，getBeanDefinitionCount，getBeanDefinitionNames，getBeanNamesForType，getBeansOfType，findAnnotationOnBean方法
- 实现ConfigurableListableBeanFactory接口的registerResolvableDependency，isAutowireCandidate，freezeConfiguration方法
- 实现BeanDefinitionRegistry接口的registerBeanDefinition，removeBeanDefinition方法
- 实现SingletonBeanRegistry接口的registerSingleton，destroySingleton，destroySingletons方法
扩展
[ignoreDependencyType和ignoreDependencyInterface]
[registerResolvableDependency]
[Spring getBean和createBean的过程及三级缓存]
