Spring Bean初始化及销毁多种实现方式

2023-08-05 09:14:04 81

这篇文章主要介绍了SpringBean初始化及销毁多种实现方式,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

一、前言

日常开发过程有时需要在应用启动之后加载某些资源，或者在应用关闭之前释放资源。Spring框架提供相关功能，围绕SpringBean生命周期，可以在Bean创建过程初始化资源，以及销毁Bean过程释放资源。Spring提供多种不同的方式初始化/销毁Bean，如果同时使用这几种方式，Spring如何处理这几者之间的顺序？

二、姿势剖析

首先我们先来回顾一下Spring初始化/销毁Bean几种方式，分别为：

init-method/destroy-method
InitializingBean/DisposableBean
@PostConstruct/@PreDestroy
ContextStartedEvent/ContextClosedEvent

PS:其实还有一种方式，就是继承SpringLifecycle接口。不过这种方式比较繁琐，这里就不再分析。

2.1、init-method/destroy-method

这种方式在配置文件文件指定初始化/销毁方法。XML配置如下

或者也可以使用注解方式配置：

@Configurable
publicclassAppConfig{

@Bean(initMethod="init",destroyMethod="destroy")
publicHelloServicehello(){
returnnewHelloService();
}
}

还记得刚开始接触学习Spring框架，使用就是这种方式。

2.2、InitializingBean/DisposableBean

这种方式需要继承Spring接口InitializingBean/DisposableBean，其中InitializingBean用于初始化动作，而DisposableBean用于销毁之前清理动作。使用方式如下：

@Service
publicclassHelloServiceimplementsInitializingBean,DisposableBean{

@Override
publicvoiddestroy()throwsException{
System.out.println("hellodestroy...");
}

@Override
publicvoidafterPropertiesSet()throwsException{
System.out.println("helloinit....");
}
}

2.3、@PostConstruct/@PreDestroy

这种方式相对于上面两种方式来说，使用方式最简单，只需要在相应的方法上使用注解即可。使用方式如下：

@Service
publicclassHelloService{
@PostConstruct
publicvoidinit(){
System.out.println("hello@PostConstruct");
}

@PreDestroy
publicvoidPreDestroy(){
System.out.println("hello@PreDestroy");
}
}

这里踩过一个坑，如果使用JDK9之后版本，@PostConstruct/@PreDestroy需要使用maven单独引入javax.annotation-api，否者注解不会生效。

2.4、ContextStartedEvent/ContextClosedEvent

这种方式使用Spring事件机制，日常业务开发比较少见，常用与框架集成中。Spring启动之后将会发送ContextStartedEvent事件，而关闭之前将会发送ContextClosedEvent事件。我们需要继承SpringApplicationListener才能监听以上两种事件。

@Service
publicclassHelloListenerimplementsApplicationListener{

@Override
publicvoidonApplicationEvent(ApplicationEventevent){
if(eventinstanceofContextClosedEvent){
System.out.println("helloContextClosedEvent");
}elseif(eventinstanceofContextStartedEvent){
System.out.println("helloContextStartedEvent");
}

}
}

也可以使用@EventListener注解，使用方式如下：

publicclassHelloListenerV2{

@EventListener(value={ContextClosedEvent.class,ContextStartedEvent.class})
publicvoidreceiveEvents(ApplicationEventevent){
if(eventinstanceofContextClosedEvent){
System.out.println("helloContextClosedEvent");
}elseif(eventinstanceofContextStartedEvent){
System.out.println("helloContextStartedEvent");
}
}
}

PS:只有调用ApplicationContext#start才会发送ContextStartedEvent。若不想这么麻烦，可以监听ContextRefreshedEvent事件代替。一旦Spring容器初始化完成，就会发送ContextRefreshedEvent。

三、综合使用

回顾完上面几种方式，这里我们综合使用上面的四种方式，来看下Spring内部的处理顺序。在看结果之前，各位读者大人可以猜测下这几种方式的执行顺序。

publicclassHelloServiceimplementsInitializingBean,DisposableBean{


@PostConstruct
publicvoidinit(){
System.out.println("hello@PostConstruct");
}

@PreDestroy
publicvoidPreDestroy(){
System.out.println("hello@PreDestroy");
}

@Override
publicvoiddestroy()throwsException{
System.out.println("byeDisposableBean...");
}

@Override
publicvoidafterPropertiesSet()throwsException{
System.out.println("helloInitializingBean....");
}

publicvoidxmlinit(){
System.out.println("helloxml-init...");
}

publicvoidxmlDestory(){
System.out.println("byexmlDestory...");
}

@EventListener(value={ContextClosedEvent.class,ContextStartedEvent.class})
publicvoidreceiveEvents(ApplicationEventevent){
if(eventinstanceofContextClosedEvent){
System.out.println("byeContextClosedEvent");
}elseif(eventinstanceofContextStartedEvent){
System.out.println("helloContextStartedEvent");
}
}

}

xml配置方式如下：

应用启动方法如下：

ClassPathXmlApplicationContextcontext=newClassPathXmlApplicationContext("spring/dubbo-provider.xml");
context.start();
context.close();

程序输出结果如下所示：

最后采用图示说明总结以上结果：

四、源码解析

不知道各位读者有没有猜对这几种方式的执行顺序，下面我们就从源码角度解析Spring内部处理的顺序。

4.1、初始化过程

使用ClassPathXmlApplicationContext启动Spring容器，将会调用refresh方法初始化容器。初始化过程将会创建Bean。最后当一切准备完毕，将会发送ContextRefreshedEvent。当容器初始化完毕，调用context.start()就发送ContextStartedEvent事件。

