一.xml方式配置bean

二.Aware接口

  2.1 BeanNameAware

  2.2 BeanFactoryAware

  2.3 ApplicationContextAware

  2.4 Aware各接口的执行顺序

  2.4 Aware接口总结

三.BeanPostProcessor接口

四.InitializingBean接口

五.init-method方法

六.DestructionAwareBeanPostProcessor接口

七.DisposableBean接口

八.destory-method方法

九.生命周期大杂烩

  9.1 实现多接口的Student类

  9.2 BeanPostProcessor前后置处理

  9.3 DestructionAwareBeanPostPrecessor接口

  9.4 配置xml文件

  9.5 测试代码

  9.6 输出结果

十.总结

  Spring Bean的生命周期是一个老生常谈的问题了,网上一搜一大把,无非就是画一幅流程图(比如下面这幅图),然后用语言介绍创建bean后执行各Aware接口,然后BeanPostProcessor.....最终Bean创建成功了,就可以使用这个Bean了,然后在容器销毁的时候,又会执行一些操作。

  其实对于上面的提到的流程图,注意上面的图只是Spring Bean的大概流程(省略了一部分),主要涉及到了5个接口,分别是XxxAware、BeanPostProcessor、InitiailizingBean、Destruction、DisposableBean接口,本文将会对这几个接口,以及init-method、destroy-method做相关的使用介绍,在明白怎么使用后,再把他们串起来,这样的话,对于Spring Bean的生命周期就差不多知道咋回事了,而不用死记硬背。

一. xml方式配置Bean

  在说Aware、BeanPostProcessor、InitiailizingBean、Destruction、DisposableBean这些接口前,先简单回顾一下使用xml配置并获取一个Student类的bean过程,后面介绍各个接口的使用方式时时,也是按照这个形式;

1.1 创建Student类

  平淡无奇的Student类:

package cn.ganlixin.entity;

import lombok.Data;
import lombok.extern.slf4j.Slf4j; @Data
@Slf4j
public class Student { private Integer id;
private String name;
}

  

1.2 创建配置文件

  平淡无奇的applicationContext.xml配置文件,创建一个student bean,利用setter方式设置初始值:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean class="cn.ganlixin.entity.Student" id="student">
<property name="id" value="99"/>
<property name="name" value="张三"/>
</bean>
</beans>

  

1.3 测试

  创建一个Main类,用于测试

package cn.ganlixin;

import cn.ganlixin.entity.Student;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource; @Slf4j
public class Test { public static void main(String[] args) {
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml")); Student student = beanFactory.getBean("student", Student.class);
log.info("测试程序获取到的student bean:{}", student);
}
}

  下面是运行程序的输出,可以看到和预期相符,创建一个Student的bean,id和name默认值为99、张三;

INFO  [main] cn.ganlixin.Test - 测试程序获取到的student bean:Student(id=99, name=张三)

  

二.Aware接口

  Aware接口有很多实现类,本文只介绍BeanNameAware、BeanFactoryAware、ApplicationContextAware,关系如下:

  

2.1 BeanNameAware

  创建一个Student类,让该类实现BeanNameAware接口,并且重写setBeanName方法

@Data
@Slf4j
public class Student implements BeanNameAware { private Integer id;
private String name; /**
* 实现了BeanNameAware接口后,需重写setBeanName方法,接收的参数就是bean的id
*
* @param s bean的id
*/
@Override
public void setBeanName(String s) {
log.info("beanName:{}, student bean:{}", s, this);
this.id = 100;
log.info("将beanName:{}的id改为100", s);
}
}

  配置文件和测试程序都不改变,运行测试程序,输出内容如下:

INFO  [main] cn.ganlixin.entity.Student - beanName:student, student bean:Student(id=99, name=张三)
INFO [main] cn.ganlixin.entity.Student - 将beanName:student的id改为100
INFO [main] cn.ganlixin.Test - 测试程序获取到的student bean:Student(id=100, name=张三)

  可以看到,实现BeanNameAware接口后,重写setBeanName的方法中,获取到的student bean,是已经初始化的bean(属性都已经有值了),并且setBeanName方法中可以对当前的bean进行各种操作,包括修改bean的某些属性,最后获取到的bean是已经修改后的bean。

  这里只是简单介绍了一下BeanNameAware接口的用法,使用BeanNameAware接口,可以对当前Bean进行操作。

