spring-reading./spring-factory/spring-factory-configurable.../README.md

636 lines
29 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

## ConfigurableBeanFactory
- [ConfigurableBeanFactory](#configurablebeanfactory)
- [一、基本信息](#一基本信息)
- [二、基本描述](#二基本描述)
- [三、主要功能](#三主要功能)
- [四、接口源码](#四接口源码)
- [五、最佳实践](#五最佳实践)
- [六、与其他组件的关系](#六与其他组件的关系)
- [七、常见问题](#七常见问题)
### 一、基本信息
✒️ **作者** - Lex 📝 **博客** - [掘金](https://juejin.cn/user/4251135018533068/posts) 📚 **源码地址** - [github](https://github.com/xuchengsheng/spring-reading)
### 二、基本描述
`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表达式解析器、注册自定义属性编辑器和后处理器、配置作用域等功能。
```java
/**
* 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数量、注册别名、处理依赖关系等。
```java
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。这个方法通常在容器关闭时调用用于释放资源和执行清理操作。