Spring容器架构

Spring容器家族

BeanFactory：Spring容器的基石，顶级容器接口

在Spring官方文档中，称org.springframework.context.ApplicationContext这个接口就代表了Spring的容器，在解释ApplicationContext之前，必须要先介绍Spring容器的基石，BeanFactory接口。ApplicationContext就是继承了BeanFactory接口的一种高级容器接口。而BeanFactory是简单容器的代表，是Spring容器家族的基石，所有的容器都必须实现这个接口。

• BeanFactory接口的源码，主要规定了一些容器的基本功能，其中有7个获取Bean或者Bean提供者的方法，5个判断型的方法，2个获取类型的方法，1个获取别名的方法。通过这些方法，可以看出BeanFactory是一个典型的工厂模式的工厂接口。

public interface BeanFactory {
   /**
   * 对FactoryBean的转移定义，提供获取FactoryBean实例的方法。
   * 如果定义bean时是通过工厂模式配置Bean的，那么通过bean的名字检索FactoryBean时
   * 得到的会是FactoryBean生产出来的实例，如果想得到工厂本身，需要进行转义
   */
    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;
     /**
       * 获取Bean的提供者（工厂）
      */
    <T> ObjectProvider<T> getBeanProvider(Class<T> var1);

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

     // 检索是否包含指定名字的bean
  boolean containsBean(String name);
  // 判断指定名字的bean是否为单例
  boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
  // 判断指定名字的bean是否为原型
  boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

  /**
   * 指定名字的Bean是否匹配指定的类型
   */
  boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
  boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

  /**
   * 获取指定名字的Bean的类型
   */
  @Nullable
  Class<?> getType(String name) throws NoSuchBeanDefinitionException;
  @Nullable
  Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;

  // 获取指定名字Bean的所有别名
  String[] getAliases(String name);
}

顶级二级接口：ListableBeanFactory和HierarchicalBeanFactroy。

• ListableBeanFactory：该接口拥有列出工厂中所有Bean的能力。ListableBeanFactory主要对外提供了批量获取Bean和BeanDefinition的方法，拓展类了BeanFactory的功能，是一个非常重要的接口。

    

public interface ListableBeanFactory extends BeanFactory {
  
  // 检索是否包含给定beanName的BeanDefinition
  boolean containsBeanDefinition(String beanName);
  // 获取工厂中BeanDefinition的数量
  int getBeanDefinitionCount();
  // 获取工厂中所有BeanDefinition的Names
  String[] getBeanDefinitionNames();
  // 获取指定类型的beanNames
  String[] getBeanNamesForType(ResolvableType type);
  String[] getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit);
  String[] getBeanNamesForType(@Nullable Class<?> type);
  String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);
  // 根据指定的类型来获取所有Bean
  <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;
  // 根据指定的直接获取beanNames
  String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);
  // 获取所有指定注解标注的Bean实例，Autowired就是使用的该接口
  Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;
  // 查找指定Bean中含有的注解类型
  @Nullable
  <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
      throws NoSuchBeanDefinitionException;

}

HierarchicalBeanFactroy接口：顾名思义，这是一个分层的工厂。该接口实现了Bean工厂的分层。提供了一个非常重要的功能——工厂分层，通过工厂分层，SpringIoC容器可以建立父子层级关联的容器体系，子容器可以访问父容器中的Bean，而父容器不能访问子容器中的Bean。在容器内，Bean的id必须是唯一的，但子容器可以拥有一个和父容器id相同的Bean。父子容器层级体系增强了Spring容器架构的扩展性和灵活性，因为第三方可以通过编程的方式，为一个已经存在的容器添加一个或多个特殊用途的子容器，以提供一些额外的功能，Spring使用父子容器实现了很多功能，比如在Spring MVC中，展现层Bean位于一个子容器中，而业务层和持久层的Bean位于父容器中。这样，展现层Bean就可以引用业务层和持久层的Bean，而业务层和持久层的Bean则看不到展现层的Bean。

public interface HierarchicalBeanFactory extends BeanFactory {

  /**
   * 返回父级工厂
   */
  @Nullable
  BeanFactory getParentBeanFactory();

  /**
   * 检索本地工厂是否包含指定名字的Bean
   */
  boolean containsLocalBean(String name);

}