2.2 BeanFactoryAware

  创建Student类,实现BeanFactoryAware接口,并且重写setBeanFactory方法

@Data
@Slf4j
public class Student implements BeanFactoryAware { private Integer id;
private String name; /**
* 实现BeanFactoryAware接口后,需重写setBeanFactroy方法
*
* @param beanFactory 创建该bean的beanFactory
*/
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
// 可以在setBeanFactory方法中获取、修改beanFactory中的所有bean log.info("student this bean:{}", this);
Student student = beanFactory.getBean("student", Student.class);
log.info("通过beanFactory获取student bean:{}", student); // 将name设置为李四
this.name = "李四";
}
}

  运行输出如下:

INFO  [main] cn.ganlixin.entity.Student - student this bean:Student(id=99, name=张三)
INFO [main] cn.ganlixin.entity.Student - 通过beanFactory获取student bean:Student(id=99, name=张三)
INFO [main] cn.ganlixin.Test - 测试程序获取到的student bean:Student(id=99, name=李四)

  通过上面的代码输出结果可以看出,实现BeanFactoryAware接口后,可以在setBeanFactory方法中操作BeanFactory的所有bean,操作的范围要比BeanNameAware要大。

2.3 ApplicationContextAware

  ApplicationContext,有多种称呼,比如“应用容器”、“环境”、“上线文”...

  创建Student类,实现ApplicationContextAware接口,并且重写setApplicationContext接口:

@Data
@Slf4j
public class Student implements ApplicationContextAware { private Integer id;
private String name; /**
* 实现ApplicationContextAware接口后,徐重写setApplicationContext方法
*
* @param applicationContext 该bean所在的上下文(applicationContext、容器)
*/
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
log.info("Student this:{}", this); final Student student = applicationContext.getBean("student", Student.class);
final Environment environment = applicationContext.getEnvironment();
log.info("student bean:{}", student);
log.info("env -> user.dir:{}", environment.getProperty("user.dir"));
}
}

  需要修改一下测试程序,测试程序中加载配置时使用的XmlBeanFactory,而XmlBeanFactory不会回调ApplicationContextAware接口的setApplicationContext方法,下面使用ClassPathXmlApplicationContext类来加载配置:

@Slf4j
public class Test { public static void main(String[] args) {
//BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml")); // 使用ApplicationContext来加载配置
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Student student = context.getBean("student", Student.class);
log.info("测试程序获取到的student bean:{}", student);
}
}

  运行测试程序:

INFO  [main] cn.ganlixin.entity.Student - Student this:Student(id=99, name=张三)
INFO [main] cn.ganlixin.entity.Student - student bean:Student(id=99, name=张三)
INFO [main] cn.ganlixin.entity.Student - env -> user.dir:/Users/ganlixin/code/java-code-all/spring
INFO [main] cn.ganlixin.Test - 测试程序获取到的student bean:Student(id=99, name=张三)

  实现ApplicationContextAware接口后,在setApplicationContext方法中,入参是当前的applicationContext,也就是说,可以在该方法中对Spring容器进行设置,操作的范围又要比BeanFactoryAware的setBeanFactory要广得多。

2.4 Aware各接口执行的先后顺序

  既然有这几个Aware接口,如果一个类同时实现了这3个接口,那么执行顺序是怎样的呢?下面就来测试一下。

  创建Student类,分别实现BeanNameAware、BeanFactoryAware、ApplicationContextAware接口,并重写其接口的方法:

@Data
@Slf4j
public class Student implements BeanNameAware, BeanFactoryAware, ApplicationContextAware { private Integer id;
private String name; /**
* 实现了BeanNameAware接口后,需重写setBeanName方法,接收的参数就是bean的id
*
* @param s bean的id
*/
@Override
public void setBeanName(String s) {
log.info("call BeanNameAware.setBeanName()");
} /**
* 实现BeanFactoryAware接口后,需重写setBeanFactroy
*
* @param beanFactory 创建该bean的bean工厂
*/
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
log.info("call BeanFactoryAware.setBeanFactory()");
} /**
* 实现ApplicationContextAware接口后,徐重写setApplicationContext方法
*
* @param applicationContext 该bean所在的上下文(applicationContext、容器)
*/
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
log.info("call ApplicationContextAware.setApplicationContext()");
}
}

  仍旧使用ClassPathXmlApplicationContext类来加载配置,运行输出结果如下:

INFO  [main] cn.ganlixin.entity.Student - call BeanNameAware.setBeanName()
INFO [main] cn.ganlixin.entity.Student - call BeanFactoryAware.setBeanFactory()
INFO [main] cn.ganlixin.entity.Student - call ApplicationContextAware.setApplicationContext()
INFO [main] cn.ganlixin.Test - 测试程序获取到的student bean:Student(id=99, name=张三)

  

2.4 Aware接口总结

  上面演示了Spring中几个Aware接口的用法和特点,下面总结一下:

  1.实现BeanNameAware接口后,重写setBeanName方法,可以对单个Bean进行扩展修改;

  2.实现BeanFactoryAware接口后,重写setBeanFactory方法,可以对bean工厂中的所有Bean进行扩展修改;

  3.实现ApplicationContextAware接口后,重写setApplicationContext方法后,可以对整个容器进行扩展修改;

  4.这几个接口的执行顺序分别是BeanNameAware->BeanFactoryAware->ApplicationContextAware;

三.BeanPostProcessor接口

  BeanPostProcessor和前面的Aware接口有些区别,通过下面的例子就能看出区别在哪里!

  下面举个例子,创建MyBeanPostProcessor类,实现BeanPostProcessor接口,注意,这里没有在Student类上实现BeanPostProcessor接口。

@Slf4j
public class MyBeanPostProcessor implements BeanPostProcessor { /**
* 实现了BeanPostProcessor接口后,重写postProcessBeforeInitialization,在各种Aware接口执行完毕后执行该方法
*
* @param bean 本次处理的bean
* @param beanName 本次处理的beanName(bean id)
* @return 返回的是在本方法中处理后的bean
*/
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
log.info("MyBeanPostProcessor.postProcessBeforeInitialization, beanName:{}, bean:{}", beanName, bean);
return bean;
} /**
* 实现了BeanPostProcessor接口后,重写postProcessBeforeInitialization,在initMethod方法执行完毕后执行该方法
*
* @param bean 本次处理的bean
* @param beanName 本次处理的beanName(bean id)
* @return 返回的是在本方法中处理后的bean
*/
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
log.info("MyBeanPostProcessor.postProcessAfterInitialization, beanName:{}, bean:{}", beanName, bean);
return bean;
}
}

  创建两个类,分别是Student和User类,其中Use类没有实现Aware接口,Student类实现了前面提到的3个Aware接口

@Data
public class User {
private Integer id;
private String name;
}

  

@Data
@Slf4j
public class Student implements BeanNameAware, BeanFactoryAware, ApplicationContextAware { private Integer id;
private String name; /**
* 实现了BeanNameAware接口后,需重写setBeanName方法,接收的参数就是bean的id
*
* @param s bean的id
*/
@Override
public void setBeanName(String s) {
log.info("call BeanNameAware.setBeanName()");
} /**
* 实现BeanFactoryAware接口后,需重写setBeanFactroy
*
* @param beanFactory 创建该bean的bean工厂
*/
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
log.info("call BeanFactoryAware.setBeanFactory()");
} /**
* 实现ApplicationContextAware接口后,徐重写setApplicationContext方法
*
* @param applicationContext 该bean所在的上下文(applicationContext、容器)
*/
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
log.info("call ApplicationContextAware.setApplicationContext()");
}
}

  

  xml配置文件:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean class="cn.ganlixin.entity.Student" id="student">
<property name="id" value="99"/>
<property name="name" value="张三"/>
</bean> <bean class="cn.ganlixin.entity.User" id="user">
<property name="id" value="88"/>
<property name="name" value="王五"/>
</bean> <!-- 将实现了BeanPostProcessor接口的类也声明为bean -->
<bean class="cn.ganlixin.processor.MyBeanPostProcessor"/>
</beans>

  

  测试:

