共计 6412 个字符，预计需要花费 17 分钟才能阅读完成。
BeanFactory 提供最根本的 Ioc 容器的性能，BeanFactory 只是一个接口类，并没有给出容器的具体实现，它通过不同的实现类，来定义或者裁减某个性能。
BeanFactory，从名字上也很好了解，生产治理 bean 的工厂（容器），它负责生产和治理各个 bean 实例。BeanFactory 接口相干的次要继承构造如下：
BeanFactory
BeanFactory 是顶级接口，定义了 Ioc 容器最根本的模式。
public interface BeanFactory {
// 这里能够临时不必管
String FACTORY_BEAN_PREFIX = "&";
Object getBean(String name) throws BeansException;
... // 省略其它办法
}FACTORY_BEAN_PREFIX 是用于与 BeanFactory 类似类~~~~FactoryBean 的相干应用，后续会在 Aop 讲。
BeanFactory 接口直系亲属
ListableBeanFactory
通过名字，这定义的是一个可列举（迭代）的 BeanFactory，通过这个 BeanFactory 能够查找特定的 Bean，相比顶级的 BeanFactory，其查问更加多样化，牵涉到 BeanDefinition，BeanName，注解等。
public interface ListableBeanFactory extends BeanFactory {
// 对于给定的名字是否含有 BeanDefinition
boolean containsBeanDefinition(String beanName);
// 返回工厂的 BeanDefinition 总数
int getBeanDefinitionCount();
// 返回工厂中所有 Bean 的名字
String[] getBeanDefinitionNames();
// 返回对于指定类型 获取 bean 的名字
String[] getBeanNamesForType(ResolvableType type);
// 获取蕴含某个注解 bean 的名字
String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);
// 依据指定 Bean 名和注解类型查找指定的 Bean
<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
throws NoSuchBeanDefinitionException;
}HierarchicalBeanFactory
分层式的 BeanFactory，这个工厂接口非常简单，实现了 Bean 工厂的分层。绝对于 BeanFactory 接口，它只扩大了一个重要的性能————工厂分层，能够指定父工厂（容器），同时查找 Bean 的时候，能够只查看本容器，疏忽父容器。
public interface HierarchicalBeanFactory extends BeanFactory {BeanFactory getParentBeanFactory();
/**
* 返回本地 bean 工厂是否蕴含给定名称的 bean，* 疏忽父容器上下文中定义的 bean。* <p> 这是 {@code containsBean} 的代替办法，* 疏忽 bean 来自一个父容器工厂的名字。*/
boolean containsLocalBean(String name);
}
AutowireCapableBeanFactory
AutowireCapableBeanFactory 目前还没有深刻的钻研，这个 Beanfactory 减少了注解性能，能够通过注解进行拆卸（操作）的工厂（容器）。
public interface AutowireCapableBeanFactory extends BeanFactory {
// 这个常量表明工厂没有主动拆卸的 Bean
int AUTOWIRE_NO = 0;
// 表明依据名称主动拆卸
int AUTOWIRE_BY_NAME = 1;
// 表明依据类型主动拆卸
int AUTOWIRE_BY_TYPE = 2;
// 表明依据构造方法拆卸
int AUTOWIRE_CONSTRUCTOR = 3;
// 被废除了
@Deprecated
int AUTOWIRE_AUTODETECT = 4;
<T> T createBean(Class<T> beanClass) throws BeansException;
// 给定对象，依据正文、后处理器等，进行主动拆卸
void autowireBean(Object existingBean) throws BeansException;
...// 省略后续办法
}
BeanFactory 高级接口
SingletonBeanRegistry
SingletoBeanRegistry 接口次要实现了单例类注册的性能。
public interface SingletonBeanRegistry {
// 注册一个单例类
void registerSingleton(String beanName, Object singletonObject);
Object getSingleton(String beanName);
boolean containsSingleton(String beanName);
String[] getSingletonNames();
int getSingletonCount();
// 不分明
Object getSingletonMutex();}ConfigurableBeanFactory
ConfigurableBeanFactory 同时继承了 HierarchicalBeanFactory 和 SingletonBeanRegistry 这两个接口，即同时继承了分层和单例类注册的性能。
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
String SCOPE_SINGLETON = "singleton";
String SCOPE_PROTOTYPE = "prototype";
// 设置父容器
void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;
void setBeanClassLoader(ClassLoader beanClassLoader);
ClassLoader getBeanClassLoader();
void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);
BeanExpressionResolver getBeanExpressionResolver();
/*
* 设置 转换服务
*/
void setConversionService(ConversionService conversionService);
ConversionService getConversionService();
void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);
/*
* 注册属性编辑器
*/
void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);
void copyRegisteredEditorsTo(PropertyEditorRegistry registry);
void setTypeConverter(TypeConverter typeConverter);
TypeConverter getTypeConverter();
// 设置一个 Bean 后处理器
void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
int getBeanPostProcessorCount();
void registerScope(String scopeName, Scope scope);
String[] getRegisteredScopeNames();
Scope getRegisteredScope(String scopeName);
void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);
/*
* 给指定的 Bean 注册别名
*/
void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;
BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
// 判断指定 Bean 是否为一个工厂 Bean
boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;
void setCurrentlyInCreation(String beanName, boolean inCreation);
boolean isCurrentlyInCreation(String beanName);
void registerDependentBean(String beanName, String dependentBeanName);
String[] getDependentBeans(String beanName);
String[] getDependenciesForBean(String beanName);
void destroyBean(String beanName, Object beanInstance);
void destroyScopedBean(String beanName);
void destroySingletons();
...// 省略局部办法
}ConfigurableListableBeanFactory
工厂接口 ConfigrableListableBeanFactory 同时继承了 3 个接口，ListableBeanFactory、AutowireCapableBeanfactory,ConfigurableBeanFactory，性能曾经很全面了。
public interface ConfigurableListableBeanFactory
extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
// 疏忽主动拆卸的依赖类型
void ignoreDependencyType(Class<?> type);
// 疏忽主动拆卸的接口
void ignoreDependencyInterface(Class<?> ifc);
// 返回注册的 Bean 定义
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
Iterator<String> getBeanNamesIterator();
...// 疏忽局部办法
}BeanDefinitionRegistry
BeanDefinitionRegistry 用于对 BeanDefinition 的操作
public interface BeanDefinitionRegistry extends AliasRegistry {
// 给定 bean 名称，注册一个新的 bean 定义
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException;
// 依据指定 Bean 名移除对应的 Bean 定义
void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
依据指定 bean 名失去对应的 Bean 定义
BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
查找，指定的 Bean 名是否蕴含 Bean 定义
boolean containsBeanDefinition(String beanName);
// 返回本容器内所有注册的 Bean 定义名称
String[] getBeanDefinitionNames();
// 指定 Bean 名是否被注册过。int getBeanDefinitionCount();
// 指定 Bean 名是否被注册过。boolean isBeanNameInUse(String beanName);
}BeanDefinition
Bean 的定义次要由 BeanDefinition 来形容，作为 Spring 中用于包装 Bean 的数据结构。
// 规范单例作用域 标识符：“singleton”。String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
// 规范原型作用域的范畴标识符：“prototype”。String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
// 示意 BeanDefinition 是应用程序次要局部的角色提醒。通常对应于用户定义的 bean。int ROLE_APPLICATION = 0;
// 示意 BeanDefinition 是某些大型配置的反对局部的角色提醒，通常是一个内部 ComponentDefinition。// 当查看某个特定的 ComponentDefinition 时，认为 bean 十分重要，// 以便在查看应用程序的整体配置时可能意识到这一点。int ROLE_SUPPORT = 1;
// 角色提醒表明一个 BeanDefinition 是提供一个齐全背景的角色，并且与最终用户没有关系。int ROLE_INFRASTRUCTURE = 2;
下面是 BeanDifinition 的一些根本属性信息，一个就是标识以后 Bean 的作用域，另外就是标识一下这个 Bean 是外部的还是内部的。
总结
ListableBeanFactory（可列举的容器（多花色查问）），HierarchicalBeanFactory（分档次容器，可有父容器），AutowireCapableBeanFactory（主动拆卸容器），这三个容器定义了 BeanFactory 的根本风貌，在这个三个直系亲属上面又派生了两个简单的容器：ConfigurableBeanFactory，ConfigurableListableBeanFactory，可配置的（可操作）的容器，通过这两个 BeanFactory 可有批改容器中的 bean, 性能又更加高级了，集成了单例 bean 服务，以及 BeanDefinition 注册服务，那么对于 DefaultListableBeanFactory 来说，此时它就是一个可注册，可配置，可获取的 BeanFactory，就容器方面而言性能曾经健全了。