Spring源码分析———bean工厂接口体系

体系结构图：

四级接口继承体系：
1. BeanFactory 作为一个主接口不继承任何接口，暂且称为一级接口。

2. AutowireCapableBeanFactory、HierarchicalBeanFactory、ListableBeanFactory 3个子接口继承了它，
进行功能上的增强。这3个子接口称为二级接口。

3. ConfigurableBeanFactory 可以被称为三级接口，对二级接口 HierarchicalBeanFactory 进行了再次增
强，它还继承了另一个外来的接口 SingletonBeanRegistry。

4. ConfigurableListableBeanFactory 是一个更强大的接口，继承了上述的所有接口，无所不包，称为四级接
口。

总结：
|-- BeanFactory 是Spring bean容器的根接口.
提供获取bean,是否包含bean,是否单例与原型,获取bean类型,bean 别名的api.
|-- -- AutowireCapableBeanFactory 提供工厂的装配功能。
|-- -- HierarchicalBeanFactory 提供父容器的访问功能
|-- -- -- ConfigurableBeanFactory 如名,提供factory的配置功能,眼花缭乱好多api
|-- -- -- -- ConfigurableListableBeanFactory 集大成者,提供解析,修改bean定义,并初始化单例.
|-- -- ListableBeanFactory 提供容器内bean实例的枚举功能.这边不会考虑父容器内的实例

下面是继承关系的2个抽象类和2个实现类：
1. AbstractBeanFactory 作为一个抽象类，实现了三级接口 ConfigurableBeanFactory 大部分功能。
2. AbstractAutowireCapableBeanFactory 同样是抽象类，继承自 AbstractBeanFactory ，并额外实现了二级
接口 AutowireCapableBeanFactory 。
3. DefaultListableBeanFactory 继承自 AbstractAutowireCapableBeanFactory ，实现了最强大的四级接口
ConfigurableListableBeanFactory ，并实现了一个外来接口 BeanDefinitionRegistry ，它并非抽象类。
4. 最后是最强大的 XmlBeanFactory ，继承自 DefaultListableBeanFactory ，重写了一些功能，使自己更强
大。

总结：
BeanFactory 的类体系结构看似繁杂混乱，实际上由上而下井井有条，非常容易理解。

 

BeanFactory：

package org.springframework.beans.factory;

public interface BeanFactory {

//用来引用一个实例，或把它和工厂产生的Bean区分开
//就是说，如果一个FactoryBean的名字为a，那么，&a会得到那个Factory
String FACTORY_BEAN_PREFIX = "&";
/*
* 四个不同形式的getBean方法，获取实例
*/
Object getBean(String name) throws BeansException;
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
<T> T getBean(Class<T> requiredType) throws BeansException;
Object getBean(String name, Object... args) throws BeansException;
// 是否存在
boolean containsBean(String name);
// 是否为单实例
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
// 是否为原型（多实例）
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
// 名称、类型是否匹配
boolean isTypeMatch(String name, Class<?> targetType)
throws NoSuchBeanDefinitionException;
// 获取类型
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
// 根据实例的名字获取实例的别名
String[] getAliases(String name);
}

源码说明：

• 4个获取实例的方法。getBean的重载方法。
• 4个判断的方法。判断是否存在，是否为单例、原型，名称类型是否匹配。
• 1个获取类型的方法、一个获取别名的方法。根据名称获取类型、根据名称获取别名。一目了然！

总结：
这10个方法，很明显，这是一个典型的工厂模式的工厂接口。

ListableBeanFactory：可将Bean逐一列出的工厂

public interface ListableBeanFactory extends BeanFactory {
// 对于给定的名字是否含有
boolean containsBeanDefinition(String beanName); BeanDefinition
// 返回工厂的BeanDefinition总数
int getBeanDefinitionCount();
// 返回工厂中所有Bean的名字
String[] getBeanDefinitionNames();
// 返回对于指定类型Bean（包括子类）的所有名字
String[] getBeanNamesForType(Class<?> type);
/*
* 返回指定类型的名字
* includeNonSingletons为false表示只取单例Bean，true则不是
* allowEagerInit为true表示立刻加载，false表示延迟加载。
* 注意：FactoryBeans都是立刻加载的。
*/
String[] getBeanNamesForType(Class<?> type, boolean includeNonSingletons,
boolean allowEagerInit);
// 根据类型（包括子类）返回指定Bean名和Bean的Map
<T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException;
<T> Map<String, T> getBeansOfType(Class<T> type,
boolean includeNonSingletons, boolean allowEagerInit)
throws BeansException;
// 根据注解类型，查找所有有这个注解的Bean名和Bean的Map
Map<String, Object> getBeansWithAnnotation(
Class<? extends Annotation> annotationType) throws BeansException;
// 根据指定Bean名和注解类型查找指定的Bean
<A extends Annotation> A findAnnotationOnBean(String beanName,
Class<A> annotationType);
}

