Spring5企业级开发实战（四）————Bean的生命周期

最新推荐文章于 2020-12-03 01:58:45 发布

原创最新推荐文章于 2020-12-03 01:58:45 发布 · 1.5k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Spring5 Bean的生命周期 BeanFactory

Spring5+SpringBoot+Redis 专栏收录该内容

8 篇文章

订阅专栏

本文深入解析Spring框架中Bean的生命周期，包括Bean从创建到销毁的全过程，涉及Bean的自身方法、生命周期接口方法、容器级和工厂级后处理器接口方法。通过代码示例展示了不同阶段的执行顺序和作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

引言

SpringIoc容器管理的Bean默认都是单例设计模式的，即每个Bean只有一个实例化的Bean对象存在于SpringIoc容器中，因此SpringIoc容器需要负责管理Bean的生命周期。

分类

Bean 的生命周期可以分为以下四类，
（1）Bean 的自身方法
（2）Bean生命周期接口方法
（3）容器级生命周期接口方法
（4）工厂后处理器接口方法

Spring生命周期各个阶段	相关接口及方法
Bean 的自身方法	Bean本身业务的方法。配置文件中init-method和destroy-method指定的方法
Bean生命周期接口方法	InitializingBean接口，DiposiableBean接口，BeanNameAware接口，ApplicationContextAware接口，BeanFactoryAware接口等等
容器级生命周期接口方法	InstantiationAwareBeanPostProcessor接口实现，BeanPostProcessor接口实现
工厂后处理器接口方法	AspectJWWeavingEnabler ConfigurationClassPostProcessor,CustomAutowireConfigurer等

Bean 的自身方法及Bean生命周期接口方法

设计一个BeanLifeCycle类，继承相关接口

package com.Bean生命周期;

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:haozhixin
 * Func: Bean的生命周期
 * Date: 2019-08-05
 */
public class BeanLifeCycle implements BeanNameAware,ApplicationContextAware,InitializingBean,DisposableBean{
	/*
	* 构造器
	*
	*/
	public BeanLifeCycle(){
		System.out.println("1.[Bean级别]构造器执行了");
	}
	/*
	* BeanNameAware接口方法实现
	*
	*/
	@Override
	public void setBeanName(String name){
		System.out.println("2.[Bean级别]setBean方法执行了]");
	}

	/*
	* ApplicationContextAware接口方法实现
	*
	*/
	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException{
		System.out.println("3.[Bean级别]setApplicationContext方法执行了]");
	}
	/*
	* InitializingBean接口方法实现
	*
	*/
	@Override
	public  void afterPropertiesSet() throws  Exception{
		System.out.println("4.[Bean级别]afterPropertiesSet方法执行了]");
	}
	/*
	* init-method属性指定的方法
	*
	*/
	public void lifeCycleInit(){
		System.out.println("5.[Bean级别]lifeCycleInit方法执行了]");
	}
	/*
	* bean中的业务方法
	*
	*/
	public void sayHello(){
		System.out.println("6.[Bean级别]syHello方法执行了]");
	}
	/*
	* DisposableBean接口方法实现
	*
	*/
	@Override
	public void destroy() throws Exception {
		System.out.println("7.[Bean级别]destroy方法执行了]");
	}
	/*
	* destroy-method属性指定的方法
	*
	*/
	public void lifeCycleInitDestroy(){
		System.out.println("8.[Bean级别]lifeCycleInitDestroy方法执行了]");
	}
}

bean_life_cycle.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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="BeanLifeCycle" class="com.Bean生命周期.BeanLifeCycle" scope="singleton" init-method="lifeCycleInit" destroy-method="lifeCycleInitDestroy">

    </bean>
</beans>

测试类的写法

import com.Bean生命周期.BeanLifeCycle;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * Author:haozhixin
 * Func: Bean的生命周期
 * Date: 2019-08-05
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:bean_life_cycle.xml")
public class BeanLifeCycleTest {
	@Autowired
	private BeanLifeCycle beanLifeCycle;
	@Test
	public void test(){
		beanLifeCycle.sayHello();
	}
}

测试结果：

1.[Bean级别]构造器执行了
2.[Bean级别]setBean方法执行了]
3.[Bean级别]setApplicationContext方法执行了]
4.[Bean级别]afterPropertiesSet方法执行了]
5.[Bean级别]lifeCycleInit方法执行了]
6.[Bean级别]syHello方法执行了]
7.[Bean级别]destroy方法执行了]
8.[Bean级别]lifeCycleInitDestroy方法执行了]

我们可以看到执行顺序，即Bean自身方法和Bean声明周期接口方法生命周期为：
Ioc容器–>Bean构造器->BeanNameAware->ApplicationContextAware–>InitializingBean->init-method->Bean中的业务方法->DisposableBean->destroy-method方法。

容器级生命周期接口方法的执行次序

容器级接口方法一般有InstantiationAwareBeanPostProcessor和BeanPostProcessor两个接口，一般也将其实现类称为后处理器。容器级生命周期接口的实现独立于SpringIoc容器中的Bean，其是以容器拓展的形式注册到Spring中的。无论SpringIoc管理任何的Bean，这些后处理器都会发生作用。因此后处理器的影响范围是全局的SpringIoc容器中的Bean。用户可以通过编写合理的后处理器来实现自己对Bean的加工逻辑。

