自学内容网 自学内容网

请你谈谈:spring bean的生命周期 - 阶段2:Bean实例化阶段

在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,为开发者提供了在容器启动过程中定制和修改容器内部结构的机会。

BeanDefinitionRegistryBeanFactory 的一个子接口,提供了动态注册 BeanDefinition 的能力。结合使用 BeanFactoryPostProcessorBeanDefinitionRegistry,你可以动态地添加、修改或删除 Bean 定义。

下面是一个使用 BeanFactoryPostProcessorBeanDefinitionRegistry 来替换或增强 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 容器中使用 BeanFactoryPostProcessorBeanDefinitionRegistry 来动态地修改或增强 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容器的内部机制非常有帮助。


原文地址:https://blog.csdn.net/zs18753479279/article/details/140504570

免责声明:本站文章内容转载自网络资源,如本站内容侵犯了原著者的合法权益,可联系本站删除。更多内容请关注自学内容网(zxcms.com)!