INFO  [main] cn.ganlixin.entity.Student - call BeanNameAware.setBeanName()
INFO [main] cn.ganlixin.entity.Student - call BeanFactoryAware.setBeanFactory()
INFO [main] cn.ganlixin.entity.Student - call ApplicationContextAware.setApplicationContext()
INFO [main] cn.ganlixin.processor.MyBeanPostProcessor - MyBeanPostProcessor.postProcessBeforeInitialization, beanName:student1, bean:Student(id=99, name=张三)
INFO [main] cn.ganlixin.processor.MyBeanPostProcessor - MyBeanPostProcessor.postProcessAfterInitialization, beanName:student1, bean:Student(id=99, name=张三)
INFO [main] cn.ganlixin.processor.MyBeanPostProcessor - MyBeanPostProcessor.postProcessBeforeInitialization, beanName:user, bean:User(id=88, name=王五)
INFO [main] cn.ganlixin.processor.MyBeanPostProcessor - MyBeanPostProcessor.postProcessAfterInitialization, beanName:user, bean:User(id=88, name=王五)
INFO [main] cn.ganlixin.Test - 测试程序获取到的student bean:Student(id=99, name=张三)

  从上面的运行结果可以得出以下结论:

  1.因为只有Student实现了Aware接口,所以创建student bean的时候会调用对应的Aware接口方法,而User类没有实现Aware接口,所以并没有调用Aware接口方法;

  2.Student和User类都没有继承BeanPostProcessor接口,但是在创建student和user bean的时候,都掉用了MyBeanPostProcessor类中的前置和后置处理(继承自BeanPostProcessor接口);

  3.BeanPostProcessor接口的前置和后置处理,是在Aware接口之后调用;

  4.很重要的一点,需要将BeanPostProcessor接口实现类声明为bean,使用<bean>配置或者使用@Component注解,不然BeanPostProcessor不起作用。

四.InitializingBean接口

  创建Student类,实现InitializingBean接口,然后重写afterPropertiesSet方法:

@Data
@Slf4j
public class Student implements InitializingBean { private Integer id;
private String name; @Override
public void afterPropertiesSet() throws Exception {
// 同样可以在这里修改bean的属性值
log.info("InitialingBean.afterPropertiesSet, this:{}", this);
}
}

  修改xml配置文件,创建student bean,测试:

INFO  [main] cn.ganlixin.entity.Student - InitialingBean.afterPropertiesSet, this:Student(id=99, name=张三)
INFO [main] cn.ganlixin.Test - 测试程序获取到的student bean:Student(id=99, name=张三)

  

五.init-method

  创建Student类,增加一个额外的方法display()

@Data
@Slf4j
public class Student { private Integer id;
private String name; public void display() {
log.info("Student.display call, this:{}", this);
}
}

  修改配置文件,在<bean>标签中增加init-method属性,值为display,也就是Student的display方法名:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean class="cn.ganlixin.entity.Student" id="student" init-method="display">
<property name="id" value="99"/>
<property name="name" value="张三"/>
</bean>
</beans>

  运行测试:

INFO  [main] cn.ganlixin.entity.Student - Student.display call, this:Student(id=99, name=张三)
INFO [main] cn.ganlixin.Test - 测试程序获取到的student bean:Student(id=99, name=张三)

  上面,输出了display中的内容,这是在设置bean的时候调用的。

六.DestructionAwareBeanPostProcessor接口

  DestructionAwareBeanPostProcessor接口,从名称上可以看出来是DestructionAware + BeanPostProcessor的组合,其实也的确是这样,但是需要注意的就是,spring并没有提供DestructionAware接口!!

  下面是DestructionAwareBeanPostProcessor接口的定义:

public interface DestructionAwareBeanPostProcessor extends BeanPostProcessor {