复杂配置的Bean工厂：ConfigurableBeanFactory接口 ConfigurableBeanFactory接口是一个继承了HierarchicalBeanFactroy的子接口，同时该接口还继承了SingletonBeanRegistry接口，SingletonBeanRegistry是一个用来注册单例类的接口，提供了同意访问单例Bean的功能，ConfigurableBeanFactory接口主要扩展了一些复杂的对单例Bean的配置与操作，虽然这个接口并没有被ApplicationContext高级容器体系所继承，但是一般的容器实现类都会继承或实现这个接口，目的是使用一种统一的方式对外暴露管理单例Bean的方式。

SingletonBeanRegistry接口的方法：

public interface SingletonBeanRegistry {

  /**
   * 单例的注册，如果脱离生命周期单独调用该方法，就是单纯的注册而不执行
   *     诸如生命周期回调等相关
   * 通常，是容器在基于 BeanDefinition 创建 singleton 时调用该方法的
   */
  void registerSingleton(String beanName, Object singletonObject);

  /**
   * 获取以及实例化完成的 singleton
   * 1）手动 registerSingleton 注册的
   * 2）容器基于 BeanDefinition 实例化完成后注册的
   */
  @Nullable
  Object getSingleton(String beanName);

  /**
   * 检查指定 singleton 是否存在
   * 该方法 + ListableBeanFactory#containsBeanDefinition：可以查看当前容器中是否可以
   *     获取到指定 name 的 bean，无论它是否实例化完成
   * BeanFactory#containsBean 在上一步基础上，还可以查找父级容器    
   */
  boolean containsSingleton(String beanName);

  // 上述 singleton 名称数组
  String[] getSingletonNames();

  // 上述 singleton 个数
  int getSingletonCount();

  // 单例锁对象
  Object getSingletonMutex();

}

ConfigurableBeanFactory接口的方法：

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
 
  //单例
  String SCOPE_SINGLETON = "singleton";
 
  //原型
  String SCOPE_PROTOTYPE = "prototype";
 
 
  //设置父类的BeanFactory,可以在HierarchicalBeanFactory中看到父类的BeanFactory的设置
  void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;
 
  //设置类加载器
  void setBeanClassLoader(ClassLoader beanClassLoader);
 
  //获取类加载器
  ClassLoader getBeanClassLoader();
 
  //设置临时加载器
  void setTempClassLoader(ClassLoader tempClassLoader);
 
  //获取临时加载器
  ClassLoader getTempClassLoader();
 
  //设置是否缓存源，false，从新从类加载器加载
  void setCacheBeanMetadata(boolean cacheBeanMetadata);
 
  //是否缓存了definitions
  boolean isCacheBeanMetadata();
 
   //bean的表达式解析
  void setBeanExpressionResolver(BeanExpressionResolver resolver);
 
    //获取bean的表达式解析
  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();
 
// 增加一个嵌入式的StringValueResolve
  void addEmbeddedValueResolver(StringValueResolver valueResolver);
 
    //确定定是否有一个嵌入式的value resolver已经在这个bean factory中注册了,并且可以通过resolveEmbeddedValue函数来应用.
  String resolveEmbeddedValue(String value);
 
  //增加一个BeanPostProcessor的处理器 前后
  void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
 
  //获取BeanPostProcessor的数量
  int getBeanPostProcessorCount();
 
   //注册bean的范围
  void registerScope(String scopeName, Scope scope);
 
  //获取bean的范围
  String[] getRegisteredScopeNames();
 
    //获取注册的范围
  Scope getRegisteredScope(String scopeName);
 
    //返回本工厂的一个安全访问上下文
  AccessControlContext getAccessControlContext();
 
   //复制其他工程的属性配置
  void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);
 
  //给指定的bean注册别名
  void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;
 
  //根据StringValueResolver来移除bean
  void resolveAliases(StringValueResolver valueResolver);
 
  //返回合并后的Beandefinition
  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
  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);
 
  //销毁指定的
  void destroyScopedBean(String beanName);
 
  //销毁单例对象
  void destroySingletons();
 
}

自动装配工厂：AutowireCapableBeanFactory接口 直接继承自BeanFactory接口，主要作用是将自动装配的能力对外暴露出来，可以通过实现此接口实现自动装配能力，但是正常情况下不应该使用该接口。此接口主要针对框架之外，没有向Spring托管的Bean的应用。

