请你谈谈:spring bean的生命周期 - 阶段2:Bean实例化阶段
在Spring框架中,Bean的实例化是Bean生命周期中的一个重要阶段。这个过程包括两个关键的子阶段:Bean实例化前阶段和Bean实例化阶段本身。BeanFactoryPostProcessor:BeanFactoryPostProcessor是容器启动阶段Spring提供的一个扩展点,主要负责对注册到BeanDefinationRegistry中的一个个的BeanDefination进行一定
在Spring框架中,Bean的实例化是Bean生命周期中的一个重要阶段。这个过程包括两个关键的子阶段:Bean实例化前阶段和Bean实例化阶段本身。
BeanFactoryPostProcessor:BeanFactoryPostProcessor是容器启动阶段Spring提供的一个扩展点,主要负责对注册到BeanDefinationRegistry中的一个个的BeanDefination进行一定程度上的修改与替换。例如使用占位符配置元信息,例如配置Jdbc的DataSource连接的时候可以这样配置:
<property name="driverClassName"
value="${jdbc.driverClassName}">
</property>
BeanFactoryPostProcessor就会对注册到BeanDefinationRegistry中的BeanDefination做最后的修改,替换$占位符为配置文件中的真实的数据。至此,整个容器启动阶段就算完成了,容器的启动阶段的最终产物就是注册到BeanDefinationRegistry中的一个个BeanDefination了,这就是Spring为Bean实例化所做的预热的工作:
BeanFactoryPostProcessor
是 Spring 框架中的一个高级接口,允许在 Spring IoC 容器完全初始化之前(准确点说应该是:实例化之前),对 BeanFactory 中的 Bean 定义(BeanDefinition)进行修改。当 Spring 容器启动时,它会检测并调用所有实现了 BeanFactoryPostProcessor
接口的 bean,为开发者提供了在容器启动过程中定制和修改容器内部结构的机会。
BeanDefinitionRegistry
是 BeanFactory
的一个子接口,提供了动态注册 BeanDefinition 的能力。结合使用 BeanFactoryPostProcessor
和 BeanDefinitionRegistry
,你可以动态地添加、修改或删除 Bean 定义。
下面是一个使用 BeanFactoryPostProcessor
和 BeanDefinitionRegistry
来替换或增强 Bean 定义的例子:
public interface UserService {
void performAction();
}
public class OriginalUserService implements UserService {
@Override
public void performAction() {
System.out.println("Original UserService performing action.");
}
}
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.annotation.Configuration;
public class CustomBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 替换 OriginalUserService Bean
BeanDefinition originalUserServiceDef = registry.getBeanDefinition("originalUserService");
if (originalUserServiceDef != null) {
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(EnhancedUserService.class);
builder.addConstructorArgReference("originalUserService"); // 注入原始的 UserService Bean
AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
registry.registerBeanDefinition("enhancedUserService", beanDefinition);
}
}
// 模拟增强的 UserService 实现
static class EnhancedUserService implements UserService {
private final OriginalUserService originalUserService;
public EnhancedUserService(OriginalUserService originalUserService) {
this.originalUserService = originalUserService;
}
@Override
public void performAction() {
System.out.println("Before enhanced action...");
originalUserService.performAction();
System.out.println("After enhanced action...");
}
}
}
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean
public UserService originalUserService() {
return new OriginalUserService();
}
@Bean
public CustomBeanFactoryPostProcessor userServiceBeanFactoryPostProcessor() {
return new CustomBeanFactoryPostProcessor();
}
}
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.ApplicationContext;
public class Main {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService originalUserService = context.getBean("enhancedUserService", UserService.class);
originalUserService.performAction();
}
}
输出如下所示:
Before enhanced action...
Original UserService performing action.
After enhanced action...
通过上述步骤,我们展示了如何在 Spring 容器中使用 BeanFactoryPostProcessor
和 BeanDefinitionRegistry
来动态地修改或增强 Bean 定义。这种方法特别适用于在不修改原始类代码的情况下,对应用进行扩展或修改。然而,在实际应用中,应谨慎使用这种方法,因为它可能会使应用的配置和依赖关系变得复杂和难以管理。
接下来解释加载方式的知识点:
选择懒加载的方式,那么直到我们伸手向Spring要依赖对象实例之前,其都是以BeanDefinationRegistry中的一个个的BeanDefination的形式存在,也就是Spring只有在我们需要依赖对象的时候才开启相应对象的实例化阶段;
而如果我们不是选择懒加载的方式,容器启动阶段完成之后,将立即启动Bean实例化阶段,通过隐式的调用所有依赖对象的getBean方法来实例化所有配置的Bean并保存起来。
1、对象创建策略:对象的创建采用了策略模式,BeanDefinationRegistry中的BeanDefination,我们可以使用反射的方式创建对象,也可以使用CGlib字节码生成创建对象。
2、BeanWrapper:由于Spring IOC容器为了统一对不同类型对象的访问,Spring给所有创建的Bean实例穿上了一层外套BeanWrapper。BeanWrapper实际上是对反射相关API的简单封装,我们要获取某个对象的属性、调用某个对象的方法,现在不需要在写繁杂的反射API了以及处理一堆麻烦的异常,直接通过BeanWrapper就可以完成相关操作。
在Spring框架中,BeanWrapper
是一个非常重要的接口,它提供了对JavaBean属性的访问和修改的能力,同时也支持对JavaBean方法的调用。BeanWrapper
是Spring IoC容器内部使用的核心组件之一,用于在Bean的实例化过程中设置Bean的属性值。以下是在Spring中BeanWrapper
的用法:
1. 封装Bean实例
BeanWrapper
是对JavaBean实例的封装,它允许Spring IoC容器以统一的方式访问和修改Bean的属性。当Spring IoC容器创建了一个Bean的实例后,它会使用BeanWrapper
来封装这个实例,并通过BeanWrapper
来设置Bean的属性值。
2. 访问和修改Bean属性
BeanWrapper
提供了丰富的API来访问和修改Bean的属性。例如,可以使用getPropertyValue(String propertyName)
方法来获取Bean的某个属性值,使用setPropertyValue(String propertyName, Object value)
方法来设置Bean的某个属性值。此外,BeanWrapper
还支持嵌套属性的访问和修改,例如可以通过"address.city"
这样的属性名来访问和修改嵌套在address
属性中的city
属性。
3. 类型转换
在设置Bean属性值时,BeanWrapper
会考虑属性值的类型转换。如果属性值的类型与Bean属性所需的类型不匹配,BeanWrapper
会尝试使用注册在PropertyEditorRegistry
中的属性编辑器(PropertyEditor
)或ConversionService
来进行类型转换。这使得开发者可以灵活地处理类型转换问题,而无需编写额外的代码。
4. 与Spring IoC容器的集成
BeanWrapper
是Spring IoC容器内部使用的核心组件之一,它与Spring IoC容器的其他组件紧密集成。在Bean的实例化过程中,Spring IoC容器会创建BeanWrapper
实例来封装Bean的实例,并通过BeanWrapper
来设置Bean的属性值。此外,Spring IoC容器还利用BeanWrapper
来支持依赖注入、AOP等功能。
5. 示例用法
虽然用户很少需要直接使用BeanWrapper
进行编程,但了解其用法对于深入理解Spring IoC容器的内部机制非常有帮助。以下是一个简化的示例,展示了如何在Spring IoC容器外部使用BeanWrapper
:
package com.springIoc.BeanDefinitionDemo;
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
public class SpringBeanWrapperExample {
public static void main(String[] args) {
// 创建一个JavaBean实例
Person person = new Person();
// 创建BeanWrapperImpl实例来包装Person对象
BeanWrapper personWrapper = new BeanWrapperImpl(person);
// 使用BeanWrapper设置属性值
personWrapper.setPropertyValue("name", "John Doe");
personWrapper.setPropertyValue("age", 30);
// 获取BeanWrapper封装的Bean实例并调用其方法(如果需要的话)
Person modifiedPerson = (Person) personWrapper.getWrappedInstance();
modifiedPerson.greet(); // 假设Person类有一个greet()方法
}
// 假设的Person类,与前面的示例相同
// ...
}
class Person {
private String name;
private Integer age;
public Person() {
}
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public void greet() {
System.out.println("name = " + name);
System.out.println("age = " + age);
}
}
需要注意的是,上述示例仅用于演示BeanWrapper
的用法,而在实际开发中,BeanWrapper
的使用通常是由Spring IoC容器自动完成的,用户无需手动创建和使用BeanWrapper
实例。
结论
BeanWrapper
是Spring框架中一个非常重要的接口,它提供了对JavaBean属性的访问和修改的能力,同时也支持类型转换和与Spring IoC容器的集成。虽然用户很少需要直接使用BeanWrapper
进行编程,但了解其用法对于深入理解Spring IoC容器的内部机制非常有帮助。
更多推荐
所有评论(0)