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

最新推荐文章于 2022-05-25 14:52:53 发布

apriaaaa

最新推荐文章于 2022-05-25 14:52:53 发布

阅读量132

点赞数 1

分类专栏：个人笔记

本文链接：https://blog.csdn.net/apriaaaa/article/details/103515301

版权

个人笔记专栏收录该内容

124 篇文章 0 订阅

订阅专栏

本文深入探讨Spring框架中Bean的生命周期，包括Bean的实例化、属性设置、初始化、使用及销毁等关键步骤。同时介绍了如何利用init-method和destroy-method进行自定义初始化和销毁操作，以及Bean后置处理器的作用。

摘要由CSDN通过智能技术生成

spring bean 主要包括

一个bean容器即-

//1.创建Spring IOC 容器对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");

bean 的生命周期

定义- 在spring的配置文件中配置bean
初始化-程序启动的时候读取spring 的配置文件加载bean的配置，生成bean 的实例
使用- 开发中从Spring的容器中取出bean的实例并使用
销毁- 在bean容器停止的时候，销毁所有由这个spring 的bean容器创建的bean

初始化

销毁

配置全局的初始化与销毁方式

在IoC容器启动之后，并不会马上就实例化相应的bean，此时容器仅仅拥有所有对象的BeanDefinition(BeanDefinition：是容器依赖某些工具加载的XML配置信息进行解析和分析，并将分析后的信息编组为相应的BeanDefinition)。只有当getBean()调用时才是有可能触发Bean实例化阶段的活动

为什么说有可能触发Bean实例化阶段？

因为当对应某个bean定义的getBean()方法第一次被调用时，不管是显示的还是隐式的，Bean实例化阶段才会被触发，第二次被调用则会直接返回容器缓存的第一次实例化完的对象实例(因为默认是singleton单例，当然，这里的情况prototype类型的bean除外)

一、Bean的一生过程

可以简述为以下九步

    实例化bean对象(通过构造方法或者工厂方法)
    设置对象属性(setter等)（依赖注入）
    如果Bean实现了BeanNameAware接口，工厂调用Bean的setBeanName()方法传递Bean的ID。（和下面的一条均属于检查Aware接口）
    如果Bean实现了BeanFactoryAware接口，工厂调用setBeanFactory()方法传入工厂自身
    将Bean实例传递给Bean的前置处理器的postProcessBeforeInitialization(Object bean, String beanname)方法
    调用Bean的初始化方法
    将Bean实例传递给Bean的后置处理器的postProcessAfterInitialization(Object bean, String beanname)方法
    使用Bean
    容器关闭之前，调用Bean的销毁方法

package beanLife;

import org.springframework.beans.factory.BeanNameAware;

/**
 * @author LinJie
 * @Description:一个学生类(Bean)，能体现其生命周期的Bean
 */
public class Student implements BeanNameAware {
	private String name;

	//无参构造方法
	public Student() {
		super();
	}

	/** 设置对象属性
	 * @param name the name to set
	 */
	public void setName(String name) {
		System.out.println("设置对象属性setName()..");
		this.name = name;
	}
	
	//Bean的初始化方法
	public void initStudent() {
		System.out.println("Student这个Bean：初始化");
	}
	
	//Bean的销毁方法
	public void destroyStudent() {
		System.out.println("Student这个Bean：销毁");
	}
	
	//Bean的使用
	public void play() {
		System.out.println("Student这个Bean：使用");
	}

	/* 重写toString
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return "Student [name = " + name + "]";
	}

	//调用BeanNameAware的setBeanName()
	//传递Bean的ID。
	@Override
	public void setBeanName(String name) {
		System.out.println("调用BeanNameAware的setBeanName()..." ); 
	}
	
}

package beanLife;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 测试类
 * @author LinJie
 * 
 */
public class CycleTest {
    @Test
 	public void test() {
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		Student student = (Student) context.getBean("student");
		//Bean的使用
		student.play();
		System.out.println(student);
		//关闭容器
		((AbstractApplicationContext) context).close();
	}
}

<?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">
 