refresh方法源码如下：

publicvoidrefresh()throwsBeansException,IllegalStateException{
synchronized(this.startupShutdownMonitor){
//...忽略无关代码

//初始化所有非延迟初始化的Bean
finishBeanFactoryInitialization(beanFactory);

//发送ContextRefreshedEvent
finishRefresh();

//...忽略无关代码
}
}

一路跟踪finishBeanFactoryInitialization源码，直到AbstractAutowireCapableBeanFactory#initializeBean，源码如下：

protectedObjectinitializeBean(finalStringbeanName,finalObjectbean,RootBeanDefinitionmbd){
ObjectwrappedBean=bean;
if(mbd==null||!mbd.isSynthetic()){
//调用BeanPostProcessor#postProcessBeforeInitialization方法
wrappedBean=applyBeanPostProcessorsBeforeInitialization(wrappedBean,beanName);
}

try{
//初始化Bean
invokeInitMethods(beanName,wrappedBean,mbd);
}
catch(Throwableex){
thrownewBeanCreationException(
(mbd!=null?mbd.getResourceDescription():null),
beanName,"Invocationofinitmethodfailed",ex);
}
}

BeanPostProcessor将会起着拦截器的作用，一旦Bean符合条件，将会执行一些处理。这里带有@PostConstruct注解的Bean都将会被CommonAnnotationBeanPostProcessor类拦截，内部将会触发@PostConstruct标注的方法。

接着执行invokeInitMethods，方法如下:

protectedvoidinvokeInitMethods(StringbeanName,finalObjectbean,RootBeanDefinitionmbd)
throwsThrowable{

booleanisInitializingBean=(beaninstanceofInitializingBean);
if(isInitializingBean&&(mbd==null||!mbd.isExternallyManagedInitMethod("afterPropertiesSet"))){
//省略无关代码
//如果是Bean继承InitializingBean，将会执行afterPropertiesSet方法
((InitializingBean)bean).afterPropertiesSet();
}

if(mbd!=null){
StringinitMethodName=mbd.getInitMethodName();
if(initMethodName!=null&&!(isInitializingBean&&"afterPropertiesSet".equals(initMethodName))&&
!mbd.isExternallyManagedInitMethod(initMethodName)){
//执行XML定义init-method
invokeCustomInitMethod(beanName,bean,mbd);
}
}
}

如果Bean继承InitializingBean接口，将会执行afterPropertiesSet方法，另外如果在XML中指定了init-method，也将会触发。

上面源码其实都是围绕着Bean创建的过程，当所有Bean创建完成之后，调用context#start将会发送ContextStartedEvent。这里源码比较简单，如下：

publicvoidstart(){
getLifecycleProcessor().start();
publishEvent(newContextStartedEvent(this));
}

4.2、销毁过程

调用ClassPathXmlApplicationContext#close方法将会关闭容器，具体逻辑将会在doClose方法执行。

doClose这个方法首先发送ContextClosedEvent，然再后开始销毁Bean。

灵魂拷问:如果我们颠倒上面两者顺序，结果会一样吗？

doClose源码如下：

protectedvoiddoClose(){
if(this.active.get()&&this.closed.compareAndSet(false,true)){
//省略无关代码

try{
//Publishshutdownevent.
publishEvent(newContextClosedEvent(this));
}
catch(Throwableex){
logger.warn("ExceptionthrownfromApplicationListenerhandlingContextClosedEvent",ex);
}


//销毁Bean
destroyBeans();

//省略无关代码
}
}

destroyBeans最终将会执行DisposableBeanAdapter#destroy，@PreDestroy、DisposableBean、destroy-method三者定义的方法都将会在内部被执行。

首先执行DestructionAwareBeanPostProcessor#postProcessBeforeDestruction，这里方法类似与上面BeanPostProcessor。

@PreDestroy注解将会被CommonAnnotationBeanPostProcessor拦截，这里类同时也继承了DestructionAwareBeanPostProcessor。

最后如果Bean为DisposableBean的子类，将会执行destroy方法，如果在xml定义了destroy-method方法，该方法也会被执行。

publicvoiddestroy(){
if(!CollectionUtils.isEmpty(this.beanPostProcessors)){
for(DestructionAwareBeanPostProcessorprocessor:this.beanPostProcessors){
processor.postProcessBeforeDestruction(this.bean,this.beanName);
}
}

if(this.invokeDisposableBean){
//省略无关代码
//如果Bean继承DisposableBean，执行destroy方法
((DisposableBean)bean).destroy();

}

if(this.destroyMethod!=null){
//执行xml指定的destroy-method方法
invokeCustomDestroyMethod(this.destroyMethod);
}
elseif(this.destroyMethodName!=null){
MethodmethodToCall=determineDestroyMethod();
if(methodToCall!=null){
invokeCustomDestroyMethod(methodToCall);
}
}
}

五、总结

init-method/destroy-method这种方式需要使用XML配置文件或单独注解配置类，相对来说比较繁琐。而InitializingBean/DisposableBean这种方式需要单独继承Spring的接口实现相关方法。@PostConstruct/@PreDestroy这种注解方式使用方式简单，代码清晰，比较推荐使用这种方式。

另外ContextStartedEvent/ContextClosedEvent这种方式比较适合在一些集成框架使用，比如Dubbo2.6.X优雅停机就是用改机制。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

Spring Bean初始化及销毁多种实现方式

热门推荐

随机推荐