public interface AutowireCapableBeanFactory extends BeanFactory {
 
  /**
   * Constant that indicates no externally defined autowiring. Note that
   * BeanFactoryAware etc and annotation-driven injection will still be applied.
   * @see #createBean
   * @see #autowire
   * @see #autowireBeanProperties
   */
    //表明没有外部定义自动装配的bean
  int AUTOWIRE_NO = 0;
 
  //根据名称自动装配bean（适用于Bean所有属性的setter）
  int AUTOWIRE_BY_NAME = 1;
 
  //根据类型自动装配bean（适用于Bean所有属性的setter）
  int AUTOWIRE_BY_TYPE = 2;
 
  //根据构造器自动装配bean（构造函数）
  int AUTOWIRE_CONSTRUCTOR = 3;
 
  //通过class的内部来自动装配bean
    //已经被启用
  @Deprecated
  int AUTOWIRE_AUTODETECT = 4;
 
 
  //-------------------------------------------------------------------------
  // Typical methods for creating and populating external bean instances
  //-------------------------------------------------------------------------
 
  //根据给定的class创建bean
  <T> T createBean(Class<T> beanClass) throws BeansException;
 
  //通过调用给定Bean的after-instantiation及post-processing接口，对bean进行配置。
  void autowireBean(Object existingBean) throws BeansException;
 
  // 配置参数中指定的bean，包括自动装配其域，对其应用如setBeanName功能的回调函数。
  Object configureBean(Object existingBean, String beanName) throws BeansException;
 
  //解析出在Factory中与指定Bean有指定依赖关系的Bean
  Object resolveDependency(DependencyDescriptor descriptor, String beanName) throws BeansException;
 
 
  //　创建一个指定class的实例，通过参数可以指定其自动装配模式（by-name or by-type）.
  Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
 
  //通过指定的自动装配策略来初始化一个Bean。
  Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
 
  //　通过指定的自动装配方式来对给定的Bean进行自动装配
  void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
      throws BeansException;
 
  //将参数中指定了那么的Bean，注入给定实例当中
  void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;
 
  //初始化参数中指定的Bean，调用任何其注册的回调函数如setBeanName、setBeanFactory等。
  Object initializeBean(Object existingBean, String beanName) throws BeansException;
 
  //调用参数中指定Bean的postProcessBeforeInitialization方法
  Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
      throws BeansException;
 
  //　调用参数中指定Bean的postProcessAfterInitialization方法
  Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
      throws BeansException;
 
  //销毁参数中指定的Bean
  void destroyBean(Object existingBean);
 
  //解析指定Bean在Factory中的依赖关系
  Object resolveDependency(DependencyDescriptor descriptor, String beanName,
      Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException;
 
}

• Bean工厂接口的集大成者：ConfigurableListableBeanFactory 接口 继承了ListableBeanFactory和可配置bean工厂**ConfigurableBeanFactory接口的子接口，同时它还继承了AutowireCapableBeanFactory**接口，并且自身还扩展了一些功能

• 可配置bean工厂**ConfigurableBeanFactory**接口，有两个父接口，一个为HierarchicalBeanFactory，一个为SingletonBeanRegistry

  • ConfigurableBeanFactory接口源码ConfigurableBeanFactory接口主要提供了，bean作用域，类加载器，临时类加载器，Spring EL解决器，转换服务 ConversionService，属性编辑器注册器，嵌入值解决器，bean后处理的配置操作，同时提供了，是否缓存bean的元数据，设置bean的创建状态，判断bean是否为工厂bean，拷贝bean工厂的配置，获取bean的定义，设置bean的别名，解决基于bean的name的依赖，获取bean的依赖bean信息和获取依赖于bean的bean的name操作，还有销毁给定作用域的bean。需要注意的是，设置bean的创建状态操作属于容器的内部操作，获取作用域时，不包括单例和原型作用域。此接口不能够在应用中直接调用，要配合{@link org.springframework.beans.factory.BeanFactory} 或@link org.springframework.beans.factory.ListableBeanFactory}使用。此接口的扩展接口，运行框架内部使用，用于访问bean工厂的配置方法。

package org.springframework.beans.factory.config;

import java.beans.PropertyEditor;
import java.security.AccessControlContext;

