SpringIOC容器中Bean的生命周期

1.IOC容器中Bean的生命周期方法

•   Spring IOC容器可以管理Bean的生命周期，Spring允许在Bean生命周期的特定点执行定制的任务。
• SpringIOC容器对Bean的生命周期进行管理的过程：

1. 通过构造方法或工厂方法创建bean对象
2. 为Bean对象注入值（调用set方法）
3. 调用Bean的初始化方法 通过init-method来指定
4. Bean 可以使用了
5. 当IOC容器，调用Bean的销毁方法

• 在Bean的 声明里设置init-method和destory-method属性，为Bean指定初始化和销毁方法。

（1）创建一个javaBean

package com.hbsi.springlifecycle;

public class Address {
	private String city;
	private String street;
	// IOC容器中bean生命周期的第一阶段：调用构造器 创建对象
	public Address() {
		super();
		System.out.println("1.创建Bean对象");
	}
	// 生命周期的第二阶段：给对象的属性赋值
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
	public String getStreet() {
		return street;
	}
	public void setStreet(String street) {
		System.out.println("2.给对象的属性注入值");
		this.street = street;
	}
	// 生命周期的第三阶段:初始化阶段
	public void init() {
		System.out.println("3.初始化");
	}
	// 生命周期的第五阶段：销毁
	public void destory() {
		System.out.println("5.销毁");
	}
	@Override
	public String toString() {
		return "Address [city=" + city + ", street=" + street + "]";
	}
}

（2）spring-lifecycle.xml  配置javaBean

<?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">
	<!-- Spring IOC容器对bean的生命周期进行管理的过程 1.通过构造器或工厂方法创建Bean对象 2.为Bean对象注入值（调用set方法） 
		3.调用Bean的初始化方法，通过init-method来指定的 4.Bean可以使用了 5.当IOC容器关闭时，调用Bean的销毁方法 -->
	 <bean id="address" class="com.hbsi.springlifecycle.Address"
		init-method="init" destroy-method="destory">
		<property name="city" value="beijing"></property>
		<property name="street" value="chaoyang"></property>
	</bean>
 
</beans>

(3)进行测试，演示bean的生命周期

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
	public static void main(String[] args) {
	 ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("spring-lifecycle.xml");	
		Address address = classPathXmlApplicationContext.getBean("address",Address.class);
		System.out.println("4.使用Bean对象"+address);
		//关闭容器
		classPathXmlApplicationContext.close();
	}
}

结果展示：

2.创建Bean后置处理器

•  Bean的后置处理器允许在调用初始化方法前后Bean进行额外的处理
• Bean的后置处理器对IOC容器里的所有Bean实例逐一处理，而非单一实例，其典型的应用是：检查Bean属性的正确性或根据特定的标准更改Bean的属性
• 对Bean的后置处理器而言，需要实现BeanPostProcessor接口，在初始化方法被调用前后，Spring将把每个Bean实例分别传递给上述接口的以下两个方法：

（1）spring-lifecycle.xml 中配置bean的后置处理器

  <!-- 配置Bean的后置处理器：Spring会自动识别该Bean是一个后置处理器类 -->
   <bean class="com.hbsi.springlifecycle.MyBeanPostProcessor"></bean>

（2）后置处理器类 Bean的后置处理器对IOC容器中所有的Bean对象的生命周期都起作用.

//创建bean的后置处理器
public class MyBeanPostProcessor implements BeanPostProcessor {
	// bean的后置处理器 ,在初始化方法的前后对bean对象进行额外的处理
	/*bean的后置处理器对IOC容器里的所有Bean实例逐一处理，而非单一实例，其典型的应用是：检查bean属性是否正确性或根据特定的标准更改bean的属性
	 * bean的后置处理器对IOC容器中所有的bean对象的生命周期都起作用 
	 */
    //Bean:当前的bean对象  beanName:当前bean对象的id值
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("postProcessAfterInitialization:" + bean);
		Address address = (Address) bean;
		address.setStreet("Huilongguan");
		return address;
	}
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("postProcessBeforeInitialization:"+bean);
		Address address = new Address();
		address.setCity("ShangHai");
		address.setStreet("PudongdaDao");
		return address;
	}
}

测试跟上面的测试是一样的

• 当加入了Bean的后置处理器，IOC容器中Bean的生命周期分为七个阶段

       

   ① 调用构造器 或者是通过工厂的方式创建Bean对象

   ② 给bean对象的属性注入值

   ③ 执行Bean后置处理器中的 postProcessBeforeInitialization方法

   ④ 调用初始化方法，进行初始化， 初始化方法是通过init-method来指定的.

   ⑤ 执行Bean的后置处理器中 postProcessAfterInitialization方法

   ⑥ 使用

   ⑦ IOC容器关闭时， 销毁Bean对象.

3.spring Bean的作用域

见本人博客https://blog.csdn.net/lbqlzch/article/details/106348044