BeanFactory体系结构

beanfactory是spring中非常重要的一个类，搞懂了它，你就知道了bean的初始化和摧毁过程，对于深入理解ioc有很大的帮助。

beanfactory体系结构

首先看一下使用idea生成的继承层次图（图中去掉了applicationcontext的继承图）：

可以看到beanfactory下的接口主要分为三个：

• hierarchicalbeanfactory：详细的分析见
• listablebeanfactory：详细的分析见
• autowirecapablebeanfactory：能够自动装配的bean的工厂需要实现此接口，下面会进行详细的说明。

关于beanfactory的分析见

beanfactory接口分析

下面将对beanfactory中的接口进行分析。

autowirecapablebeanfactory

该接口提供了对现有bean进行自动装配的能力，设计目的不是为了用于一般的应用代码中，对于一般的应用代码应该使用beanfactory和listablebeanfactory。其他框架的代码集成可以利用这个接口去装配和填充现有的bean的实例，但是spring不会控制这些现有bean的生命周期。你也许注意到了applicationcontext中的getautowirecapablebeanfactory()能获取到autowirecapablebeanfactory的实例（https://www.cnblogs.com/zhangfengxian/p/11086695.html#applicationcontext%e8%ae%be%e8%ae%a1%e8%a7%a3%e6%9e%90）。同样，也能实现beanfactoryaware接口来接收beanfactory（应用程序上下暴露的内部使用的beanfactory）的实例，然后将其转换成autowirecapablebeanfactory。

下面看一下这个接口中的静态成员变量和方法：

// 定义了bean的装配策略
int autowire_no = 0;            // 不进行装配
int autowire_by_name = 1;       // 根据名字进行装配
int autowire_by_type = 2;       // 根据类型进行装配
int autowire_constructor = 3;   // 根据构造函数进行装配
@deprecated
int autowire_autodetect = 4;    // spring3.0已经过时的方法，通过省视bean来决定适当的装载策略

//spring5.1后增加，原始实例的后缀，例如"com.mypackage.myclass.original"，强制返回给定的实例（没有代理）
string original_instance_suffix = ".original";

// 完全创建给定类的一个新的实例，包括所有适用的beanpostprocessor
// 填充注解的field和方法，并且会应用所有的初始化回调函数
<t> t createbean(class<t> beanclass) throws beansexception;
// 装配bean，通过应用初始化之后的回调函数和bean属性的后置处理来填充给定的bean的实例
// 本质上是为了在创建新的实例或者反序列化实例时，填充（重新填充）实例中注解的field和方法
void autowirebean(object existingbean) throws beansexception;
// 配置给定的原始bean：自动装配bean的属性，应用bean的属性值、工厂回调函数（例如setbeanname,values）
// 同样也会应用所有bean的后置处理器
object configurebean(object existingbean, string beanname) throws beansexception;

// 使用指定的装配策略来完全创建一个新的bean的实例
object createbean(class<?> beanclass, int autowiremode, boolean dependencycheck) throws beansexception;
// 使用指定的装配策略来实例化一个给定类新的bean的实例
// 不会应用标准的beanpostprocessor回调函数或者在未来执行任何bean的初始化
object autowire(class<?> beanclass, int autowiremode, boolean dependencycheck) throws beansexception;
// 根据名字和类型来自动装配给定bean的实例的属性
// 不会应用标准的beanpostprocessor回调函数或者在未来执行任何bean的初始化
void autowirebeanproperties(object existingbean, int autowiremode, boolean dependencycheck)
    throws beansexception;
// 应用给定名字的bean的定义的属性值到给定的bean的实例
// 该方法不会自动装配bean属性，仅仅应用明确定义的属性值
void applybeanpropertyvalues(object existingbean, string beanname) throws beansexception;
// 初始化给定的原始的bean应用bean的属性值、工厂回调函数（例如setbeanname,values）
// 同样也会应用所有bean的后置处理器
object initializebean(object existingbean, string beanname) throws beansexception;
// 应用beanpostprocessor到给定的现存的bean的实例，调用postprocessbeforeinitialization方法
object applybeanpostprocessorsbeforeinitialization(object existingbean, string beanname)
    throws beansexception;
// 应用beanpostprocessor到给定的现存的bean的实例，postprocessafterinitialization
object applybeanpostprocessorsafterinitialization(object existingbean, string beanname)
    throws beansexception;
// 摧毁给定的bean的实例，应用disposablebean规约和注册的destructionawarebeanpostprocessor
void destroybean(object existingbean);

