搜索

Spring中与bean有关的生命周期

java1234

共 12526字，需浏览 26分钟

 ·

2020-07-28 17:26

点击上方蓝色字体，选择“标星公众号”

优质文章，第一时间送达


66套java从入门到精通实战课程分享

  作者 |  eaglelihh

来源 | cnblogs.com/eaglelihh/p/13383039.html


前言

记得以前的时候，每次提起Spring中的bean相关的生命周期时，内心都无比的恐惧，因为好像有很多，自己又理不清楚：什么beanFactory啊，aware接口啊，beanPostProcessor啊，afterPropertiesSet啊，initMethod啊等等。

今天终于理清这些关系了，并且又新增了对postConstruct和lifecycle的理解。

执行顺序


- 首先是 BeanFactoryPostProcessor，它是针对所有bean的definition的，只执行一次

下面是针对每个bean的初始
- 实现了一系列aware接口的，比如BeanNameAware，ApplicationContextAware，调用其set方法
- 执行BeanPostProcessor的postProcessBeforeInitialization方法
- 带有@PostConstruct注解的方法
- 实现InitializingBean接口的afterPropertiesSet方法
- 指定的initMethod方法
- 执行BeanPostProcessor的postProcessAfterInitialization方法
- 实现了SmartLifecycle接口的start方法(实现Lifecycle接口的不会自动调用，需要显式的调用start方法)

下面是针对每个bean的销毁
- 实现了SmartLifecycle接口的stop方法(实现Lifecycle接口的不会自动调用，需要显式的调用stop方法)
- 带有@PreDestroy注解的方法
- 实现DisposableBean接口的destroy方法
- 指定的destroyMethod方法

目前就想到这么多了，其他的麻烦在评论区留言呀~


代码实例

bean实体类


/**
 * @date: 2020-07-22
 * 
 * 一个简单的枚举类 
 */
public enum BeanType {
    NORMAL, LIFECYCLE, SMART_LIFECYCLE;
}

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
/**
 * @author: lihui
 * @date: 2020-07-22
 * 一个简单的bean
 */
@Slf4j
public class NormalBean implements BeanNameAware, ApplicationContextAware, InitializingBean, DisposableBean {
    private BeanType beanType;

    public NormalBean() {
        this(BeanType.NORMAL);
    }

    public NormalBean(BeanType beanType) {
        this.beanType = beanType;
    }

    @PostConstruct
    public void postConstruct() {
        log.info("{}, postConstruct", beanType);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        log.info("{}, afterPropertiesSet", beanType);
    }

    public void initMethod() {
        log.info("{}, initMethod", beanType);
    }

    @PreDestroy
    public void preDestroy() {
        log.info("{}, preDestroy", beanType);
    }

    @Override
    public void destroy() throws Exception {
        log.info("{}, destroy", beanType);
    }

    public void destroyMethod() {
        log.info("{}, destroyMethod", beanType);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        log.info("setApplicationContext, applicationContext : {}", applicationContext);
    }

