04--SpringIoC容器BeanFactory简介

---

新版连接 01–Spring源码深度解析目录

---

前三篇文章,介绍了Spring源码阅读环境搭建,Spring框架以及IoC容器简介,接下来分析IoC容器的基础BeanFactory,并以XmlBeanFactory其实现类作为入口分析IoC容器的实现(XmlBeanFactory已经被标记为过期,但是这不妨碍我们作为分析IoC的入口类)

类图关系

• IDEA查看类图–>光标定位到类或接口–>右键

• XmlBeanFactory类图结构

蓝色的实线表示类与类之间的继承关系
绿色的实线表示接口与接口之间的继承关系
绿色的虚线表示类与接口之间的继承关系

XmlBeanFactory的继承体系比较复杂,但是在分析源码之间,了解一下类的继承关系将助于我们对源码的分析

从图中可以看到,顶级接口分别是BeanFactory,SingletonBeanRegistry,AliasRegistry

1.BeanFactory

//SpringIoC容器顶级接口
public interface BeanFactory {

    // 区分是获取FactoryBean还是FactoryBean的createBean创建的实例.如果&开始则获取FactoryBean;否则获取createBean创建的实例.
	String FACTORY_BEAN_PREFIX = "&";

	Object getBean(String name) throws BeansException;

	<T> T getBean(String name, Class<T> requiredType) throws BeansException;

	Object getBean(String name, Object... args) throws BeansException;

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

	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);

	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

	boolean containsBean(String name);

	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

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

	String[] getAliases(String name);
}

1.1 ListableBeanFactory–>BeanFactory

//扩展了BeanFactory接口,提供了对bean的枚举能力,
//即可以返回bean的实例集合,而不用像BeanFactory只能返回单个bean的实例
//注意:如果存在父容器的话该接口不会考虑父容器中的bean,只会返回当前容器中的bean
public interface ListableBeanFactory extends BeanFactory {

	boolean containsBeanDefinition(String beanName);

	int getBeanDefinitionCount();

	String[] getBeanDefinitionNames();

	String[] getBeanNamesForType(ResolvableType type);

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

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

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

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

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

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

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

}

#####1.2 HierarchicalBeanFactory–> BeanFactory

//扩展了BeanFactory接口,提供了对父容器的访问功能
public interface HierarchicalBeanFactory extends BeanFactory {

	@Nullable
	BeanFactory getParentBeanFactory();

	boolean containsLocalBean(String name);

}

#####1.3 AutowireCapableBeanFactory --> BeanFactory

//扩展了BeanFactory，主要提供了自动装配能力
public interface AutowireCapableBeanFactory extends BeanFactory {

    //无自动装配
	int AUTOWIRE_NO = 0;

    //by-name装配
	int AUTOWIRE_BY_NAME = 1;

    //by-type装配
	int AUTOWIRE_BY_TYPE = 2;

    //constructor构造函数装配
	int AUTOWIRE_CONSTRUCTOR = 3;

    //自动装配,已被标记为过时
	@Deprecated
	int AUTOWIRE_AUTODETECT = 4;


	//-------------------------------------------------------------------------
	// 创建和填充外部bean实例的典型方法
	//-------------------------------------------------------------------------

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

	void autowireBean(Object existingBean) throws BeansException;

	Object configureBean(Object existingBean, 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;

	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;

}

ListableBeanFactory,HierarchicalBeanFactory,AutowireCapableBeanFactory是BeanFactory的直接子接口,分别提供了对bean的枚举能力,对父容器的访问能力,对bean的自动装配能力

#####1.4 ConfigurableBeanFactory–> HierarchicalBeanFactory–>BeanFactory

//扩展了HierarchicalBeanFactory，SingletonBeanRegistry,主要提供了对BeanFactory的配置能力
//该接口扩展的内容较多,比如类加载器,类型转化,属性编辑器,BeanPostProcessor,
//作用域,bean定义,处理bean依赖关系,合并其他ConfigurableBeanFactory,bean如何销毁等
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {

	标准单例范围的范围标识符：“singleton”。
	String SCOPE_SINGLETON = "singleton";

	//标准原型范围的范围标识符：“prototype”。
	String SCOPE_PROTOTYPE = "prototype";

	//设置父工厂,注意:不能更改父级工厂
	void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;

	//设置类加载器以用于加载bean类。默认是线程上下文类加载器。
	void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);

