spring-reading./spring-factory/spring-factory-configurableBeanFactory

ConfigurableBeanFactory

• ConfigurableBeanFactory
  • 一、基本信息
  • 二、基本描述
  • 三、主要功能
  • 四、接口源码
  • 五、最佳实践
  • 六、与其他组件的关系
  • 七、常见问题

一、基本信息

✒️ 作者 - Lex 📝 博客 - 掘金 📚 源码地址 - github

二、基本描述

ConfigurableBeanFactory接口是Spring框架中的一个子接口，提供了一组方法用于在运行时配置和定制BeanFactory。通过这些方法，可以设置父级BeanFactory、类加载器、表达式解析器、类型转换服务等，以满足特定应用程序的需求。

三、主要功能

1. 设置父级BeanFactory (setParentBeanFactory)

   • 允许将当前的BeanFactory与一个父级BeanFactory相关联，以实现Bean的继承和层次结构。

2. 设置Bean类加载器 (setBeanClassLoader)

   • 允许指定用于加载Bean类的类加载器，使得可以在运行时动态加载Bean的类。

3. 设置临时的类加载器 (setTempClassLoader)

   • 允许配置一个临时的类加载器，该加载器在需要时用于解析类，提供更灵活的类加载机制。

4. 配置是否缓存Bean元数据 (setCacheBeanMetadata)

   • 允许我们配置是否缓存Bean的元数据，以提高性能。

5. 设置Bean表达式解析器 (setBeanExpressionResolver)

   • 允许配置用于解析SpEL表达式的解析器，支持在Bean定义中使用Spring表达式语言。

6. 设置类型转换服务 (setConversionService)

   • 允许配置用于处理属性类型转换的ConversionService，影响属性注入时的类型转换。

7. 注册PropertyEditorRegistrar (addPropertyEditorRegistrar)

   • 允许注册自定义的PropertyEditorRegistrar，以便注册自定义的PropertyEditors，用于处理属性值的类型转换。

8. 设置自动装配候选Bean的解析器 (setAutowireCandidateResolver)

   • 允许配置用于确定自动装配候选Bean的解析器，支持自定义自动装配策略。

9. 设置作用域别名 (setScopeAlias)

   • 允许为指定的作用域设置别名，提供更灵活的作用域配置。

10. 注册Bean别名 (registerAlias)

    • 允许注册给定Bean名称的别名，支持通过不同的名称引用相同的Bean。

11. 设置Bean后处理器 (addBeanPostProcessor)

    • 允许注册自定义的Bean后处理器，用于在Bean初始化前后执行一些自定义逻辑。

12. 设置属性编辑器 (registerCustomEditor)

    • 允许注册自定义的属性编辑器，用于将字符串值转换为特定属性类型。

13. 设置Bean名称生成器 (setBeanNameGenerator)

    • 允许配置用于生成默认Bean名称的Bean名称生成器。

14. 设置范围解析器 (setScopeResolver)

    • 允许配置用于解析范围的解析器，支持自定义作用域的处理逻辑。

15. 设置忽略依赖接口 (ignoreDependencyInterface)

    • 允许配置需要被忽略的依赖接口，以避免它们被自动装配。

四、接口源码

ConfigurableBeanFactory接口是Spring框架中用于配置和定制Bean工厂的关键接口。它提供了设置父级Bean工厂、配置类加载器、设置Bean表达式解析器、注册自定义属性编辑器和后处理器、配置作用域等功能。

