SpringIOC容器中Bean的生命周期

男娘i 2023-02-12 12:28 4阅读 0赞

### 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">
    	
    	 <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>

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xicWx6Y2g_size_16_color_FFFFFF_t_70][]

(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();
    	}
    }

结果展示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xicWx6Y2g_size_16_color_FFFFFF_t_70 1][]

### 2.**创建****Bean****后置处理器** ###

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

（1）spring-lifecycle.xml 中配置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;
    	}
    }

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xicWx6Y2g_size_16_color_FFFFFF_t_70 2][]

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

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

② 给bean对象的属性注入值

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

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

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

⑥ 使用

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

### 3.spring Bean的作用域 ###

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xicWx6Y2g_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200526110838199.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xicWx6Y2g=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xicWx6Y2g_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200526110748740.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xicWx6Y2g=,size_16,color_FFFFFF,t_70
[20200526111723598.png]: https://img-blog.csdnimg.cn/20200526111723598.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xicWx6Y2g_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200526112551633.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xicWx6Y2g=,size_16,color_FFFFFF,t_70
[https_blog.csdn.net_lbqlzch_article_details_106348044]: https://blog.csdn.net/lbqlzch/article/details/106348044