    /**
* Destruction执行的操作
*
* @param bean 处理的bean
* @param beanName bean的名称
* @throws BeansException
*/
void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException; /**
* 是否需要执行postProcessBeforeDestruction方法
*
* @param bean 执行Destruction的bean
* @return 是否需要执行postProcessBeforeDestruction方法
*/
default boolean requiresDestruction(Object bean) {
return true;
}
}

  DestructionAwareBeanPostProceesor继承自BeanPostProcessor接口,所以也可以重写前值和后置处理。

  下面介绍使用示例,创建MyDestructionAwareBeanPostProceesor,继承DestructionAwareBeanPostProceesor接口:

@Slf4j
public class MyDestructionAwareBeanPostProcessor implements DestructionAwareBeanPostProcessor { @Override
public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
log.info("DestructionAwareBeanPostProcessor.postProcessBeforeDestruction, \n\tbeanName:{}, bean:{}", beanName, bean);
} @Override
public boolean requiresDestruction(Object bean) {
return true; // 返回true,一律执行postProcessBeforeDestruction方法
// 如果返回false,则不执行postProcessBeforeDestruction方法
}
}

  修改配置文件:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean class="cn.ganlixin.entity.Student" id="student">
<property name="id" value="99"/>
<property name="name" value="张三"/>
</bean> <bean class="cn.ganlixin.entity.User" id="user">
<property name="id" value="88"/>
<property name="name" value="王五"/>
</bean> <!-- 将实现了DestructionAwareBeanPostProcessor接口的实现类声明为bean> -->
<bean class="cn.ganlixin.processor.MyDestructionAwareBeanPostProcessor"/>
</beans>

  测试程序:

@Slf4j
public class Test { public static void main(String[] args) {
// 使用ApplicationContext来加载配置
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Student student = context.getBean("student", Student.class);
User user = context.getBean("user", User.class); log.info("测试程序获取到的student bean:{}", student); // 获取bean工厂,然后调用destroyBean销毁bean
AutowireCapableBeanFactory factory = context.getAutowireCapableBeanFactory();
factory.destroyBean(student);
}
}

  运行测试程序,输出如下:

INFO  [main] cn.ganlixin.Test - 测试程序获取到的student bean:Student(id=99, name=张三)
INFO [main] cn.ganlixin.processor.MyDestructionAwareBeanPostProcessor - DestructionAwareBeanPostProcessor.postProcessBeforeDestruction,
beanName:cn.ganlixin.entity.Student, bean:Student(id=99, name=张三)

  可以看到,在手动调用destroyBean方法来销毁student bean的时候,调用了MyDestructionAwareBeanPostProcessor中定义的方法。

  需要注意的是,虽然这里使用destroyBean来销毁了student bean,如果又通过getBean来获取student bean,则会重新创建student bean。

七.DisposableBean接口 

  前面介绍了DestructionAwareBeanPostProcessor接口,可以对所有的bean设置销毁(destruction)后的处理操作。

  而这里介绍的DisposableBean接口,就是对单独的Bean进行destrction后的处理,也就是说不是应用到所有的bean上。

  简单介绍一下用法,创建Student类和User类,User类正常(不实现任何接口),Student类实现DisposableBean接口,然后重写destroy方法:

@Data
@Slf4j
public class Student implements DisposableBean { private Integer id;
private String name; @Override
public void destroy() throws Exception {
log.info("DisposableBean.destroy, this:{}", this);
}
} @Data
public class User {
private Integer id;
private String name;
}

  创建配置文件:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean class="cn.ganlixin.entity.Student" id="student">
<property name="id" value="99"/>
<property name="name" value="张三"/>
</bean> <bean class="cn.ganlixin.entity.User" id="user">
<property name="id" value="88"/>
<property name="name" value="王五"/>
</bean>
</beans>

  测试程序:

@Slf4j
public class Test { public static void main(String[] args) {
// 使用ApplicationContext来加载配置
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Student student = context.getBean("student", Student.class);
User user = context.getBean("user", User.class); log.info("测试程序获取到的student bean:{}", student);
log.info("测试程序获取到的user bean:{}",user); // 获取bean工厂,然后调用destroyBean销毁bean
AutowireCapableBeanFactory factory = context.getAutowireCapableBeanFactory();
factory.destroyBean(student);
factory.destroyBean(user);
}
}

  运行输出:

INFO  [main] cn.ganlixin.Test - 测试程序获取到的student bean:Student(id=99, name=张三)
INFO [main] cn.ganlixin.Test - 测试程序获取到的user bean:User(id=88, name=王五)
INFO [main] cn.ganlixin.entity.Student - DisposableBean.destroy, this:Student(id=99, name=张三)

  可以看到,虽然测试代码中destroy了student和user两个bean,但是只有student bean在销毁时触发了DisposableBean的destory方法。

八.destroy-method方法

  和init-method相对应的就是destory-method方法了,创建Student类,增加clean方法(自定义):

@Data
@Slf4j
public class Student { private Integer id;
private String name; public void clean() {
log.info("Student.clean, this:{}", this);
}
}

  修改配置文件,<bean>标签中使用destroy-method属性,值为clean方法

<bean class="cn.ganlixin.entity.Student" id="student" destroy-method="clean">
<property name="id" value="99"/>
<property name="name" value="张三"/>
</bean>

  测试程序:

@Slf4j
public class Test { public static void main(String[] args) {
// 使用ApplicationContext来加载配置
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Student student = context.getBean("student", Student.class); log.info("测试程序获取到的student bean:{}", student); // 删除bean
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) context.getAutowireCapableBeanFactory();
registry.removeBeanDefinition("student");
}
}

  输出:

INFO  [main] cn.ganlixin.Test - 测试程序获取到的student bean:Student(id=99, name=张三)
INFO [main] cn.ganlixin.entity.Student - Student.clean, this:Student(id=99, name=张三)

  

九.声明周期大杂烩

  上面对每一种接口都做了介绍,这里就将所有接口都做一下整合,尝试在一个测试程序中测试所有接口,这个过程中就会对Bean的生命周期有清晰的认识:

9.1 实现多接口的Student类

  创建Student类,实现Aware、InitializingBean、DisposableBean接口,并且增加display、clean方法,作为init-method和destory-method。

package cn.ganlixin.entity;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware; @Data
@Slf4j
public class Student implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean { private Integer id;
private String name; @Override
public void setBeanName(String s) {
log.info("BeanNameAware.setBeanName, this:{}", this);
} @Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
log.info("BeanFactoryAware.setBeanFactory, this:{}", this);
} @Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
log.info("ApplicationContextAware.setApplicationContext, this:{}", this);
} @Override
public void afterPropertiesSet() throws Exception {
log.info("InitialingBean.afterPropertiesSet, this:{}", this);
} @Override
public void destroy() throws Exception {
log.info("DisposableBean.destory, this:{}", this);
} public void display() {
log.info("init-method, Student.display, this:{}", this);
} public void clean() {
log.info("destroy-method, Student.clean, this:{}", this);
}
}

9.2 BeanPostProcessor前后置处理

  创建MyBeanPostProcessor接口实现类,并重写前置和后置处理方法:

package cn.ganlixin.processor;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor; @Slf4j
public class MyBeanPostProcessor implements BeanPostProcessor { @Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
log.info("MyBeanPostProcessor.postProcessBeforeInitialization, beanName:{}, bean:{}", beanName, bean);
return bean;
} @Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
log.info("MyBeanPostProcessor.postProcessAfterInitialization, beanName:{}, bean:{}", beanName, bean);
return bean;
}
}

9.3 DestructionAwareBeanPostPrecessor接口

  创建MyDestructionAwareBeanPostProcessor类,并重写其中的方法(不重写BeanPostProcessor的前后置处理方法):

package cn.ganlixin.processor;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor; @Slf4j
public class MyDestructionAwareBeanPostProcessor implements DestructionAwareBeanPostProcessor { @Override
public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
log.info("DestructionAwareBeanPostProcessor.postProcessBeforeDestruction, \n\tbeanName:{}, bean:{}", beanName, bean);
} @Override
public boolean requiresDestruction(Object bean) {
return true; // 返回true,一律执行postProcessBeforeDestruction方法
// 如果返回false,则不执行postProcessBeforeDestruction方法
}
}

  