/**
 * Configuration接口由大多数Bean工厂实现，提供配置Bean工厂的功能，除了{@link org.springframework.beans.factory.BeanFactory}接口中的客户端方法。
 *
 * <p>这个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 {

    /**
     * 标准单例范围的范围标识符：{@value}。
     * <p>可以通过{@code registerScope}添加自定义范围。
     * @see #registerScope
     */
    String SCOPE_SINGLETON = "singleton";

    /**
     * 标准原型范围的范围标识符：{@value}。
     * <p>可以通过{@code registerScope}添加自定义范围。
     * @see #registerScope
     */
    String SCOPE_PROTOTYPE = "prototype";

    /**
     * 设置这个Bean工厂的父级。
     * <p>请注意，父级不能更改：仅在构造函数之外设置，如果在工厂实例化时不可用。
     * @param parentBeanFactory 父Bean工厂
     * @throws IllegalStateException 如果此工厂已经与父Bean工厂关联
     * @see #getParentBeanFactory()
     */
    void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;

    /**
     * 设置用于加载Bean类的类加载器。
     * 默认为线程上下文类加载器。
     * 注意，此类加载器仅适用于尚未解析Bean类的Bean定义。
     * 这在Spring 2.0默认情况下是这样的：Bean定义只携带Bean类名称，一旦工厂处理Bean定义，就会解析Bean类。
     * @param beanClassLoader 要使用的类加载器，如果为{@code null}，则使用默认类加载器
     */
    void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);

    /**
     * 获取用于加载Bean类的类加载器。
     * （如果系统类加载器不可访问，甚至为{@code null}）。
     * @see org.springframework.util.ClassUtils#forName(String, ClassLoader)
     */
    @Nullable
    ClassLoader getBeanClassLoader();

    /**
     * 指定用于类型匹配目的的临时ClassLoader。
     * 默认为none，简单地使用标准Bean类ClassLoader。
     * 通常，仅在涉及<load-time weaving>时才指定临时ClassLoader，
     * 以确保实际的Bean类尽可能地懒加载。启动后，临时加载程序将被删除。
     * @since 2.5
     */
    void setTempClassLoader(@Nullable ClassLoader tempClassLoader);

    /**
     * 获取用于类型匹配目的的临时ClassLoader，如果有的话。
     * @since 2.5
     */
    @Nullable
    ClassLoader getTempClassLoader();

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

    /**
     * 返回是否缓存诸如给定Bean定义（以合并方式）和已解析Bean类等Bean元数据。
     */
    boolean isCacheBeanMetadata();

    /**
     * 指定Bean定义值中表达式的解析策略。
     * <p>默认情况下，Bean工厂中没有激活表达式支持。
     * ApplicationContext通常在这里设置标准的表达式策略，支持统一EL兼容样式的“＃{...}”表达式。
     * @since 3.0
     */
    void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);

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

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

    /**
     * 返回关联的ConversionService，如果有的话。
     * @since 3.0
     */
    @Nullable
    ConversionService getConversionService();

    /**
     * 添加一个PropertyEditorRegistrar，应用于所有Bean创建过程。
     * <p>此类注册器创建新的PropertyEditor实例，并为每个Bean创建尝试将其注册在给定的注册表上。这避免了对自定义编辑器的同步的需求；
     * 因此，通常最好使用此方法，而不是{@link #registerCustomEditor}。
     * @param registrar 要注册的PropertyEditorRegistrar
     */
    void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);

    /**
     * 注册给定类型的所有属性的自定义属性编辑器。在工厂配置期间调用。
     * <p>请注意，此方法将注册共享的自定义编辑器实例；对该实例的访问将同步以确保线程安全。通常最好使用{@link #addPropertyEditorRegistrar}，
     * 而不是此方法，以避免在自定义编辑器上进行同步的需求。
     * @param requiredType 属性的类型
     * @param propertyEditorClass 要注册的{@link PropertyEditor}类
     */
    void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);

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

    /**
     * 设置此BeanFactory应该用于转换Bean属性值、构造函数参数值等的自定义类型转换器。
     * <p>这将覆盖默认的PropertyEditor机制，因此任何自定义编辑器或自定义编辑器注册器都将变得无关紧要。
     * @since 2.5
     * @see #addPropertyEditorRegistrar
     * @see #registerCustomEditor
     */
    void setTypeConverter(TypeConverter typeConverter);

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

    /**
     * 添加用于嵌入值（如注释属性）的String解析器。
     * @param valueResolver 要应用于嵌入值的String解析器
     * @since 3.0
     */
    void addEmbeddedValueResolver(StringValueResolver valueResolver);

    /**
     * 确定是否已向此工厂注册了嵌入值解析器，以通过{@link #resolveEmbeddedValue(String)}应用它们。
     * @since 4.3
     */
    boolean hasEmbeddedValueResolver();

    /**
     * 解析给定的嵌入值，例如注解属性。
     * @param value 要解析的值
     * @return 已解析的值（可能是原始值）
     * @since 3.0
     */
    @Nullable
    String resolveEmbeddedValue(String value);

    /**
     * 添加将应用于此工厂创建的所有Bean的新BeanPostProcessor。
     * 在工厂配置期间调用。
     * <p>注意：此处提交的后处理器将按照注册的顺序应用；通过实现{@link org.springframework.core.Ordered}接口表达的任何排序语义将被忽略。
     * 请注意，在自动检测到的后处理器（例如，作为应用程序上下文中的bean）之后，总是会应用程序地注册的后处理器。
     * @param beanPostProcessor 要注册的后处理器
     */
    void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);

    /**
     * 返回当前已注册的BeanPostProcessor数量，如果有的话。
     */
    int getBeanPostProcessorCount();

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

    /**
     * 返回当前已注册的所有Scope的名称。
     * <p>这将仅返回明确注册的范围名称。内置范围，如“singleton”和“prototype”将不会被公开。
     * @return 范围名称的数组，如果没有则为空数组
     * @see #registerScope
     */
    String[] getRegisteredScopeNames();

    /**
     * 返回给定范围名称的Scope实现，如果有的话。
     * <p>这将仅返回明确注册的范围。
     * 内置范围，如“singleton”和“prototype”将不会被公开。
     * @param scopeName 范围的名称
     * @return 注册的Scope实现，如果没有则为{@code null}
     * @see #registerScope
     */
    @Nullable
    Scope getRegisteredScope(String scopeName);

    /**
     * 为此Bean工厂设置{@code ApplicationStartup}。
     * <p>这允许应用程序上下文在应用程序启动期间记录度量。
     * @param applicationStartup 新的应用程序启动
     * @since 5.3
     */
    void setApplicationStartup(ApplicationStartup applicationStartup);

    /**
     * 返回此Bean工厂的{@code ApplicationStartup}。
     * @since 5.3
     */
    ApplicationStartup getApplicationStartup();

    /**
     * 提供与此工厂相关的安全访问控制上下文。
     * @return 适用的AccessControlContext（永远不为{@code null}）
     * @since 3.0
     */
    AccessControlContext getAccessControlContext();

    /**
     * 从给定的其他工厂复制所有相关配置。
     * <p>应包括所有标准配置设置，以及BeanPostProcessors、Scopes和工厂特定的内部设置。
     * 不应包括任何实际Bean定义的元数据，如BeanDefinition对象和Bean名称别名。
     * @param otherFactory 要从中复制的其他Bean工厂
     */
    void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

   
	/**
     * 给定一个bean名称，创建一个别名。通常在工厂配置期间调用此方法，但也可以用于别名的运行时注册。因此，工厂实现应该同步别名访问。
     *
     * @param beanName 目标bean的规范名称
     * @param alias 要为bean注册的别名
     * @throws BeanDefinitionStoreException 如果别名已经被使用
     */
    void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;

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

    /**
     * 返回给定bean名称的合并BeanDefinition，如果需要，将子bean定义与其父定义合并。考虑在祖先工厂中的bean定义。
     *
     * @param beanName 要检索合并定义的bean的名称
     * @return 给定bean的（可能合并的）BeanDefinition
     * @throws NoSuchBeanDefinitionException 如果没有给定名称的bean定义
     * @since 2.5
     */
    BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

    /**
     * 确定具有给定名称的bean是否是FactoryBean。
     *
     * @param name 要检查的bean的名称
     * @return bean是否是FactoryBean（{@code false}表示bean存在但不是FactoryBean）
     * @throws NoSuchBeanDefinitionException 如果没有给定名称的bean
     * @since 2.5
     */
    boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;

    /**
     * 显式控制指定bean的当前创建状态。仅供容器内部使用。
     *
     * @param beanName bean的名称
     * @param inCreation bean当前是否正在创建
     * @since 3.1
     */
    void setCurrentlyInCreation(String beanName, boolean inCreation);

    /**
     * 确定指定的bean当前是否正在创建。
     *
     * @param beanName bean的名称
     * @return bean当前是否正在创建
     * @since 2.5
     */
    boolean isCurrentlyInCreation(String beanName);

    /**
     * 为给定的bean注册一个依赖bean，该依赖bean在给定bean被销毁之前将被销毁。
     *
     * @param beanName bean的名称
     * @param dependentBeanName 依赖bean的名称
     * @since 2.5
     */
    void registerDependentBean(String beanName, String dependentBeanName);

    /**
     * 返回所有依赖于指定bean的bean的名称（如果有的话）。
     *
     * @param beanName bean的名称
     * @return 依赖bean名称的数组，如果没有则为空数组
     * @since 2.5
     */
    String[] getDependentBeans(String beanName);

    /**
     * 返回指定bean依赖的所有bean的名称（如果有的话）。
     *
     * @param beanName bean的名称
     * @return bean依赖的bean名称数组，如果没有则为空数组
     * @since 2.5
     */
    String[] getDependenciesForBean(String beanName);

    /**
     * 根据其bean定义销毁给定的bean实例（通常是从此工厂获得的原型实例）。
     * <p>销毁期间出现的任何异常都应捕获并记录，而不是传播到此方法的调用者。
     *
     * @param beanName bean定义的名称
     * @param beanInstance 要销毁的bean实例
     */
    void destroyBean(String beanName, Object beanInstance);

    /**
     * 在当前目标作用域中销毁指定的作用域bean，如果有的话。
     * <p>销毁期间出现的任何异常都应捕获并记录，而不是传播到此方法的调用者。
     *
     * @param beanName 作用域bean的名称
     */
    void destroyScopedBean(String beanName);

    /**
     * 销毁此工厂中的所有单例bean，包括已注册为可销毁的内部bean。在工厂关闭时调用。
     * <p>销毁期间出现的任何异常都应捕获并记录，而不是传播到此方法的调用者。
     */
    void destroySingletons();
    
}

五、最佳实践

演示了ConfigurableBeanFactory接口的一些常用方法。包括设置父级BeanFactory、获取BeanPostProcessor数量、注册别名、处理依赖关系等。

public class ConfigurableBeanFactoryDemo {

    public static void main(String[] args) {
        // 创建 ApplicationContext
        ConfigurableBeanFactory configurableBeanFactory = new AnnotationConfigApplicationContext(MyConfiguration.class).getBeanFactory();

        // 设置父级 BeanFactory
        configurableBeanFactory.setParentBeanFactory(new DefaultListableBeanFactory());

        // 获取BeanPostProcessor数量
        int beanPostProcessorCount = configurableBeanFactory.getBeanPostProcessorCount();
        System.out.println("获取BeanPostProcessor数量: " + beanPostProcessorCount);

        // 获取所有已注册的 Scope 名称
        String[] scopeNames = configurableBeanFactory.getRegisteredScopeNames();
        System.out.println("获取所有已注册的Scope名称: " + String.join(", ", scopeNames));

        // 获取注册的 Scope
        Scope customScope = configurableBeanFactory.getRegisteredScope("customScope");
        System.out.println("获取注册的Scope :" + customScope);

        // 获取ApplicationStartup
        ApplicationStartup applicationStartup = configurableBeanFactory.getApplicationStartup();
        System.out.println("获取ApplicationStartup: " + applicationStartup);

        // 获取AccessControlContext
        AccessControlContext accessControlContext = configurableBeanFactory.getAccessControlContext();
        System.out.println("获取AccessControlContext: " + accessControlContext);

        // 拷贝配置
        ConfigurableListableBeanFactory otherFactory = new DefaultListableBeanFactory();
        configurableBeanFactory.copyConfigurationFrom(otherFactory);
        System.out.println("拷贝配置copyConfigurationFrom: " + otherFactory);

        // 注册别名
        String beanName = "myService";
        String alias = "helloService";
        configurableBeanFactory.registerAlias(beanName, alias);
        System.out.println("注册别名registerAlias, BeanName: " + beanName + "alias: " + alias);

        // 获取合并后的 BeanDefinition
        BeanDefinition mergedBeanDefinition = configurableBeanFactory.getMergedBeanDefinition("myService");
        System.out.println("获取合并后的 BeanDefinition: " + mergedBeanDefinition);

        // 判断是否为 FactoryBean
        String factoryBeanName = "myService";
        boolean isFactoryBean = configurableBeanFactory.isFactoryBean(factoryBeanName);
        System.out.println("判断是否为FactoryBean" + isFactoryBean);

        // 设置当前 Bean 是否正在创建
        String currentBeanName = "myService";
        boolean inCreation = true;
        configurableBeanFactory.setCurrentlyInCreation(currentBeanName, inCreation);
        System.out.println("设置当前Bean是否正在创建: " + currentBeanName);

        // 判断指定的 Bean 是否正在创建
        boolean isCurrentlyInCreation = configurableBeanFactory.isCurrentlyInCreation(currentBeanName);
        System.out.println("判断指定的Bean是否正在创建" + isCurrentlyInCreation);

        // 注册依赖关系
        String dependentBeanName = "dependentBean";
        configurableBeanFactory.registerDependentBean(beanName, dependentBeanName);
        System.out.println("注册依赖关系" + "beanName: " + beanName + "dependentBeanName: " + dependentBeanName);

        // 获取所有依赖于指定 Bean 的 Bean 名称
        String[] dependentBeans = configurableBeanFactory.getDependentBeans(beanName);
        System.out.println("获取所有依赖于指定Bean的Bean名称: " + String.join(", ", dependentBeans));

        // 获取指定 Bean 依赖的所有 Bean 名称
        String[] dependencies = configurableBeanFactory.getDependenciesForBean(beanName);
        System.out.println("获取指定Bean依赖的所有Bean名称: " + String.join(", ", dependencies));

        // 销毁指定 Bean 实例
        Object beanInstance = configurableBeanFactory.getBean(beanName);
        configurableBeanFactory.destroyBean(beanName, beanInstance);
        System.out.println("销毁指定 Bean 实例: " + beanName);

        // 销毁所有单例 Bean
        configurableBeanFactory.destroySingletons();
        System.out.println("销毁所有单例Bean destroySingletons" );
    }
}

六、与其他组件的关系

1. BeanFactory

   • ConfigurableBeanFactory 继承自 BeanFactory 接口，因此它包含了 BeanFactory 的基本功能。它扩展了 BeanFactory 接口，提供了更多的配置和管理功能。

2. HierarchicalBeanFactory

   • ConfigurableBeanFactory 扩展了 HierarchicalBeanFactory 接口，因此它具有层次结构的特性。这允许配置一个父级 BeanFactory，从而实现层次化的容器结构。

3. SingletonBeanRegistry

   • ConfigurableBeanFactory 扩展了 SingletonBeanRegistry 接口，使其能够注册和管理单例对象。这包括对单例对象的创建、获取和销毁等操作。

4. BeanPostProcessor

   • ConfigurableBeanFactory 允许注册 BeanPostProcessor 实现，这些实现可以在容器中的 bean 实例创建和初始化阶段进行干预。通过 addBeanPostProcessor 方法，可以向容器注册自定义的 BeanPostProcessor 实现。

5. Scope

   • ConfigurableBeanFactory 定义了注册和获取作用域的方法。可以通过 registerScope 注册自定义作用域，并通过 getRegisteredScope 获取已注册的作用域。

6. ConversionService

   • ConfigurableBeanFactory 允许设置和获取 ConversionService，用于执行属性值的类型转换。通过 setConversionService 和 getConversionService 方法，可以配置和检索自定义的类型转换服务。