    @Override
    public void setBeanName(String name) {
        log.info("setBeanName, bean name : {}", name);
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.Lifecycle;
/**
 * @author: lihui
 * @date: 2020-07-22
 * 实现了Lifecycle的一个bean
 */
@Slf4j
public class LifecycleBean extends NormalBean implements Lifecycle {
    private volatile boolean running = false;

    public LifecycleBean() {
        super(BeanType.LIFECYCLE);
    }

    @Override
    public void start() {
        log.info("start");
        running = true;
    }

    @Override
    public void stop() {
        log.info("stop");
        running = false;
    }

    @Override
    public boolean isRunning() {
        return running;
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.SmartLifecycle;
/**
 * @author: lihui
 * @date: 2020-07-22
 * 实现了SmartLifecycle的一个bean
 */
@Slf4j
public class SmartLifecycleBean extends NormalBean implements SmartLifecycle {
    private volatile boolean running = false;

    public SmartLifecycleBean() {
        super(BeanType.SMART_LIFECYCLE);
    }

    @Override
    public void start() {
        log.info("start");
        running = true;
    }

    @Override
    public void stop() {
        log.info("stop");
        running = false;
    }

    @Override
    public boolean isRunning() {
        return running;
    }
}


配置类


import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
/**
 * @author: lihui
 * @date: 2020-07-25
 */
@Slf4j
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        log.info("postProcessBeanFactory, beanFactory:{}", beanFactory);
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
/**
 * @author: lihui
 * @date: 2020-07-25
 */
@Slf4j
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        log.info("postProcessBeforeInitialization, bean:{}", beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        log.info("postProcessAfterInitialization, bean:{}", beanName);
        return bean;
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.SmartLifecycle;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * @author: lihui
 * @date: 2020-07-22
 */
@Configuration
@Slf4j
public class Config {

    @Bean(initMethod = "initMethod", destroyMethod = "destroyMethod")
    public NormalBean normalBean() {
        return new NormalBean();
    }

    @Bean(initMethod = "initMethod", destroyMethod = "destroyMethod")
    public LifecycleBean lifecycleBean() {
        return new LifecycleBean();
    }

    @Bean(initMethod = "initMethod", destroyMethod = "destroyMethod")
    public SmartLifecycle smartLifecycle() {
        return new SmartLifecycleBean();
    }

    @Bean
    public static MyBeanFactoryPostProcessor myBeanFactoryPostProcessor() {
        return new MyBeanFactoryPostProcessor();
    }

    @Bean
    public static MyBeanPostProcessor myBeanPostProcessor() {
        return new MyBeanPostProcessor();
    }
}


Main类


import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @author: lihui
 * @date: 2020-07-22
 */
@Slf4j
public class Main {
    public static void main(String[] args) throws InterruptedException {
        ConfigurableApplicationContext ctx = new AnnotationConfigApplicationContext(Config.class);
        ctx.registerShutdownHook();
        Thread.sleep(5000);
        log.info("line ----------------------------- line");
        ctx.start();
        ctx.stop();
        log.info("line ----------------------------- line");
    }
}


结果说明

结果正如前面所说的执行顺序一致，主要注意的就是Lifecycle接口和SmartLifecycle接口，只有实现了SmartLifecycle接口的bean在初始化时才会被自动调用，而实现了Lifecycle接口的除非显式调用start和stop方法才会被调用。


502   2020-07-26 23:43:41.808 [main] INFO  c.e.d.s.a.i.l.MyBeanFactoryPostProcessor - postProcessBeanFactory, beanFactory:org.springframework.beans.factory.support.DefaultListableBeanFactory@55ca8de8: defining beans [org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,org.springframework.context.event.internalEventListenerProcessor,org.springframework.context.event.internalEventListenerFactory,config,normalBean,lifecycleBean,smartLifecycle,myBeanFactoryPostProcessor,myBeanPostProcessor]; root of factory hierarchy
520   2020-07-26 23:43:41.826 [main] INFO  c.e.d.s.a.i.l.MyBeanPostProcessor - postProcessBeforeInitialization, bean:config
520   2020-07-26 23:43:41.826 [main] INFO  c.e.d.s.a.i.l.MyBeanPostProcessor - postProcessAfterInitialization, bean:config
536   2020-07-26 23:43:41.842 [main] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - setBeanName, bean name : normalBean
536   2020-07-26 23:43:41.842 [main] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - setApplicationContext, applicationContext : org.springframework.context.annotation.AnnotationConfigApplicationContext@7cd62f43, started on Sun Jul 26 23:43:41 CST 2020
536   2020-07-26 23:43:41.842 [main] INFO  c.e.d.s.a.i.l.MyBeanPostProcessor - postProcessBeforeInitialization, bean:normalBean
536   2020-07-26 23:43:41.842 [main] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - NORMAL, postConstruct
536   2020-07-26 23:43:41.842 [main] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - NORMAL, afterPropertiesSet
536   2020-07-26 23:43:41.842 [main] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - NORMAL, initMethod
537   2020-07-26 23:43:41.843 [main] INFO  c.e.d.s.a.i.l.MyBeanPostProcessor - postProcessAfterInitialization, bean:normalBean
538   2020-07-26 23:43:41.844 [main] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - setBeanName, bean name : lifecycleBean
538   2020-07-26 23:43:41.844 [main] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - setApplicationContext, applicationContext : org.springframework.context.annotation.AnnotationConfigApplicationContext@7cd62f43, started on Sun Jul 26 23:43:41 CST 2020
538   2020-07-26 23:43:41.844 [main] INFO  c.e.d.s.a.i.l.MyBeanPostProcessor - postProcessBeforeInitialization, bean:lifecycleBean
538   2020-07-26 23:43:41.844 [main] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - LIFECYCLE, postConstruct
540   2020-07-26 23:43:41.846 [main] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - LIFECYCLE, afterPropertiesSet
540   2020-07-26 23:43:41.846 [main] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - LIFECYCLE, initMethod
540   2020-07-26 23:43:41.846 [main] INFO  c.e.d.s.a.i.l.MyBeanPostProcessor - postProcessAfterInitialization, bean:lifecycleBean
541   2020-07-26 23:43:41.847 [main] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - setBeanName, bean name : smartLifecycle
541   2020-07-26 23:43:41.847 [main] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - setApplicationContext, applicationContext : org.springframework.context.annotation.AnnotationConfigApplicationContext@7cd62f43, started on Sun Jul 26 23:43:41 CST 2020
541   2020-07-26 23:43:41.847 [main] INFO  c.e.d.s.a.i.l.MyBeanPostProcessor - postProcessBeforeInitialization, bean:smartLifecycle
541   2020-07-26 23:43:41.847 [main] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - SMART_LIFECYCLE, postConstruct
541   2020-07-26 23:43:41.847 [main] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - SMART_LIFECYCLE, afterPropertiesSet
541   2020-07-26 23:43:41.847 [main] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - SMART_LIFECYCLE, initMethod
541   2020-07-26 23:43:41.847 [main] INFO  c.e.d.s.a.i.l.MyBeanPostProcessor - postProcessAfterInitialization, bean:smartLifecycle
550   2020-07-26 23:43:41.856 [main] INFO  c.e.d.s.a.i.l.SmartLifecycleBean - start
5562  2020-07-26 23:43:46.868 [main] INFO  c.e.d.s.a.ioc.lifecycle.Main - line ----------------------------- line
5563  2020-07-26 23:43:46.869 [main] INFO  c.e.d.s.a.i.lifecycle.LifecycleBean - start
5566  2020-07-26 23:43:46.872 [main] INFO  c.e.d.s.a.i.l.SmartLifecycleBean - stop
5566  2020-07-26 23:43:46.872 [main] INFO  c.e.d.s.a.i.lifecycle.LifecycleBean - stop
5566  2020-07-26 23:43:46.872 [main] INFO  c.e.d.s.a.ioc.lifecycle.Main - line ----------------------------- line
5576  2020-07-26 23:43:46.882 [SpringContextShutdownHook] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - SMART_LIFECYCLE, preDestroy
5576  2020-07-26 23:43:46.882 [SpringContextShutdownHook] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - SMART_LIFECYCLE, destroy
5576  2020-07-26 23:43:46.882 [SpringContextShutdownHook] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - SMART_LIFECYCLE, destroyMethod
5576  2020-07-26 23:43:46.882 [SpringContextShutdownHook] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - LIFECYCLE, preDestroy
5576  2020-07-26 23:43:46.882 [SpringContextShutdownHook] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - LIFECYCLE, destroy
5577  2020-07-26 23:43:46.883 [SpringContextShutdownHook] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - LIFECYCLE, destroyMethod
5577  2020-07-26 23:43:46.883 [SpringContextShutdownHook] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - NORMAL, preDestroy
5577  2020-07-26 23:43:46.883 [SpringContextShutdownHook] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - NORMAL, destroy
5577  2020-07-26 23:43:46.883 [SpringContextShutdownHook] INFO  c.e.d.s.a.ioc.lifecycle.NormalBean - NORMAL, destroyMethod



     




感谢点赞支持下哈 


浏览 22
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报
评论
图片
表情
推荐
Spring Bean生命周期
Java资料站
0
详解Spring中Bean的作用域与生命周期
                   摘要：在利用Spring进行IOC配置时，关于bean的配置和使用一直都是比较重要的一部分，同时如何合理的使用和创建bean对象，也是小伙伴们在学习和使用Spring时需要注意的部分，所以这一篇文章我就来...
一文读懂 Spring Bean 的生命周期
老周聊架构
0
Spring的Bean生命周期和扩展点
一品江南
0
请别再问Spring Bean的生命周期了
Java技术迷
0
你能说说Spring框架中Bean的生命周期吗？
三太子敖丙
0
面试官：你能说说Spring框架中Bean的生命周期吗？
我是程序汪
0
【02期】你能说说Spring框架中Bean的生命周期吗？
程序员的成长之路
0
面试官：兄弟你来阐述一下Spring框架中Bean的生命周期？
Stephen
0
你知道Spring是怎么将AOP应用到Bean的生命周期中的吗?
程序员书单
0
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报