Spring5源码（13）-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接口,提供了对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;
}

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

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

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

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