7. BeanExpressionResolver

   • ConfigurableBeanFactory 允许设置和获取 BeanExpressionResolver，用于解析 bean 定义中的表达式。通过 setBeanExpressionResolver 和 getBeanExpressionResolver 方法，可以配置和获取表达式解析器。

8. TypeConverter

   • ConfigurableBeanFactory 允许设置和获取 TypeConverter，用于执行 bean 属性值的类型转换。通过 setTypeConverter 和 getTypeConverter 方法，可以配置和获取类型转换器。

9. StringValueResolver

   • ConfigurableBeanFactory 允许添加和检查字符串值解析器，用于解析 bean 定义中的嵌入式值。通过 addEmbeddedValueResolver 和 hasEmbeddedValueResolver 方法，可以进行相应的操作。

10. PropertyEditorRegistrar

    • ConfigurableBeanFactory 允许添加 PropertyEditorRegistrar，用于注册自定义的 PropertyEditor。通过 addPropertyEditorRegistrar 方法，可以注册属性编辑器注册器。

11. ApplicationStartup

    • ConfigurableBeanFactory 允许设置和获取 ApplicationStartup，用于记录应用程序启动期间的度量。通过 setApplicationStartup 和 getApplicationStartup 方法，可以配置和获取启动度量实例。

12. AccessControlContext

    • ConfigurableBeanFactory 允许获取与该工厂相关的安全访问控制上下文。通过 getAccessControlContext 方法，可以获取安全访问控制上下文。

13. AliasRegistry

    • ConfigurableBeanFactory 继承了 AliasRegistry 接口，因此它也提供了对别名的注册和解析的功能。可以通过 registerAlias 和 resolveAliases 方法进行别名的注册和解析。