9.4 配置xml文件  

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"> <!-- 创建student bean,指定init-method和destroy-method -->
<bean class="cn.ganlixin.entity.Student" id="student" init-method="display" destroy-method="clean">
<property name="id" value="99"/>
<property name="name" value="张三"/>
</bean> <!-- 将实现了DestructionAwareBeanPostProcessor接口的实现类声明为bean-->
<bean class="cn.ganlixin.processor.MyDestructionAwareBeanPostProcessor"/> <!-- 将实现了BeanPostProcessor接口的类也声明为bean-->
<bean class="cn.ganlixin.processor.MyBeanPostProcessor"/>
</beans>

  

9.5 测试代码

package cn.ganlixin;

import cn.ganlixin.entity.Student;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; @Slf4j
public class Test { public static void main(String[] args) {
// 使用ApplicationContext来加载配置
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Student student = context.getBean("student", Student.class); log.info("测试程序获取到的student bean:{}", student); // 删除bean
BeanDefinitionRegistry factory = (BeanDefinitionRegistry) context.getAutowireCapableBeanFactory();
factory.removeBeanDefinition("student");
}
}

  

9.6 输出结果

INFO  [main] cn.ganlixin.entity.Student - BeanNameAware.setBeanName, this:Student(id=99, name=张三)
INFO [main] cn.ganlixin.entity.Student - BeanFactoryAware.setBeanFactory, this:Student(id=99, name=张三)
INFO [main] cn.ganlixin.entity.Student - ApplicationContextAware.setApplicationContext, this:Student(id=99, name=张三)
INFO [main] cn.ganlixin.processor.MyBeanPostProcessor - MyBeanPostProcessor.postProcessBeforeInitialization, beanName:student, bean:Student(id=99, name=张三)
INFO [main] cn.ganlixin.entity.Student - InitialingBean.afterPropertiesSet, this:Student(id=99, name=张三)
INFO [main] cn.ganlixin.entity.Student - init-method, Student.display, this:Student(id=99, name=张三)
INFO [main] cn.ganlixin.processor.MyBeanPostProcessor - MyBeanPostProcessor.postProcessAfterInitialization, beanName:student, bean:Student(id=99, name=张三)
INFO [main] cn.ganlixin.Test - 测试程序获取到的student bean:Student(id=99, name=张三)
INFO [main] cn.ganlixin.processor.MyDestructionAwareBeanPostProcessor - DestructionAwareBeanPostProcessor.postProcessBeforeDestruction,
beanName:student, bean:Student(id=99, name=张三)
INFO [main] cn.ganlixin.entity.Student - DisposableBean.destory, this:Student(id=99, name=张三)
INFO [main] cn.ganlixin.entity.Student - destroy-method, Student.clean, this:Student(id=99, name=张三)

  

十.总结

  看了上面这个输出结果,再结合下面这个图,基本就能掌握Bean的大致生命周期了。

  

  原文地址:https://www.cnblogs.com/-beyond/p/13188675.html

  

  

