源码动态 源码评测 源码技巧 网站运营 网页制作 网站开发 安全相关 软件教程 IDC资讯 业界消息
高级搜索
关键字:Discuz!  Axure  团购系统
最新更新发布资源提建议收藏本站
当前位置:A5下载 > 资讯报道 > 编程开发 > 网站开发 > Spring与bean有关的生命周期示例详解

Spring与bean有关的生命周期示例详解

作者:小静来源:脚本之家浏览:时间:2020-07-27 10:20我要评论
这篇文章主要给大家介绍了关于Spring与bean有关的生命周期的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者使用Spring具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧

前言

记得以前的时候,每次提起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方法

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

代码实例

 

/**
* @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方法才会被调用。
 

相关文章
评论暂时关闭
资讯分类
本类热门资讯
  • 源码推荐
  • 软件推荐
关于我们联系我们发布资源广告服务合作伙伴网站地图版权声明与我们对话