BeanPostProcessor：可以对Bean的属性进行更改
InstantiationAwareBeanPostProcessor：此接口可以在bean的实例化之前，之后操作，也可以在实例化之后进行属性操作
InstantiationAwareBeanPostProcessorAdapter：适配器类

代码实现：

package com.Bean生命周期;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;

import java.beans.PropertyDescriptor;

/**
 * Author:haozhixin
 * Func:
 * Date:
 */
public class ContainerLifeCycle extends InstantiationAwareBeanPostProcessorAdapter{
	/***
	 * 构造器
	 */
	public ContainerLifeCycle(){
		System.out.println("a.[容器级别]ContainerLifeCycle构造器执行了");
	}

	/***
	 *接口方法和实例化bean之前调用
	 */
	@Override
	public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		System.out.println("b.[容器级别]postProcessBeforeInstantiation执行了,beanClass:"+beanClass);
		return null;
	}

    /***
     *设置某个属性时调用
     */
	@Override
	public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
		System.out.println("c.[容器级别]postProcessPropertyValues执行了,beanName:"+beanName);
		return pvs;
	}


	/***
	 *接口方法和实例化Bean之后调用
	 */
	@Override
	public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
		System.out.println("d.[容器级别]postProcessAfterInstantiation执行了,beanClass:"+bean.getClass());
		return true;
	}


}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="ContainerLifeCycle" class="com.Bean生命周期.ContainerLifeCycle" scope="singleton" >

    </bean>
</beans>

import com.Bean生命周期.BeanLifeCycle;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * Author:haozhixin
 * Func: Bean的生命周期
 * Date: 2019-08-05
 */
public class ContainerLifeCycleTest {
	public static void main(String [] args){
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean_life_cycle.xml","classpath:container_life_cycle.xml");
		BeanLifeCycle beanLifeCycle = context.getBean("BeanLifeCycle",BeanLifeCycle.class);
		beanLifeCycle.sayHello();
		context.close();
	}
}

运行结果：

a.[容器级别]ContainerLifeCycle构造器执行了
b.[容器级别]postProcessBeforeInstantiation执行了,beanClass:class com.Bean生命周期.BeanLifeCycle
1.[Bean级别]构造器执行了
d.[容器级别]postProcessAfterInstantiation执行了,beanClass:class com.Bean生命周期.BeanLifeCycle
c.[容器级别]postProcessPropertyValues执行了,beanName:BeanLifeCycle
2.[Bean级别]setBean方法执行了]
3.[Bean级别]setApplicationContext方法执行了]
4.[Bean级别]afterPropertiesSet方法执行了]
5.[Bean级别]lifeCycleInit方法执行了]
6.[Bean级别]syHello方法执行了]
7.[Bean级别]destroy方法执行了]
8.[Bean级别]lifeCycleInitDestroy方法执行了]

工厂级生命周期接口代码实现

话不多说，直接上代码

package com.Bean生命周期;

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.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

/**
 * Author:haozhixin
 * Func: Bean的生命周期
 * Date: 2019-08-05
 */
public class FactoryLifeCycle implements BeanFactoryPostProcessor{
	/*
	* 构造器
	*
	*/
	public FactoryLifeCycle(){
		System.out.println("一.[工厂级别]构造器执行了");
	}

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println("二.[工厂级别]postProcessBeanFactory方法执行了");
	}
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="FactoryLifeCycle" class="com.Bean生命周期.FactoryLifeCycle" scope="singleton" >

    </bean>
</beans>

import com.Bean生命周期.BeanLifeCycle;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Author:haozhixin
 * Func: Bean的生命周期（工厂级别，bean级别，容器级别）
 * Date: 2019-08-05
 */
public class FactoryLifeCycleTest {
	public static void main(String [] args){
		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:bean_life_cycle.xml","classpath:container_life_cycle.xml","classpath:factory_life_cycle.xml");
		BeanLifeCycle beanLifeCycle = context.getBean("BeanLifeCycle",BeanLifeCycle.class);
		beanLifeCycle.sayHello();
		context.close();
	}
}

执行结果是：

一.[工厂级别]构造器执行了
二.[工厂级别]postProcessBeanFactory方法执行了
a.[容器级别]ContainerLifeCycle构造器执行了
b.[容器级别]postProcessBeforeInstantiation执行了,beanClass:class com.Bean生命周期.BeanLifeCycle
1.[Bean级别]构造器执行了
d.[容器级别]postProcessAfterInstantiation执行了,beanClass:class com.Bean生命周期.BeanLifeCycle
c.[容器级别]postProcessPropertyValues执行了,beanName:BeanLifeCycle
2.[Bean级别]setBean方法执行了]
3.[Bean级别]setApplicationContext方法执行了]
4.[Bean级别]afterPropertiesSet方法执行了]
5.[Bean级别]lifeCycleInit方法执行了]
6.[Bean级别]syHello方法执行了]
7.[Bean级别]destroy方法执行了]
8.[Bean级别]lifeCycleInitDestroy方法执行了]

好了，就这么多，大家如果有疑问可以去Spring5企业级开发实战（五）下载以下源代码。

作者：select you from me
来源：优快云
转载请联系作者获得授权并注明出处。