Spring Bean各阶段生命周期的介绍的更多相关文章

  1. spring bean 容器的生命周期是什么样的?

    spring bean 容器的生命周期流程如下: 1.Spring 容器根据配置中的 bean 定义中实例化 bean. 2.Spring 使用依赖注入填充所有属性,如 bean 中所定义的配置. 3 ...

  2. spring Bean的完整生命周期

    spring 容器中的bean的完整生命周期一共分为十一步完成. 1.bean对象的实例化 2.封装属性,也就是设置properties中的属性值 3.如果bean实现了BeanNameAware,则 ...

  3. 一张图搞懂Spring bean的完整生命周期

    一张图搞懂Spring bean的生命周期,从Spring容器启动到容器销毁bean的全过程,包括下面一系列的流程,了解这些流程对我们想在其中任何一个环节怎么操作bean的生成及修饰是非常有帮助的. ...

  4. [spring] -- bean作用域跟生命周期篇

    作用域 singleton : 唯一 bean 实例,Spring 中的 bean 默认都是单例的. prototype : 每次请求都会创建一个新的 bean 实例. request : 每一次HT ...

  5. Spring 了解Bean的一生(生命周期)

    转载 https://blog.csdn.net/w_linux/article/details/80086950 该篇博客就来了解IoC容器下Bean的一生吧,也可以理解为bean的生命周期. ## ...

  6. Spring中与bean有关的生命周期

    前言 记得以前的时候,每次提起Spring中的bean相关的生命周期时,内心都无比的恐惧,因为好像有很多,自己又理不清楚,然后看网上的帖子,好像都是那么一套,什么beanFactory啊,aware接 ...

  7. Bean 注解(Annotation)配置(2)- Bean作用域与生命周期回调方法配置

    Spring 系列教程 Spring 框架介绍 Spring 框架模块 Spring开发环境搭建(Eclipse) 创建一个简单的Spring应用 Spring 控制反转容器(Inversion of ...

  8. Bean XML 配置(2)- Bean作用域与生命周期回调方法配置

    系列教程 Spring 框架介绍 Spring 框架模块 Spring开发环境搭建(Eclipse) 创建一个简单的Spring应用 Spring 控制反转容器(Inversion of Contro ...

  9. 浅尝Spring注解开发_Bean生命周期及执行过程

    Spring注解开发 浅尝Spring注解开发,基于Spring 4.3.12 包含Bean生命周期.自定义初始化方法.Debug BeanPostProcessor执行过程及在Spring底层中的应 ...

随机推荐

  1. 使用锚点定位不改变url同时平滑的滑动到锚点位置,不会生硬的直接到锚点位置

    使用锚点定位不改变url同时平滑的滑动到锚点位置,不会生硬的直接到锚点位置 对前端来说锚点是一个很好用的技术,它能快速定位到预先埋好的位置. 但是美中不足的是它会改变请求地址url,当用户使用了锚点的 ...

  2. Java实现 LeetCode 395 至少有K个重复字符的最长子串

    395. 至少有K个重复字符的最长子串 找到给定字符串(由小写字符组成)中的最长子串 T , 要求 T 中的每一字符出现次数都不少于 k .输出 T 的长度. 示例 1: 输入: s = " ...

  3. Java实现 LeetCode 150 逆波兰表达式求值

    150. 逆波兰表达式求值 根据逆波兰表示法,求表达式的值. 有效的运算符包括 +, -, *, / .每个运算对象可以是整数,也可以是另一个逆波兰表达式. 说明: 整数除法只保留整数部分. 给定逆波 ...

  4. Java中数组二分法查找

    算法:当数组的数据量很大适宜采用该方法.采用二分法查找时,数据需是有序不重复的,如果是无序的也可通过选择排序.冒泡排序等数组排序方法进行排序之后,就可以使用二分法查找. 基本思想:假设数据是按升序排序 ...

  5. Spring之JdbcTemplate使用

    一:JdbcTemplate概述及入门 “Don‘t Reinvent the Wheel” , 这是一句很经典的话,出自Spring官方,翻译过来就是说 “不要重复发明轮子” .由此我们可以猜测,J ...

  6. 通知!Symantec品牌证书已正式更名为Digicert

    尊敬的合作伙伴和客户: 您好! 2017年8月2日,CA认证机构Digicert宣布正式收购 Symantec 安全认证业务.为此,Digicert宣布从2020年4月30日起,停止使用与赛门铁克(S ...

  7. 天哪!手动编写mybatis雏形竟然这么简单

    前言 mybaits 在ORM 框架中,可算是半壁江山了,由于它是轻量级,半自动加载,灵活性和易拓展性.深受广大公司的喜爱,所以我们程序开发也离不开mybatis .但是我们有对mabtis 源码进行 ...

  8. 用struts的action运行jsp页面

    struts是开源框架.使用Struts的目的是为了帮助我们减少在运用MVC设计模型来开发Web应用的时间.如果我们想混合使用Servlets和JSP的优点来建立可扩展的应用,struts是一个不错的 ...

  9. 09.Django-数据库优化

    Django查询数据库性能优化 现在有一张记录用户信息的UserInfo数据表,表中记录了10个用户的姓名,呢称,年龄,工作等信息. models文件 from django.db import mo ...

  10. [xDebug] 服务器端的配置参数

    [Xdebug] ;load xdebug extensionzend_extension_ts = path/tp/xdebug;是否开启自动跟踪xdebug.auto_trace = On;是否开 ...