源码说明：

3个跟BeanDefinition有关的总体操作。包括BeanDefinition的总数、名字的集合、指定类型的名字的集合。

• 这里指出，BeanDefinition是Spring中非常重要的一个类，每个BeanDefinition实例都包含一个类在Spring工厂中所有属性。
• 2个getBeanNamesForType重载方法。根据指定类型（包括子类）获取其对应的所有Bean名字。
• 2个getBeansOfType重载方法。根据类型（包括子类）返回指定Bean名和Bean的Map。
• 2个跟注解查找有关的方法。根据注解类型，查找Bean名和Bean的Map。以及根据指定Bean名和注解类型查找指定的Bean。

总结：
　　正如这个工厂接口的名字所示，这个工厂接口最大的特点就是可以列出工厂可以生产的所有实例。当然，工厂并
没有直接提供返回所有实例的方法，也没这个必要。它可以返回指定类型的所有的实例。而且你可以通过
getBeanDefinitionNames()得到工厂所有bean的名字，然后根据这些名字得到所有的Bean。这个工厂接口扩展了
BeanFactory的功能，作为上文指出的BeanFactory二级接口，有9个独有的方法，扩展了跟BeanDefinition的功
能，提供了BeanDefinition、BeanName、注解有关的各种操作。它可以根据条件返回Bean的集合，这就是它名字
的由来——ListableBeanFactory。

HierarchicalBeanFactory：分层的Bean工厂
 

public interface HierarchicalBeanFactory extends BeanFactory {
// 返回本Bean工厂的父工厂
BeanFactory getParentBeanFactory();
// 本地工厂是否包含这个Bean
boolean containsLocalBean(String name);
}

参数说明：

• 第一个方法返回本Bean工厂的父工厂。这个方法实现了工厂的分层。
• 第二个方法判断本地工厂是否包含这个Bean（忽略其他所有父工厂）。这也是分层思想的体现。

总结：
这个工厂接口非常简单，实现了Bean工厂的分层。这个工厂接口也是继承自BeanFacotory，也是一个二级接
口，相对于父接口，它只扩展了一个重要的功能——工厂分层。

 

AutowireCapableBeanFactory：自动装配的Bean工厂
 

public interface AutowireCapableBeanFactory extends BeanFactory {
// 这个常量表明工厂没有自动装配的Bean
int AUTOWIRE_NO = 0;
// 表明根据名称自动装配
int AUTOWIRE_BY_NAME = 1;
// 表明根据类型自动装配
int AUTOWIRE_BY_TYPE = 2;
// 表明根据构造方法快速装配
int AUTOWIRE_CONSTRUCTOR = 3;
//表明通过Bean的class的内部来自动装配（有没翻译错...）Spring3.0被弃用。
@Deprecated
int AUTOWIRE_AUTODETECT = 4;
// 根据指定Class创建一个全新的Bean实例
<T> T createBean(Class<T> beanClass) throws BeansException;
// 给定对象，根据注释、后处理器等，进行自动装配
void autowireBean(Object existingBean) throws BeansException;
// 根据Bean名的BeanDefinition装配这个未加工的Object，执行回调和各种后处理器。
Object configureBean(Object existingBean, String beanName) throws BeansException;
// 分解Bean在工厂中定义的这个指定的依赖descriptor
Object resolveDependency(DependencyDescriptor descriptor, String beanName) throws
BeansException;
// 根据给定的类型和指定的装配策略，创建一个新的Bean实例
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;
/*
* 初始化一个Bean...
*/
Object initializeBean(Object existingBean, String beanName) throws
BeansException;
/*
* 初始化之前执行BeanPostProcessors
*/
Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String
beanName)
throws BeansException;
/*
* 初始化之后执行BeanPostProcessors
*/
Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String
beanName)
throws BeansException;
/*
* 分解指定的依赖
*/
Object resolveDependency(DependencyDescriptor descriptor, String beanName,
Set<String> autowiredBeanNames, TypeConverter typeConverter) throws
BeansException;
}

源码说明：

• 总共5个静态不可变常量来指明装配策略，其中一个常量被Spring3.0废弃、一个常量表示没有自动装配，另外3个常量指明不同的装配策略——根据名称、根据类型、根据构造方法。
• 8个跟自动装配有关的方法，实在是繁杂，具体的意义我们研究类的时候再分辨吧。
• 2个执行BeanPostProcessors的方法。
• 2个分解指定依赖的方法

总结：
这个工厂接口继承自BeanFacotory，它扩展了自动装配的功能，根据类定义BeanDefinition装配Bean、执行前、
后处理器等

