快捷導航

Spring與bean有關(guān)的生命周期示例詳解

更新時間：2020年07月27日 08:35:17 作者：eaglelihh

這篇文章主要給大家介紹了關(guān)于Spring與bean有關(guān)的生命周期的相關(guān)資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者使用Spring具有一定的參考學習價值，需要的朋友們下面來一起學習學習吧

前言

記得以前的時候，每次提起Spring中的bean相關(guān)的生命周期時，內(nèi)心都無比的恐懼，因為好像有很多，自己又理不清楚：什么beanFactory啊，aware接口啊，beanPostProcessor啊，afterPropertiesSet啊，initMethod啊等等。

今天終于理清這些關(guān)系了，并且又新增了對postConstruct和lifecycle的理解。

執(zhí)行順序

- 首先是 BeanFactoryPostProcessor，它是針對所有bean的definition的，只執(zhí)行一次

下面是針對每個bean的初始

- 實現(xiàn)了一系列aware接口的，比如BeanNameAware，ApplicationContextAware，調(diào)用其set方法
- 執(zhí)行BeanPostProcessor的postProcessBeforeInitialization方法
- 帶有@PostConstruct注解的方法
- 實現(xiàn)InitializingBean接口的afterPropertiesSet方法
- 指定的initMethod方法
- 執(zhí)行BeanPostProcessor的postProcessAfterInitialization方法
- 實現(xiàn)了SmartLifecycle接口的start方法(實現(xiàn)Lifecycle接口的不會自動調(diào)用，需要顯式的調(diào)用start方法)

下面是針對每個bean的銷毀

- 實現(xiàn)了SmartLifecycle接口的stop方法(實現(xiàn)Lifecycle接口的不會自動調(diào)用，需要顯式的調(diào)用stop方法)
- 帶有@PreDestroy注解的方法
- 實現(xiàn)DisposableBean接口的destroy方法
- 指定的destroyMethod方法

目前就想到這么多了，其他的麻煩在評論區(qū)留言呀~

代碼實例

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
 * 實現(xiàn)了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
 * 實現(xiàn)了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");
  }
}

結(jié)果說明

結(jié)果正如前面所說的執(zhí)行順序一致，主要注意的就是Lifecycle接口和SmartLifecycle接口，只有實現(xiàn)了SmartLifecycle接口的bean在初始化時才會被自動調(diào)用，而實現(xiàn)了Lifecycle接口的除非顯式調(diào)用start和stop方法才會被調(diào)用。

總結(jié)

到此這篇關(guān)于Spring與bean有關(guān)的生命周期的文章就介紹到這了,更多相關(guān)Spring與bean生命周期內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: