BeanFactory介绍

BeanFactory是用于访问Spring Bean容器的根接口，是bean容器的最基本的实现。其子接口（如ListableBeanFactory和ConfigurableListableBeanFactory）是用于特定功能的扩展接口。主要是负责bean的创建，访问等工作。

• 在Spring中，顶级接口分别为BeanFactory,SingletonBeanRegistry,AliasRegistry

1.1 BeanFactory源码

//Spring IoC容器等级接口
public interface BeanFactory {
    // 区分是获取FactoryBean还是FactoryBean的createBean创建的实例.如果&开始则获取FactoryBean;否则获取createBean创建的实例.
    // 注意理解BeanFactory和FactoryBean.FactoryBean接口是一个可以返回实例bean的工厂bean
    String FACTORY_BEAN_PREFIX = "&";
    //获取单个bean的实例
    Object getBean(String var1) throws BeansException;
    <T> T getBean(String var1, Class<T> var2) throws BeansException;
    Object getBean(String var1, Object... var2) throws BeansException;
    <T> T getBean(Class<T> var1) throws BeansException;
    <T> T getBean(Class<T> var1, Object... var2) throws BeansException;
    <T> ObjectProvider<T> getBeanProvider(Class<T> var1);
    <T> ObjectProvider<T> getBeanProvider(ResolvableType var1);
    boolean containsBean(String var1);
    boolean isSingleton(String var1) throws NoSuchBeanDefinitionException;
    boolean isPrototype(String var1) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String var1, ResolvableType var2) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String var1, Class<?> var2) throws NoSuchBeanDefinitionException;
    @Nullable
    Class<?> getType(String var1) throws NoSuchBeanDefinitionException;
    @Nullable
    Class<?> getType(String var1, boolean var2) throws NoSuchBeanDefinitionException;
    String[] getAliases(String var1);
}

1.2 ListableBeanFactory接口源码(继承BeanFactory接口)

//扩展了BeanFactory接口
//获取bean实例集合，BeanFactory只能获取单个bean实例
//注意：该接口只返回当前bean容器中的bean集合，不会考虑父容器的bean实例结婚
public interface ListableBeanFactory extends BeanFactory {
    boolean containsBeanDefinition(String var1);
    int getBeanDefinitionCount();
    String[] getBeanDefinitionNames();
    String[] getBeanNamesForType(ResolvableType var1);
    String[] getBeanNamesForType(ResolvableType var1, boolean var2, boolean var3);
    String[] getBeanNamesForType(@Nullable Class<?> var1);
    String[] getBeanNamesForType(@Nullable Class<?> var1, boolean var2, boolean var3);
    <T> Map<String, T> getBeansOfType(@Nullable Class<T> var1) throws BeansException;
    <T> Map<String, T> getBeansOfType(@Nullable Class<T> var1, boolean var2, boolean var3) throws BeansException;
    //获取指定注解的bean
    String[] getBeanNamesForAnnotation(Class<? extends Annotation> var1);
    Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> var1) throws BeansException;
    @Nullable
    <A extends Annotation> A findAnnotationOnBean(String var1, Class<A> var2) throws NoSuchBeanDefinitionException;
}

1.3 HierarchicalBeanFactory接口源码(继承BeanFactory接口)

//扩展了BeanFactory接口
//主要是提供了访问父容器的功能
public interface HierarchicalBeanFactory extends BeanFactory {
    @Nullable
    BeanFactory getParentBeanFactory();
    boolean containsLocalBean(String var1);
}

1.4 AutowireCapableBeanFactory接口源码(继承BeanFactory接口)

//扩展了BeanFactory接口
//主要是提供了自动转配的功能
public interface AutowireCapableBeanFactory extends BeanFactory {
    int AUTOWIRE_NO = 0;           //不自动装配
    int AUTOWIRE_BY_NAME = 1;      //by-name装配
    int AUTOWIRE_BY_TYPE = 2;      //by-type装配
    int AUTOWIRE_CONSTRUCTOR = 3;  //构造函数装配
    /** @deprecated */
    @Deprecated
    int AUTOWIRE_AUTODETECT = 4; //自动装配，已过时
    String ORIGINAL_INSTANCE_SUFFIX = ".ORIGINAL";

