spring(BeanFactory)

最新推荐文章于 2024-08-04 14:34:04 发布

神笔码靓

最新推荐文章于 2024-08-04 14:34:04 发布

阅读量64

点赞数

原文链接：https://www.jianshu.com/p/e50a848932e0

版权

1. BeanFactory 简介

BeanFactory 是IoC容器的顶级接口，是IoC容器的最基础实现，也是访问Spring容器的根接口，负责对bean的创建，访问等工作。

1.1 BeanFactory 类结构图

这里以XmlBeanFactory 为例：
在这里插入图片描述
说明：

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

从图中可以看到，顶级接口分别是

BeanFactory,
SingletonBeanRegistry,
AliasRegistry

1.2 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);
}

BeanFactory的直接子接口：

ListableBeanFactory, 提供了对bean的枚举能力
HierarchicalBeanFactory, 对父容器的访问能力
AutowireCapableBeanFactory ，对bean的自动装配能力

1.2.1 ListableBeanFactory

//扩展了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.2 HierarchicalBeanFactory

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

    @Nullable
    BeanFactory getParentBeanFactory();

    boolean containsLocalBean(String name);

}

1.2.3 AutowireCapableBeanFactory

//扩展了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;

}

1.2.4 ConfigurableBeanFactory

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.2.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.2.6 BeanFactory总结

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