import org.springframework.beans.PropertyEditorRegistrar;
import org.springframework.beans.PropertyEditorRegistry;
import org.springframework.beans.TypeConverter;
import org.springframework.beans.factory.BeanDefinitionStoreException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.HierarchicalBeanFactory;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.core.convert.ConversionService;
import org.springframework.util.StringValueResolver;

/**
 *ConfigurableBeanFactory是一个大多数bean工厂都会实现的接口。为配置bean工厂和工厂接口中客户端操作，
 *提供了便利。
 * 配置bean工厂不以为者可以在应用代码中，直接使用：应配合{@link org.springframework.beans.factory.BeanFactory}
 * 或@link org.springframework.beans.factory.ListableBeanFactory}使用。
 * 此接口的扩展接口，运行框架内部使用，用于访问bean工厂的配置方法。
 *
 * @author Juergen Hoeller
 * @since 03.11.2003
 * @see org.springframework.beans.factory.BeanFactory
 * @see org.springframework.beans.factory.ListableBeanFactory
 * @see ConfigurableListableBeanFactory
 */
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {

  /**
   * 标准的单例作用域模式标识。一般的作用域可以通过{@code registerScope}方法注册。
   * @see #registerScope
   */
  String SCOPE_SINGLETON = "singleton";

  /**
   * 标准的原型作用域模式标识。一般的作用域可以通过{@code registerScope}方法注册。
   * @see #registerScope
   */
  String SCOPE_PROTOTYPE = "prototype";


  /**
   * 设置bean工厂的父bean工厂。需要注意的是，如果父类bean工厂在工厂初始化的时候，如果不可能，
   * 应该在构造外部进行设置，这时父类不能改变。
   * @param parentBeanFactory the parent BeanFactory
   * @throws IllegalStateException if this factory is already associated with
   * a parent BeanFactory
   * @see #getParentBeanFactory()
   */
  void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;

  /**
   * 设置工厂加载bean类的类加载器。默认为当前线程上下文的类加载器。
   * 需要注意的是，如果类的定义还有对应的bean类型解决器，类加载器只能应用于bean的定义。
   * 从spring2.0开始，一旦工厂处理bean的定义，仅仅拥有bean类型名字的bean定义才能被解决。
   * @param beanClassLoader the class loader to use,
   * or {@code null} to suggest the default class loader
   */
  void setBeanClassLoader(ClassLoader beanClassLoader);

  /**
   * 返回当前bean工厂的类加载器。
   */
  ClassLoader getBeanClassLoader();

  /**
   * 设置工厂的临时类加载器，一般用于类型匹配的目的。默认为无，简单地使用标准的bean类型加载器。
   * 如果处于加载织入时间（load-time weaving），为确保实际的bean类型尽可能的懒加载，
   * 一个临时的类加载器通常需要指定。一旦在bean工厂启动完成阶段后，临时类加载器将会被移除。
   * @since 2.5
   */
  void setTempClassLoader(ClassLoader tempClassLoader);

  /**
   * 返回临时类加载器
   * if any.
   * @since 2.5
   */
  ClassLoader getTempClassLoader();

  /**
   *设置是否缓存bean的元数据，比如bean的定义，bean类型解决器。默认是缓存。
   * 关闭缓存bean元数据，将会开启一些特殊bean定义对象的热刷新。如果关闭缓存，
   * 任何bean实例创建时，将会重新为新创建的类查询bean类加载器。
   */
  void setCacheBeanMetadata(boolean cacheBeanMetadata);

  /**
   * 返回当前是否缓存bean的元数据。
   */
  boolean isCacheBeanMetadata();

  /**
   * 设置bean定义中的表达式值的解析器。BeanExpressionResolver
   * 默认情况下，bean工厂中，是不支持表达式的。应用上下文将会设置一个标准的表达式策略
   * 解析器，以统一的Spring EL 兼容形式，支持"#{...}"表达式。
   * @since 3.0
   */
  void setBeanExpressionResolver(BeanExpressionResolver resolver);

  /**
   * 获取bean定义中的表达式值的解析器
   * @since 3.0
   */
  BeanExpressionResolver getBeanExpressionResolver();

  /**
   * 设置用于转换bean的属性的转换服务ConversionService。可以作为java bean的属性
   * 编辑器PropertyEditors的一种替代。
   * @since 3.0
   */
  void setConversionService(ConversionService conversionService);

  /**
   * 获取类型转换服务
   * @since 3.0
   */
  ConversionService getConversionService();

  /**
   * 添加一个属性编辑注册器应用到所有bean的创建过程。
   * 属性编辑注册器创建一个属性编辑器实例，并注册到给定的注册器中，并尝试刷新每个bean的创建。
   * 注意需要避免与定制编辑器之间的同步，因此一般情况下，最好使用addPropertyEditorRegistrar方法，
   * 替代{@link #registerCustomEditor}方法。
   * @param registrar the PropertyEditorRegistrar to register
   */
  void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);

  /**
   * 注册给定的定制属性编辑器到给定类型的所有属性。在工厂配置的过程中调用。
   * 注意此方法注册一个共享的定制编辑器实例，可以线程安全地访问编辑器实例。
   * 最好使用addPropertyEditorRegistrar方法， 替代{@link #registerCustomEditor}方法。
   * 以避免定制编辑器的同步。
   * @param requiredType type of the property
   * @param propertyEditorClass the {@link PropertyEditor} class to register
   */
  void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);

  /**
   * 初始化已经注册到bean工厂的属性编辑注册器与定制编辑器的关系。
   * @param registry the PropertyEditorRegistry to initialize
   */
  void copyRegisteredEditorsTo(PropertyEditorRegistry registry);

  /**
   * 谁知bean工厂用于bean属性值或构造参数值转换的类型转化器。
   * 此方法将会重写默认属性编辑器机制，因此使任何定制编辑器或编辑注册器不相关。
   * @see #addPropertyEditorRegistrar
   * @see #registerCustomEditor
   * @since 2.5
   */
  void setTypeConverter(TypeConverter typeConverter);

  /**
   * 获取bean工厂的类型转换器。有类型转化器是非线程安全的，每次调用，返回的可能是一个新的实例。
   * 如果默认的属性编辑器机制激活，通过返回的类型转换器，可以了解到所有注册的属性编辑器。
   * @since 2.5
   */
  TypeConverter getTypeConverter();

  /**
   * Add a String resolver for embedded values such as annotation attributes.
   * @param valueResolver the String resolver to apply to embedded values
   * @since 3.0
   */
  void addEmbeddedValueResolver(StringValueResolver valueResolver);

  /**
   * 判断是否注册嵌入值解决器到bean工厂，可以用于{@link #resolveEmbeddedValue(String)}方法。
   * @since 4.3
   */
  boolean hasEmbeddedValueResolver();

  /**
   * 解决给定的嵌入值，比如注解属性
   * @param value the value to resolve
   * @return the resolved value (may be the original value as-is)
   * @since 3.0
   */
  String resolveEmbeddedValue(String value);

  /**
   * 添加一个bean后处理器，将会用于bean工厂创建的bean。在工厂配置的工厂，将会调用。
   * 需要注意的是，bean后处理器处理的顺序与注册的顺序有关；任何实现{@link org.springframework.core.Ordered}
   * 接口的bean后处理器的排序语义将会被忽略。在程序中注册一个bean后处理器，将会自动探测上下文中的
   * bean后处理器。
   * @param beanPostProcessor the post-processor to register
   */
  void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);

  /**
   * 获取当前注册的bean后处理器数量。时
   */
  int getBeanPostProcessorCount();

  /**
   * 依赖于给定作用的实现，注册给定的作用域，
   * @param scopeName the scope identifier
   * @param scope the backing Scope implementation
   */
  void registerScope(String scopeName, Scope scope);

  /**
   * 返回当前注册的作用与的name集。
     * 此方法将会返回显示地注册的作用域。
   * 单例和原型模式作用域不会暴露。
   * @return the array of scope names, or an empty array if none
   * @see #registerScope
   */
  String[] getRegisteredScopeNames();

  /**
   * 根据给定作用域的name，返回相应的实现。此方法将会返回显示地注册的作用域。
   * 单例和原型模式作用域不会暴露。
   * @param scopeName the name of the scope
   * @return the registered Scope implementation, or {@code null} if none
   * @see #registerScope
   */
  Scope getRegisteredScope(String scopeName);

  /**
   * 返回当前工厂相关的安全访问控制上下文java.security.AccessControlContext。
   * @return the applicable AccessControlContext (never {@code null})
   * @since 3.0
   */
  AccessControlContext getAccessControlContext();

  /**
   * 从给定的工厂，拷贝所有相关的配置。
   * 应包括所有标准的配置，bean后处理器，作用域，工厂内部设置。
   * 不包括任何实际bean定义的元数据，比如bean定义对象，bean的别名。
   * @param otherFactory the other BeanFactory to copy from
   */
  void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

  /**
   * 创建给定bean name的别名。这个方法支持bean的name，在XML配置中，属于非法，xml只支持ids别名。
   * 在工厂配置，经常配置调用，但是也可以使用运行时注册别名。因此，一个工厂的实现，
   * 应该同步别名访问。
   * @param beanName the canonical name of the target bean
   * @param alias the alias to be registered for the bean
   * @throws BeanDefinitionStoreException if the alias is already in use
   * 如果别名已经存在，则抛出BeanDefinitionStoreException。
   */
  void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;

  /**
   * 在解决所有目标name的别名和注册到工厂的别名，使用给定的StringValueResolver。
   * <p>The value resolver may for example resolve placeholders
   * in target bean names and even in alias names.
   * 值解决的例子，比如解决给定bean的名称甚至别名中的占位符。
   * @param valueResolver the StringValueResolver to apply
   * @since 2.5
   */
  void resolveAliases(StringValueResolver valueResolver);

  /**
   * 返回给定bean的名称对应的合并bean定义，如果需要使用它的父工厂合并一个孩子的bean定义。
   * 考虑祖先bean工厂中的bean定义。
   * @param beanName the name of the bean to retrieve the merged definition for
   * @return a (potentially merged) BeanDefinition for the given bean
   * @throws NoSuchBeanDefinitionException if there is no bean definition with the given name
   * @since 2.5
   */
  BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

  /**
   * 检查给定name的bean是否在工厂中。
   * @param name the name of the bean to check
   * @return whether the bean is a FactoryBean
   * ({@code false} means the bean exists but is not a FactoryBean)
   * @throws NoSuchBeanDefinitionException if there is no bean with the given name
   * @since 2.5
   */
  boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;

  /**
   * 显示地控制指定bean的创建状态，仅仅容器内部使用。
   * @param beanName the name of the bean
   * @param inCreation whether the bean is currently in creation
   * @since 3.1
   */
  void setCurrentlyInCreation(String beanName, boolean inCreation);

  /**
   * 判断当前bean是否创建。
   * @param beanName the name of the bean
   * @return whether the bean is currently in creation
   * @since 2.5
   */
  boolean isCurrentlyInCreation(String beanName);

  /**
   * 注册一个依赖bean到给定的bean，在给定bean销毁前销毁依赖的bean。
   * @param beanName the name of the bean
   * @param dependentBeanName the name of the dependent bean
   * @since 2.5
   */
  void registerDependentBean(String beanName, String dependentBeanName);

  /**
   * 返回依赖于给定bean的所有bean的name。
   * @param beanName the name of the bean
   * @return the array of dependent bean names, or an empty array if none
   * @since 2.5
   */
  String[] getDependentBeans(String beanName);

  /**
   * 返回给定bean的所有依赖bean的name。
   * @param beanName the name of the bean
   * @return the array of names of beans which the bean depends on,
   * or an empty array if none
   * @since 2.5
   */
  String[] getDependenciesForBean(String beanName);

  /**
   * 根据bean的定义，销毁给定bean的实例，通常为一个原型bean实例。
   * 在析构的过程中，任何异常应该被捕捉，同时log，而不是传给方法的调用者。
   * @param beanName the name of the bean definition
   * @param beanInstance the bean instance to destroy
   */
  void destroyBean(String beanName, Object beanInstance);

  /**
   * 销毁当前目标作用的指定作用域bean。
   * 在析构的过程中，任何异常应该被捕捉，同时log，而不是传给方法的调用者。
   * @param beanName the name of the scoped bean
   */
  void destroyScopedBean(String beanName);

  /**
   * 销毁所有工厂中的单例bean，包括内部bean，比如已经被注册为disposable的bean。
   * 在工厂关闭的时候，将会被调用。
   * 在析构的过程中，任何异常应该被捕捉，同时log，而不是传给方法的调用者。
   */
  void destroySingletons();

}

SingletonBeanRegistry接口源码

package org.springframework.beans.factory.config;

/**
 *SingletonBeanRegistry接口为共享bean实例的注册器。可以被{@link org.springframework.beans.factory.BeanFactory}，
 *实现&