    //-------------------------------------------------------------------------
    // 创建和填充外部bean实例的典型方法
    //-------------------------------------------------------------------------
    //由某类型的.class创造一个bean。
    <T> T createBean(Class<T> var1) throws BeansException;
    void autowireBean(Object var1) throws BeansException;
    Object configureBean(Object var1, String var2) throws BeansException;
     //-------------------------------------------------------------------------
    // 用于细粒度控制bean生命周期的方法
    //-------------------------------------------------------------------------
    Object createBean(Class<?> var1, int var2, boolean var3) throws BeansException;
    Object autowire(Class<?> var1, int var2, boolean var3) throws BeansException;
    void autowireBeanProperties(Object var1, int var2, boolean var3) throws BeansException;
    void applyBeanPropertyValues(Object var1, String var2) throws BeansException;
    Object initializeBean(Object var1, String var2) throws BeansException;
    Object applyBeanPostProcessorsBeforeInitialization(Object var1, String var2) throws BeansException;
    Object applyBeanPostProcessorsAfterInitialization(Object var1, String var2) throws BeansException;
    void destroyBean(Object var1);
    //-------------------------------------------------------------------------
    // 委托方法解决注入点
    //-------------------------------------------------------------------------
    <T> NamedBeanHolder<T> resolveNamedBean(Class<T> var1) throws BeansException;
    Object resolveBeanByName(String var1, DependencyDescriptor var2) throws BeansException;
    @Nullable
    Object resolveDependency(DependencyDescriptor var1, @Nullable String var2) throws BeansException;
    @Nullable
    Object resolveDependency(DependencyDescriptor var1, @Nullable String var2, @Nullable Set<String> var3, @Nullable TypeConverter var4) throws BeansException;
}

上述三个接口是BeanFactory的三个直接子接口，分别扩展了对bean的集合获取，访问bean的父容器，对bean的自动装配功能

1.3.1 ConfigurableBeanFactory接口(继承HierarchicalBeanFactory)

与BeanFactory是间接继承关系:ConfigurableBeanFactory --> HierarchicalBeanFactory --> BeanFactory

//扩展了两个接口,主要扩展了对BeanFactory的配置能力
//主要功能：作用域,父工厂,类加载器,类型转化,BeanPostProcessor,属性编辑,bean的定义,bean依赖关系,合并其他ConfigurableBeanFactory,bean如何销毁等
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
    String SCOPE_SINGLETON = "singleton";//单例范围,只创建一次bean
    String SCOPE_PROTOTYPE = "prototype";//原型范围,每次获取bean都会创建一次
    //设置父级容器，可以继承父容器中的bean，与HierarchicalBeanFactory中的getParentBeanFactory互补
    void setParentBeanFactory(BeanFactory var1) throws IllegalStateException;
    //设置类加载器以用于加载bean类。默认是线程上下文类加载器。
    void setBeanClassLoader(@Nullable ClassLoader var1);
    @Nullable
    ClassLoader getBeanClassLoader();
    //指定用于类型匹配目的的临时ClassLoader
    void setTempClassLoader(@Nullable ClassLoader var1);
    @Nullable
    ClassLoader getTempClassLoader();
    //缓存bean元数据，例如给定的bean定义（以合并方式）和已解析的bean类。默认true。
    //关闭此标志以启用bean定义对象的热刷新，特别是bean类。如果此标志关闭，则任何bean实例的创建都将为新解析的类重新查询bean类加载器。
    void setCacheBeanMetadata(boolean var1);
    boolean isCacheBeanMetadata();
    //为bean定义值中的表达式指定解析策略。
    //默认情况下，BeanFactory中没有活动表达式支持。ApplicationContext通常会在此处设置标准表达式策略，支持Unified EL兼容样式中的“＃{...}”表达式。
    void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);
    @Nullable
    BeanExpressionResolver getBeanExpressionResolver();
    //指定用于转换属性值的Spring 3.0 ConversionService，作为JavaBeans PropertyEditors的替代方法。
    void setConversionService(@Nullable 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)
    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.3.1.1 ConfigurableListableBeanFactory接口

ConfigurableListableBeanFactory--> ListableBeanFactory-->BeanFactory
ConfigurableListableBeanFactory--> AutowireCapableBeanFactory-->BeanFactory
ConfigurableListableBeanFactory--> ConfigurableBeanFactory-->HierarchicalBeanFactory-->BeanFactory

//继承了三个接口，扩展了忽略依赖，自动装配判断，冻结bean的定义，获取beanName集合的功能
public interface ConfigurableListableBeanFactory extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
    //忽略给定的依赖关系
    void ignoreDependencyType(Class<?> var1);
    void ignoreDependencyInterface(Class<?> var1);
    //注册特殊依赖关系
    void registerResolvableDependency(Class<?> var1, @Nullable Object var2);
    //确定指定的bean是否有资格作为autowire候选者，注入到声明匹配类型依赖关系的其他bean中
    boolean isAutowireCandidate(String var1, DependencyDescriptor var2) 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;
}

部分转载自:https://www.jianshu.com/p/e50a848932e0