本文主要讲解 Bean的生命周期后置处理器,关于bean创建对象流程我们后面在讲。主要说明三种生命周期增强器:
-
BeanFactoryPostProcessor
:BeanFactory 后置处理器- BeanDefinitionRegistryPostProcessor:bean定义注册后置处理器
- BeanFactoryPostProcessor
-
BeanPostProcessor:Bean后置处理器
- BeanPostProcessor
- MergedBeanDefinitionPostProcessor
- SmartInstantiationAwareBeanPostProcessor
- InstantiationAwareBeanPostProcessor
-
InitializingBean
-
DisposableBean (销毁的方案我们暂时不做说明)
1. 简介
1.1 什么是 BeanPostProcessor
BeanPostProcessor 是 Spring提供给我们的一个非常重要的扩展接口
,并且Spring内部的很多功能也是通过 BeanPostProcessor 来完成的(目前看到最典型的就是 AnnotationAwareAspectJAutoProxyCreator 的 注入)。
1.2 BeanPostProcessor 的种类
BeanPostProcessor 在Spring 中的子类非常多(idea 显是有46个),比如
InstantiationAwareBeanPostProcessorAdapter
: 在Spring 的bean加载过程中起了非常重要的作用AnnotationAwareAspectJAutoProxyCreator
: bean 创建过程中的 属性注入时起作用AspectJAwareAdvisorAutoProxyCreator
: Aspect 的 AOP 功能实现也全仰仗BeanPostProcessor 的特性。
1.3 创建时机
BeanFactoryPostProcessor
:在 Spring 启动时对BeanDefinition 的创建 进行干预处理。
BeanPostProcessor
:一是Bean对应的BeanDefinition 的创建。二是Bean 实例的创建。因为在 Spring容器中,Bean的创建并非仅仅通过反射创建就结束了,在创建过程中,需要考虑到Bean针对Spring容器中的一些属性,所以BeanDefinition 中不仅仅包含了 Bean Class 文件信息,还包含了 当前Bean在Spring容器中的一些属性,比如在容器中的作用域、是否懒加载、别名等信息。当Bean 进行实例化创建时需要依赖于对应的BeanDefinition 提供对应的信息。。
而由于 BeanPostProcessor 是参与了 Bean 创建过程。所以其创建一定在普通 Bean 之前。实际上 BeanPostProcessor 的创建时在 Spring 启动时容器刷新的时候。
BeanPostProcessor 的 BeanDefinition 创建时机和普通 Bean没有区别,都是在Spring 启动时的BeanFactoryPostProcessor 中完成(确切的说是 ConfigurationClassPostProcessor 中完成)。
而BeanPostProcessor 的实例创建要优先于普通bean创建,Spring启动过程中会调用AbstractApplicationContext#registerBeanPostProcessors
方法。 在这个方法中,Spring 会从容器中获取到所有BeanPostProcessor 类型的beanName, 通过 beanFactory.getBean 方法获取到对应实例,进行排序后注册到 BeanFactory.beanPostProcessors 属性中.当容器需要执行 BeanPostProcessor 方法时可以直接从 beanPostProcessors 中获取即可。
2. 案例
分别定义几个测试类,实现bean的后置处理器:
BeanDefinitionRegistryPostProcessor:
/**
* BeanFactory的后置处理器 , PriorityOrdered, Ordered
*/
@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
public MyBeanDefinitionRegistryPostProcessor(){
System.out.println("MyBeanDefinitionRegistryPostProcessor");
}
@Override //紧接着执行
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("MyBeanDefinitionRegistryPostProcessor....postProcessBeanFactory...");
}
@Override //先执行的
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
System.out.println("MyBeanDefinitionRegistryPostProcessor...postProcessBeanDefinitionRegistry...");
//增强bean定义信息的注册中心,比如自己注册组件
}
}
BeanFactoryPostProcessor:
/**
* BeanFactory的后置处理器
*/
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
public MyBeanFactoryPostProcessor(){
System.out.println("MyBeanFactoryPostProcessor...");
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("BeanFactoryPostProcessor....postProcessBeanFactory==>"+beanFactory);
}
}
BeanPostProcessor:
/**
* Bean组件的 PostProcessor;
*/
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
public MyBeanPostProcessor(){
System.out.println("MyBeanPostProcessor...");
}
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("MyBeanPostProcessor...postProcessAfterInitialization..."+bean+"==>"+beanName);
return bean;
}
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("MyBeanPostProcessor...postProcessBeforeInitialization..."+bean+"==>"+beanName);
return bean; // new Object();
}
}
InstantiationAwareBeanPostProcessor:
@Component
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
public MyInstantiationAwareBeanPostProcessor(){
System.out.println("MyInstantiationAwareBeanPostProcessor...");
}
//初始化之前进行后置处理,Spring留给我们给这个组件创建对象的回调。
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessBeforeInstantiation=>"+beanClass+"--"+beanName);
//if(class.isAssFrom(Cat.class)){return new Dog()}
//如果我们自己创建了对象返回。Spring则不会帮我们创建对象,用我们自己创建的对象? 我们创建的这个对象,Spring会保存单实例?还是每次getBean都调到我们这里创建一个新的?
return null;
}
// 是否让剩下的后置处理器对bean继续进行处理
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
//提前改变一些Spring不管的bean里面的属性
System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessAfterInstantiation=>"+bean+"--"+beanName);
return true; //返回false则bean的赋值全部结束
}
//解析自定义注解进行属性值注入;pvs 封装了所有的属性信息。
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
throws BeansException { //@GuiguValue();redis
System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessProperties=>"+bean+"--"+beanName);
return null;
}
// public PropertyValues postProcessPropertyValues(
// PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
// System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessProperties");
// return pvs;
// }
}
MergedBeanDefinitionPostProcessor:
@Component
public class MyMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {
public MyMergedBeanDefinitionPostProcessor(){
System.out.println("MyMergedBeanDefinitionPostProcessor...");
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("MyMergedBeanDefinitionPostProcessor...postProcessBeforeInitialization...=>"+bean+"--"+beanName);
return bean; //null
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("MyMergedBeanDefinitionPostProcessor...postProcessAfterInitialization..=>"+bean+"--"+beanName);
return null;
}
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
System.out.println("MyMergedBeanDefinitionPostProcessor...postProcessMergedBeanDefinition..=>"+beanName+"--"+beanType+"---"+beanDefinition);
}
@Override
public void resetBeanDefinition(String beanName) {
System.out.println("MyMergedBeanDefinitionPostProcessor...resetBeanDefinition.."+beanName);
}
}
SmartInstantiationAwareBeanPostProcessor:
@Component //bean进行代理增强期间进行使用
public class MySmartInstantiationAwareBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {
public MySmartInstantiationAwareBeanPostProcessor(){
System.out.println("MySmartInstantiationAwareBeanPostProcessor...");
}
//预测bean的类型,最后一次改变组件类型。
public Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
System.out.println("MySmartInstantiationAwareBeanPostProcessor...predictBeanType=>"+beanClass+"--"+beanName);
return null;
}
//返回我们要使用的构造器候选列表
public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
System.out.println("MySmartInstantiationAwareBeanPostProcessor...determineCandidateConstructors=>"+beanClass+"--"+beanName);
//返回一个我们指定的构造器
return null;
}
//返回早期的bean引用,定义三级缓存中的bean信息
public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
System.out.println("MySmartInstantiationAwareBeanPostProcessor...getEarlyBeanReference=>"+bean+"--"+beanName);
return bean; //
}
}
InitializingBean:
@Component
public class CatInitializingBean implements InitializingBean {
public CatInitializingBean(){
System.out.println("cat被创建了...");
}
private String name;
@Value("${JAVA_HOME}") //自动赋值功能
public void setName(String name) {
System.out.println("cat....setName正在赋值调用....");
this.name = name;
}
//注解怎么定义这个是初始化方法?
public String getName() {
return name;
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("CatInitializingBean..afterPropertiesSet...");
}
@Autowired
private void init() {
System.out.println("CatInitializingBean init....");
}
}
debug打点:在每个构造器和方法上都打上 断点,主要看看每个方法的执行时机是什么时候?