spring中bean的生命周期

目录结构

我们构建一个bean并且运行程序简单查看

@Component
public class LifeCycleBean {
    public LifeCycleBean(){
        System.out.println("构造方法");
    }
    @Autowired
    public void autowire(){
        System.out.println("依赖注入");
    }
    @PostConstruct
    public void init(){
        System.out.println("初始化");
    }
    @PreDestroy
    public void destroy(){
        System.out.println("销毁");
    }
}

为了展现出销毁效果，我们在启动类加上close方法

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);
        context.close();
    }
}

最后控制台打印顺序是

构造方法

依赖注入
初始化

销毁

 生命周期效果已经出来，但是spring作为一个框架，需要具备很强的扩展性，所以他理所应当的拥有很多bean的后处理器去处理，去扩展。

Bean的后置处理器

目录结构

 MyBeanPostProcessor，为了方便起见，我们只看beanName为lifeCycleBean的输出

@Component
public class MyBeanPostProcessor implements InstantiationAwareBeanPostProcessor, DestructionAwareBeanPostProcessor {
    @Override
    public void postProcessBeforeDestruction(Object o, String s) throws BeansException {
        if (s.equals("lifeCycleBean")){
            System.out.println("销毁之前执行，如@PreDestroy");
        }
    }

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean")){
            System.out.println("实例化之前执行，返回的对象会替换掉原本的bean");
        }
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean")){
            System.out.println("实例化之后执行，返回false则会跳过依赖注入阶段");
        }
        return true;
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean")){
            System.out.println("依赖注入阶段，如@Autowired等");
        }
        return pvs;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean")){
            System.out.println("初始化之前执行，返回的对象会替换原本的bean。如@PostConstruct");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean")){
            System.out.println("初始化之后执行，返回的对象会替换原本的bean。如动态代理");
        }
        return bean;
    }
}

 最后输出

实例化之前执行，返回的对象会替换掉原本的bean

构造方法

实例化之后执行，返回false则会跳过依赖注入阶段

依赖注入阶段，如@Autowired等

依赖注入

初始化之前执行，返回的对象会替换原本的bean。如@PostConstruct

初始化

初始化之后执行，返回的对象会替换原本的bean。如动态代理

销毁之前执行，如@PreDestroy

销毁

 后置处理，这里不得不说一下模板方法在这里的应用，使得程序更易扩展。

CSDNhttps://mp.csdn.net/mp_blog/creation/editor/124845064常用的后置处理器

AutowiredAnnotationBeanPostProcessor：处理@Autowired和@Value

CommonAnnotationBeanPostProcessor：处理@Resource、@PostConstruct、@PreDestroy

还有springboot中的ConfigurationPropertiesBindingPostProcessor处理@ConfigurationProperties

处理器有个order属性是管理优先级的。@Resource比@Autowired优先级高。