// 解析唯一匹配给定对象类型的bean的实例，该方法是getbean(class)的变种，只不过它还提供了匹配实例的bean的名字
<t> namedbeanholder<t> resolvenamedbean(class<t> requiredtype) throws beansexception;
// 解析给定bean的名字的实例，提供了用于暴露目标的工厂方法的依赖描述符
object resolvebeanbyname(string name, dependencydescriptor descriptor) throws beansexception;
// 针对在工厂中定义的bean来解析指定的依赖
object resolvedependency(dependencydescriptor descriptor, @nullable string requestingbeanname) throws beansexception;
// 针对在工厂中定义的bean来解析指定的依赖
object resolvedependency(dependencydescriptor descriptor, @nullable string requestingbeanname,
                         @nullable set<string> autowiredbeannames, @nullable typeconverter typeconverter) throws beansexception;

configurablebeanfactory

configurablebeanfactory提供了bean工厂的配置机制（除了beanfactory接口中的bean的工厂的客户端方法）。该beanfactory接口不适应一般的应用代码中，应该使用beanfactory和listablebeanfactory。该扩展接口仅仅用于内部框架的使用，并且是对bean工厂配置方法的特殊访问。

configurablebeanfactory继承自hierarchicalbeanfactory和singletonbeanregistry，下面先看下singletonbeanregistry：

singletonbeanregistry是为了共享的bean的实例而定义的注册器，以统一的方式暴露单例管理机制。下面是在此接口中定义的方法：

// 在bean的注册器中以给定的bean的名字将给定的现存对象注册为单例
void registersingleton(string beanname, object singletonobject);
// 根据给定的bean的名字来获取单例bean，可能为null
object getsingleton(string beanname);
// 是否包含给定名字的单例bean
boolean containssingleton(string beanname);
// 获取所有在注册器中注册的单例bean的名字
string[] getsingletonnames();
// 获取所有在注册器中注册的单例bean的数量
int getsingletoncount();
// 获取在这个注册器中使用的单例的mutex（用于外部协同）
object getsingletonmutex();

需要注意的是使用registersingleton方法注册的单例bean，不会执行任何的初始化回调函数（尤其不会调用initializingbean的afterpropertiesset方法），同样也不会接收任何的摧毁回调函数。如果需要接收初始化和摧毁回调函数，请注册bean的定义而不是现存的实例对象。

接下来看下configurablebeanfactory中定义的方法：

// 作用域
string scope_singleton = "singleton"; // 单例作用域
string scope_prototype = "prototype"; // 原型作用域

// 设置父级bean工厂
void setparentbeanfactory(beanfactory parentbeanfactory) throws illegalstateexception;
// 设置bean的类加载器，默认为线程上下文类加载器
void setbeanclassloader(@nullable classloader beanclassloader);
// 获取bean的类加载器
@nullable
classloader getbeanclassloader();
// 设置临时的类加载器
void settempclassloader(@nullable classloader tempclassloader);
// 获取临时的类加载器
@nullable
classloader gettempclassloader();
// 设置是否缓存bean的元数据
void setcachebeanmetadata(boolean cachebeanmetadata);
// 是否缓存bean的元数据
boolean iscachebeanmetadata();
// 设置bean的表达式解析器，以统一的el兼容样式支持#{...}这样的表达式
void setbeanexpressionresolver(@nullable beanexpressionresolver resolver);
// 获取bean的表达式解析器
@nullable
beanexpressionresolver getbeanexpressionresolver();
// 设置转换服务，用于转换属性值
void setconversionservice(@nullable conversionservice conversionservice);
// 获取转换服务
@nullable
conversionservice getconversionservice();
// 添加属性编辑器注册者
void addpropertyeditorregistrar(propertyeditorregistrar registrar);
// 为所有给定的属性注册自定义属性编辑器
void registercustomeditor(class<?> requiredtype, class<? extends propertyeditor> propertyeditorclass);
// 使用在beanfactory中注册的自定义编辑器来初始哈给定的属性编辑器注册者
void copyregisterededitorsto(propertyeditorregistry registry);
// 设置类型转换器
void settypeconverter(typeconverter typeconverter);
// 获取类型转换器
typeconverter gettypeconverter();
// 添加嵌入值解析器，例如注册属性
void addembeddedvalueresolver(stringvalueresolver valueresolver);
// 在beanfactory是否有注册嵌入值解析器
boolean hasembeddedvalueresolver();
// 解析给定的嵌入的值
@nullable
string resolveembeddedvalue(string value);
// 添加bean的后置处理器
void addbeanpostprocessor(beanpostprocessor beanpostprocessor);
// 获取bean的后置处理器个数
int getbeanpostprocessorcount();
// 注册作用域
void registerscope(string scopename, scope scope);
// 获取注册的作用域的名字
string[] getregisteredscopenames();
// 获取作用域
@nullable
scope getregisteredscope(string scopename);
// 提供一个与这个工厂有关的安全访问控制上下文
accesscontrolcontext getaccesscontrolcontext();
// 从给定的其他的工厂拷贝所有相关的配置。不应该包含任何bean的定义元数据
void copyconfigurationfrom(configurablebeanfactory otherfactory);
// 注册别名
void registeralias(string beanname, string alias) throws beandefinitionstoreexception;
// 解析所有别名的目标名称和在工厂中注册的别名，将给定的stringvalueresolver应用于它们
void resolvealiases(stringvalueresolver valueresolver);
// 获取合并的bean的定义
beandefinition getmergedbeandefinition(string beanname) throws nosuchbeandefinitionexception;
// 给定名字的bean是否为factorybean
boolean isfactorybean(string name) throws nosuchbeandefinitionexception;
// 显式的设置指定bean的目前在创建状态
void setcurrentlyincreation(string beanname, boolean increation);
// 指定的bean目前是否为在建状态
boolean iscurrentlyincreation(string beanname);
// 注册给定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 destroyscopedbean(string beanname);
// 摧毁在工厂中的所有单例bean
void destroysingletons();