ConfigurableBeanFactory：复杂的配置Bean工厂
 

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory,
SingletonBeanRegistry {
String SCOPE_SINGLETON = "singleton"; // 单例
String SCOPE_PROTOTYPE = "prototype"; // 原型
/*
* 搭配HierarchicalBeanFactory接口的getParentBeanFactory方法
*/
void setParentBeanFactory(BeanFactory parentBeanFactory) throws
IllegalStateException;
/*
* 设置、返回工厂的类加载器
*/
void setBeanClassLoader(ClassLoader beanClassLoader);
ClassLoader getBeanClassLoader();
/*
* 设置、返回一个临时的类加载器
*/
void setTempClassLoader(ClassLoader tempClassLoader);
ClassLoader getTempClassLoader();
/*
* 设置、是否缓存元数据，如果false，那么每次请求实例，都会从类加载器重新加载（热加载）
*/
void setCacheBeanMetadata(boolean cacheBeanMetadata);
boolean isCacheBeanMetadata();//是否缓存元数据
/*
* Bean表达式分解器
*/
void setBeanExpressionResolver(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();
/*
* 增加一个嵌入式的StringValueResolver
*/
void addEmbeddedValueResolver(StringValueResolver valueResolver);

String resolveEmbeddedValue(String value);//分解指定的嵌入式的值
/*
* 设置一个Bean后处理器
*/
void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
/*
* 返回Bean后处理器的数量
*/
int getBeanPostProcessorCount();
/*
* 注册范围
*/
void registerScope(String scopeName, Scope scope);
/*
* 返回注册的范围名
*/
String[] getRegisteredScopeNames();
/*
* 返回指定的范围
*/
Scope getRegisteredScope(String scopeName);
/*
* 返回本工厂的一个安全访问上下文
*/
AccessControlContext getAccessControlContext();
/*
* 从其他的工厂复制相关的所有配置
*/
void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);
/*
* 给指定的Bean注册别名
*/
void registerAlias(String beanName, String alias) throws
BeanDefinitionStoreException;
/*
* 根据指定的StringValueResolver移除所有的别名
*/
void resolveAliases(StringValueResolver valueResolver);
/*
* 返回指定Bean合并后的Bean定义
*/
BeanDefinition getMergedBeanDefinition(String beanName) throws
NoSuchBeanDefinitionException;
/*
* 判断指定Bean是否为一个工厂Bean
*/
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
*/
void destroyBean(String beanName, Object beanInstance);
/*
* 销毁指定的范围Bean
*/
void destroyScopedBean(String beanName);
/*
* 销毁所有的单例类
*/
void destroySingletons(); 
}

ConfigurableListableBeanFactory：BeanFactory的集大成者
 

public interface ConfigurableListableBeanFactory
extends ListableBeanFactory, AutowireCapableBeanFactory,
ConfigurableBeanFactory {

void ignoreDependencyType(Class<?> type);//忽略自动装配的依赖类型

void ignoreDependencyInterface(Class<?> ifc);//忽略自动装配的接口
/*
* 注册一个可分解的依赖
*/
void registerResolvableDependency(Class<?> dependencyType, Object
autowiredValue);
/*
* 判断指定的Bean是否有资格作为自动装配的候选者
*/
boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
throws NoSuchBeanDefinitionException;

// 返回注册的Bean定义
BeanDefinition getBeanDefinition(String beanName) throws
NoSuchBeanDefinitionException;

// 暂时冻结所有的Bean配置
void freezeConfiguration();

// 判断本工厂配置是否被冻结
boolean isConfigurationFrozen();

// 使所有的非延迟加载的单例类都实例化。
void preInstantiateSingletons() throws BeansException;
}

源码说明：
　　1、2个忽略自动装配的的方法。
　　2、1个注册一个可分解依赖的方法。
　　3、1个判断指定的Bean是否有资格作为自动装配的候选者的方法。
　　4、1个根据指定bean名，返回注册的Bean定义的方法。
　　5、2个冻结所有的Bean配置相关的方法。
       6、1个使所有的非延迟加载的单例类都实例化的方法
总结：
工厂接口 ConfigurableListableBeanFactory 同时继承了3个接口， ListableBeanFactory 、
AutowireCapableBeanFactory 和 ConfigurableBeanFactory ，扩展之后，加上自有的这8个方法，这个
工厂接口总共有83个方法，实在是巨大到不行了。这个工厂接口的自有方法总体上只是对父类接口功能的补
充，包含了 BeanFactory 体系目前的所有方法，可以说是接口的集大成者。

 

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);
String[] getBeanDefinitionNames();//返回本容器内所有注册的Bean定义名称
int getBeanDefinitionCount();//返回本容器内注册的Bean定义数目
boolean isBeanNameInUse(String beanName);//指定Bean名是否被注册过。
}

补充：

BeanDefinition继承体系：