14. ConfigurableListableBeanFactory

    • ConfigurableBeanFactory 是 ConfigurableListableBeanFactory 的父接口。ConfigurableListableBeanFactory 除了提供配置和管理功能外，还允许对 bean 定义进行查询，包括合并的 bean 定义等。

七、常见问题

1. 什么是 ConfigurableBeanFactory 接口的作用？

   • ConfigurableBeanFactory 接口是 Spring 框架中 IoC 容器的配置接口之一。它扩展了 BeanFactory 接口，提供了一系列用于配置和管理 IoC 容器的方法，如设置父容器、注册作用域、添加 BeanPostProcessor 等。

2. ConfigurableBeanFactory 与 BeanFactory 有什么区别？

   • ConfigurableBeanFactory 继承自 BeanFactory 接口，相比于 BeanFactory，它提供了更多的配置和管理方法。通过 ConfigurableBeanFactory，可以设置父容器、注册作用域、添加 BeanPostProcessor 等，而 BeanFactory 只提供了基本的 bean 获取和类型检查的功能。

3. 如何设置 ConfigurableBeanFactory 的父容器？

   • 可以使用 setParentBeanFactory 方法来设置 ConfigurableBeanFactory 的父容器。通过这个方法，可以建立容器的层次结构，实现父子容器之间的资源共享和依赖管理。

4. ConfigurableBeanFactory 中的 Scope 是什么作用？

   • ConfigurableBeanFactory 中的 Scope 用于定义和管理 bean 的作用域。作用域决定了 bean 的生命周期和可见范围，例如 singleton 作用域表示一个 bean 在容器中是单例的，而 prototype 作用域表示每次获取 bean 都会创建一个新实例。

5. 如何注册自定义的 Scope？

   • 可以使用 registerScope 方法来注册自定义的作用域。通过该方法，可以添加自定义作用域的实现，并在容器中使用该作用域。

6. ConfigurableBeanFactory 中的 BeanPostProcessor 有什么作用？

   • BeanPostProcessor 在 bean 的创建和初始化阶段起作用，允许我们对 bean 进行定制和干预。通过 addBeanPostProcessor 方法，可以注册自定义的 BeanPostProcessor 实现。

7. 如何设置 ConfigurableBeanFactory 的 ClassLoader？

   • 可以使用 setBeanClassLoader 方法来设置 ConfigurableBeanFactory 的 ClassLoader。这个 ClassLoader 用于加载 bean 的类，可以指定一个特定的 ClassLoader，也可以使用默认的线程上下文 ClassLoader。

8. ConfigurableBeanFactory 中的 ConversionService 有什么作用？

   • ConversionService 用于执行 bean 属性值的类型转换。通过 setConversionService 方法，可以设置自定义的类型转换服务，用于处理 bean 属性值的类型转换。

9. 如何配置 ConfigurableBeanFactory 中的 BeanExpressionResolver？

   • 可以使用 setBeanExpressionResolver 方法来配置 ConfigurableBeanFactory 中的 BeanExpressionResolver。这个解析器用于解析 bean 定义中的表达式，例如 Spring EL 表达式。

10. ConfigurableBeanFactory 中的 TypeConverter 有什么作用？

    • TypeConverter 用于执行 bean 属性值的类型转换。通过 setTypeConverter 方法，可以设置自定义的类型转换器，用于处理 bean 属性值的类型转换。

11. 如何注册 ConfigurableBeanFactory 的 PropertyEditorRegistrar？

    • 可以使用 addPropertyEditorRegistrar 方法来注册 ConfigurableBeanFactory 的 PropertyEditorRegistrar。这个注册器用于注册自定义的 PropertyEditor，处理属性编辑器的创建和注册。

12. ConfigurableBeanFactory 中的 ApplicationStartup 有什么作用？

    • ApplicationStartup 用于记录应用程序启动期间的度量。通过 setApplicationStartup 方法，可以设置自定义的 ApplicationStartup 实例，用于记录启动度量。

13. ConfigurableBeanFactory 中的 destroySingletons 方法有什么作用？

    • destroySingletons 方法用于销毁所有单例 bean，包括内部注册为可销毁的 bean。这个方法通常在容器关闭时调用，用于释放资源和执行清理操作。