   <!-- init-method：指定初始化的方法
        destroy-method：指定销毁的方法 -->
		<bean id="student" class="com.linjie.cycle.Student" init-method="initStudent" destroy-method="destroyStudent">
		<property name="name" value="LINJIE"></property>
		</bean>
</beans>

init-method：指定初始化的方法
destroy-method：指定销毁的方法

#####说到init-method和destroy-method，当然也要提及一下在< beans>的属性

default-init-method：为应用上下文中所有的Bean设置了共同的初始化方法
default-destroy-method：为应用上下文中所有的Bean设置了共同的销毁方法

二、Bean的后置处理器

上面bean的一生其实已经算是对bean生命周期很完整的解释了，然而bean的后置处理器，是为了对bean的一个增强

用法

分别在Bean的初始化前后对Bean对象提供自己的实例化逻辑

- 实现BeanPostProcessor接口
	- postProcessBeforeInitialization方法
	- postProcessAfterInitialization方法

package beanLife;

import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

/**
 * @author LinJie
 * @Description:一个学生类(Bean)，能体现其生命周期的Bean
 */
public class Student implements  InitializingBean, DisposableBean,BeanNameAware {
	private String name;

	//无参构造方法
	public Student() {
		super();
	}

	/** 设置对象属性
	 * @param name the name to set
	 */
	public void setName(String name) {
		System.out.println("设置对象属性setName().."+name);
		this.name = name;
	}
	
	//Bean的初始化方法
	public void initStudent() {
		System.out.println("Student这个Bean：初始化");
	}
	
	//Bean的销毁方法
	public void destroyStudent() {
		System.out.println("Student这个Bean：销毁");
	}
	
	//Bean的使用
	public void play() {
		System.out.println("Student这个Bean：使用");
	}

	/* 重写toString
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return "Student [name = " + name + "]";
	}

	@Override
	public void destroy() throws Exception {
		System.out.println(" 接口-destroy");
	}

	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println(" 接口-afterPropertiesSet");
	}

//	调用BeanNameAware的setBeanName()
//	传递Bean的ID。
	@Override
	public void setBeanName(String name) {
		System.out.println("调用BeanNameAware的setBeanName()..." );
	}

}

package beanLife;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * bean的后置处理器
 * 分别在bean的初始化前后对bean对象提供自己的实例化逻辑
 * postProcessAfterInitialization：初始化之后对bean进行增强处理
 * postProcessBeforeInitialization：初始化之前对bean进行增强处理
 * @author LinJie
 * 
 */
public class MyBeanPostProcessor implements BeanPostProcessor {

	//对初始化之后的Bean进行处理
	//参数：bean：即将初始化的bean
	//参数：beanname：bean的名称
	//返回值：返回给用户的那个bean,可以修改bean也可以返回一个新的bean
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanname) throws BeansException {
		Student stu = null;
		System.out.println("对初始化之后的Bean进行处理,将Bean的成员变量的值修改了");
		if("name".equals(beanname) || bean instanceof Student) {
			stu = (Student) bean;
			stu.setName("Jack");
		}
		return stu;
	}

	//对初始化之前的Bean进行处理
	//参数：bean：即将初始化的bean
	//参数：beanname：bean的名称
	//返回值：返回给用户的那个bean,可以修改bean也可以返回一个新的bean
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanname) throws BeansException {
		System.out.println("对初始化之前的Bean进行处理,此时我的名字"+bean);
		return bean;
	}

}

<?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">
    <!-- init-method：指定初始化的方法
           destroy-method：指定销毁的方法 -->
    <bean id="student" class="beanLife.Student" init-method="initStudent" destroy-method="destroyStudent">
        <property name="name" value="LINJIE"></property>
    </bean>

    <!-- 配置bean的后置处理器,不需要id，IoC容器自动识别是一个BeanPostProcessor -->
    <bean class="beanLife.MyBeanPostProcessor"></bean>

</beans>