	//返回该工厂的类加载器
	@Nullable
	ClassLoader getBeanClassLoader();

	//指定用于类型匹配目的的临时ClassLoader。
	void setTempClassLoader(@Nullable ClassLoader tempClassLoader);

	//获取用于类型匹配目的的临时ClassLoader。
	@Nullable
	ClassLoader getTempClassLoader();

	//设置是否缓存bean元数据，例如给定的bean定义（以合并方式）和已解析的bean类。默认打开。
	//关闭此标志以启用bean定义对象的热刷新，特别是bean类。如果此标志关闭，则任何bean实例的创建都将为新解析的类重新查询bean类加载器。
	void setCacheBeanMetadata(boolean cacheBeanMetadata);

	//返回是否缓存bean元数据
	boolean isCacheBeanMetadata();

	//为bean定义值中的表达式指定解析策略。
	//默认情况下，BeanFactory中没有活动表达式支持。ApplicationContext通常会在此处设置标准表达式策略，支持Unified EL兼容样式中的“＃{...}”表达式。
	void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);

	//返回bean定义值中表达式的解析策略。
	@Nullable
	BeanExpressionResolver getBeanExpressionResolver();

	//指定用于转换属性值的Spring 3.0 ConversionService，作为JavaBeans PropertyEditors的替代方法。
	void setConversionService(@Nullable ConversionService conversionService);

	//返回关联的ConversionService（如果有）。
	@Nullable
	ConversionService getConversionService();

	//添加PropertyEditorRegistrar以应用于所有bean创建过程。
	void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);

	//为给定类型的所有属性注册给定的自定义属性编辑器。在工厂配置期间调用。
	void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);

	//使用已在此BeanFactory中注册的自定义编辑器初始化给定的PropertyEditorRegistry。
	void copyRegisteredEditorsTo(PropertyEditorRegistry registry);

	//设置此BeanFactory应用于转换bean属性值，构造函数参数值等的自定义类型转换器。
    //这将覆盖默认的PropertyEditor机制，因此使任何自定义编辑器或自定义编辑器注册表都无关紧要。
	void setTypeConverter(TypeConverter typeConverter);

	//获取此BeanFactory使用的类型转换器。这可能是每次调用的新实例，因为TypeConverters通常不是线程安全的。
    //如果默认的PropertyEditor机制处于活动状态，则返回的TypeConverter将知道已注册的所有自定义编辑器。
	TypeConverter getTypeConverter();

	//为嵌入值（例如注释属性）添加String解析器。
	void addEmbeddedValueResolver(StringValueResolver valueResolver);

	//确定是否已通过此Bean工厂注册了嵌入值解析程序resolveEmbeddedValue(String)。
	boolean hasEmbeddedValueResolver();

	//解析给定的嵌入值，例如注释属性。
	@Nullable
	String resolveEmbeddedValue(String value);

	//添加一个新的BeanPostProcessor，它将应用于此工厂创建的bean。在工厂配置期间调用。
	void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);

	//返回已注册的BeanPostProcessors的当前数量（如果有）。
	int getBeanPostProcessorCount();

	//注册给定范围，由给定的Scope实现支持。
	void registerScope(String scopeName, Scope scope);

	//返回所有当前注册的范围的名称。
	String[] getRegisteredScopeNames();

	//返回给定范围名称的Scope实现（如果有）。
	@Nullable
	Scope getRegisteredScope(String scopeName);

	//提供与此工厂相关的安全访问控制上下文。
	AccessControlContext getAccessControlContext();

	//复制给定其他工厂的所有相关配置。
    //应包括所有标准配置设置以及BeanPostProcessors，Scopes和工厂特定的内部设置。不应包含实际bean定义的任何元数据，例如BeanDefinition对象和bean名称别名。
	void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

	//给定bean名称，创建别名。
	void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;

	//解析在此工厂中注册的所有别名目标名称和别名，将给定的StringValueResolver应用于它们。
    //例如，值解析器可以解析目标bean名称中的占位符，甚至可以解析别名中的占位符。
	void resolveAliases(StringValueResolver valueResolver);

	//返回给定bean名称的合并BeanDefinition，如果需要，将子bean定义与其父bean合并。也考虑祖先工厂中的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，在销毁给定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，包括已注册为一次性的内部bean。
	void destroySingletons();

}