上面的大部分方法都是获取或者设置一些配置的信息，以便协同来完成beanfactory的配置。

configurablelistablebeanfactory

configurablelistablebeanfactory接口继承自listablebeanfactory, autowirecapablebeanfactory, configurablebeanfactory。大多数具有列出能力的bean工厂都应该实现此接口。此了这些接口的能力之外，该接口还提供了分析、修改bean的定义和单例的预先实例化的机制。这个接口不应该用于一般的客户端代码中，应该仅仅提供给内部框架使用。下面是这个接口的方法：

// 忽略用于自动装配的依赖的类型
void ignoredependencytype(class<?> type);
// 忽略用于自动装配的依赖的接口
void ignoredependencyinterface(class<?> ifc);
// 给特定的依赖类型注册自动装配的值
void registerresolvabledependency(class<?> dependencytype, @nullable object autowiredvalue);
// 指定的bean是否为自动装配的候选者
boolean isautowirecandidate(string beanname, dependencydescriptor descriptor)
    throws nosuchbeandefinitionexception;
// 获取bean的定义
beandefinition getbeandefinition(string beanname) throws nosuchbeandefinitionexception;
// 获取这个工厂中的所有bean的名字的迭代器
iterator<string> getbeannamesiterator();
// 清除元数据缓存
void clearmetadatacache();
// 冻结所有bean的定义
void freezeconfiguration();
// 工厂中bean的定义是否冻结了
boolean isconfigurationfrozen();
// 对非懒加载的单例进行预先初始化
void preinstantiatesingletons() throws beansexception;

abstractbeanfactory

abstractbeanfactory继承自factorybeanregistrysupport，实现了configurablebeanfactory接口。abstractbeanfactory是beanfactory的抽象基础类实现，提供了完整的configurablebeanfactory的能力。在这里不讨论该抽象类的实现细节，只要知道这个类是干什么的就行了，会面会有更加详细的章节来讨论。

• 单例缓存
• 别名的管理
• factorybean的处理
• 用于子bean定义的bean的合并
• bean的摧毁接口
• 自定义的摧毁方法
• beanfactory的继承管理

子类需要实现的模板方法如下：

// 是否包含给定名字的bean的定义
protected abstract boolean containsbeandefinition(string beanname);
// 根据bean的名字来获取bean的定义，子类通常要实现缓存
protected abstract beandefinition getbeandefinition(string beanname) throws beansexception;
// 为给定的已经合并了的bean的定义创建bean的实例
protected abstract object createbean(string beanname, rootbeandefinition mbd, @nullable object[] args)
    throws beancreationexception;

abstractautowirecapablebeanfactory

abstractautowirecapablebeanfactory继承自abstractbeanfactory，实现了autowirecapablebeanfactory接口。该抽象了实现了默认的bean的创建。

• 提供了bean的创建、属性填充、装配和初始化
• 处理运行时bean的引用，解析管理的集合、调用初始化方法等
• 支持构造器自动装配，根据类型来对属性进行装配，根据名字来对属性进行装配

子类需要自行实现的模板方法如下：

// 用于根据类型来进行自动装配
object resolvedependency(dependencydescriptor descriptor, @nullable string requestingbeanname,
                         @nullable set<string> autowiredbeannames, @nullable typeconverter typeconverter) throws beansexception;

defaultlistablebeanfactory

defaultlistablebeanfactory继承自abstractautowirecapablebeanfactory，实现了configurablelistablebeanfactory, beandefinitionregistry, serializable接口。这个类是一个非常完全的beanfactory，基于bean的定义元数据，通过后置处理器来提供可扩展性。

xmlbeanfactory

xmlbeanfactory继承自defaultlistablebeanfactory，用来从xml文档中读取bean的定义的一个非常方便的类。最底层是委派给xmlbeandefinitionreader，实际上等价于带有xmlbeandefinitionreader的defaultlistablebeanfactory。

思维导图