1.5 ConfigurableListableBeanFactory

ConfigurableListableBeanFactory–> ListableBeanFactory–>BeanFactory
ConfigurableListableBeanFactory–> AutowireCapableBeanFactory–>BeanFactory
ConfigurableListableBeanFactory–> ConfigurableBeanFactory–>HierarchicalBeanFactory–>BeanFactory

ConfigurableListableBeanFactory继承了三个接口,并扩展了忽略依赖,自动装配判断,冻结bean的定义,枚举所有bean名称的功能

public interface ConfigurableListableBeanFactory extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {

    //忽略给定的自动装配依赖关系接口。
	void ignoreDependencyType(Class<?> type);

    //忽略给定的自动装配依赖关系接口。
	void ignoreDependencyInterface(Class<?> ifc);

    //使用相应的自动装配值注册特殊依赖关系类型。
	void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);

    //确定指定的bean是否有资格作为autowire候选者，注入到声明匹配类型依赖关系的其他bean中。
	boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor) throws NoSuchBeanDefinitionException;

    //返回指定bean的已注册BeanDefinition，允许访问其属性值和构造函数参数值（可以在bean工厂后处理期间修改）。
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    //返回所有bean名称的迭代对象
	Iterator<String> getBeanNamesIterator();

    //清除合并的bean定义缓存，删除尚未被认为有资格进行完整元数据缓存的bean条目。
	void clearMetadataCache();

    //冻结所有bean定义，表明注册的bean定义不会被修改或进一步后处理。
	void freezeConfiguration();

    //返回是否冻结此工厂的bean定义
	boolean isConfigurationFrozen();

    //确保所有非lazy-init单例都被实例化
	void preInstantiateSingletons() throws BeansException;

}

1.6 BeanFactory总结

分析了从BeanFactory到ConfigurableListableBeanFactory接口的概要功能

• BeanFactory–>SpringIoC容器顶级接口,定义了对单个bean的获取,对bean的作用域判断,获取bean类型,获取bean别名的功能
• ListableBeanFactory–>扩展了BeanFactory接口,并提供了对bean的枚举能力
• HierarchicalBeanFactory–>扩展了BeanFactory接口,并提供了访问父容器的能力
• AutowireCapableBeanFactory–>扩展了BeanFactory接口,并提供了自动装配能力
• ConfigurableBeanFactory–>扩展了HierarchicalBeanFactory,并提供了对容器的配置能力
• ConfigurableListableBeanFactory–>扩展了ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory接口,并提供了忽略依赖,自动装配判断,冻结bean的定义,枚举所有bean名称的功能

以上介绍BeanFactory接口的分支,下面介绍AliasRegistry接口的分支,该分支下大部分都是实现类,代码较多,也较为复杂,其中细节,留在以后分析,下面只说下类的主要作用

2. AliasRegistry接口及其实现类简介

• AliasRegistry–>定义bean的别名管理
• SimpleAliasRegistry–>实现别名管理接口
• SingletonBeanRegistry–>提供单例注册,查询服务
• DefaultSingletonBeanRegistry–>实现单例与DisposableBean的生命周期管理(创建,维护,销毁)
• FactoryBeanRegistrySupport–>添加工厂方式创建类FactoryBean的支持

本篇主要从概念和功能上让大家对BeanFactory有所了解,接下来几篇介绍IoC容器的初始化及bean的获取