前言
在Java中，Bean是一个重要的概念，它代表了应用程序中的一个对象。在开发中，我们经常使用Bean来管理对象的生命周期。本文将介绍Bean的生命周期，并详细讲解如何在框架中管理Bean的生命周期。
1. 什么是Bean的生命周期？
其实就是一个管理Bean对象的工厂。它负责对象的创建，对象的销毁等。
所谓的生命周期就是：对象从创建开始到最终销毁的整个过程。为每个Bean定义了若干个回调方法，使得开发人员可以在某个特定的时间点对Bean进行特定的操作。
2. 为什么要知道Bean的生命周期？
其实生命周期的本质是：在哪个时间节点上调用了哪个类的哪个方法。
我们需要充分的了解在这个生命线上，都有哪些特殊的时间节点。
只有我们知道了特殊的时间节点都在哪，到时我们才可以确定代码写到哪。
我们可能需要在某个特殊的时间点上执行一段特定的代码，这段代码就可以放到这个节点上。当生命线走到这里的时候，自然会被调用。
3. Bean的生命周期之5步
Bean生命周期的管理，可以参考的源码：类的()方法。`
Bean生命周期可以粗略的划分为五大步：
第一步：实例化Bean
第二步：Bean属性赋值
第三步：初始化Bean
第四步：使用Bean
第五步：销毁Bean
编写测试程序：
定义一个Bean
package com.*.spring6.bean;
/**
* @author
* @version 1.0
* @className User
* @since 1.0
**/
public class User {
private String name;
public User() {
System.out.println("1.实例化Bean");
}
public void setName(String name) {
this.name = name;
System.out.println("2.Bean属性赋值");
}
public void initBean(){
System.out.println("3.初始化Bean");
}
public void destroyBean(){
System.out.println("5.销毁Bean");
}
}
package com.*.spring6.test;
import com.*.spring6.bean.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
* @author
* @version 1.0
* @className BeanLifecycleTest
* @since 1.0
**/
public class BeanLifecycleTest {
@Test
public void testLifecycle(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
User userBean = applicationContext.getBean("userBean", User.class);
System.out.println("4.使用Bean");
// 只有正常关闭spring容器才会执行销毁方法
ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
context.close();
}
}
执行结果：
需要注意的：
4. Bean的生命周期之7步
在以上的5步中，第3步是初始化Bean，如果你还想在初始化前和初始化后添加代码，可以加入“Bean后处理器”。
编写一个类实现类，并且重写和after方法：
package com.*.spring6.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
/**
* @author
* @version 1.0
* @className LogBeanPostProcessor
* @since 1.0
**/
public class LogBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("Bean后处理器的before方法执行，即将开始初始化");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("Bean后处理器的after方法执行，已完成初始化");
return bean;
}
}
在.xml文件中配置“Bean后处理器”：
一定要注意：在.xml文件中配置的Bean后处理器将作用于当前配置文件中所有的Bean。
执行测试程序：
如果加上Bean后处理器的话，Bean的生命周期就是7步了：
5. Bean的生命周期之10步
如果根据源码跟踪，可以划分更细粒度的步骤，10步：
上图中检查Bean是否实现了Aware的相关接口是什么意思？
Aware相关的接口包括：、、
当Bean实现了，会将Bean的名字传递给Bean。
当Bean实现了，会将加载该Bean的类加载器传递给Bean。
当Bean实现了，会将Bean工厂对象传递给Bean。
测试以上10步，可以让User类实现5个接口，并实现所有方法：
代码如下：
package com.*.spring6.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
/**
* @author
* @version 1.0
* @className User
* @since 1.0
**/
public class User implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {
private String name;
public User() {
System.out.println("1.实例化Bean");
}
public void setName(String name) {
this.name = name;
System.out.println("2.Bean属性赋值");
}
public void initBean(){
System.out.println("6.初始化Bean");
}
public void destroyBean(){
System.out.println("10.销毁Bean");
}
@Override
public void setBeanClassLoader(ClassLoader classLoader) {
System.out.println("3.类加载器：" + classLoader);
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("3.Bean工厂：" + beanFactory);
}
@Override
public void setBeanName(String name) {
System.out.println("3.bean名字：" + name);
}
@Override
public void destroy() throws Exception {
System.out.println("9.DisposableBean destroy");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("5.afterPropertiesSet执行");
}
}
//********************************************************
package com.*.spring6.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
/**
* @author
* @version 1.0
* @className LogBeanPostProcessor
* @since 1.0
**/
public class LogBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("4.Bean后处理器的before方法执行，即将开始初始化");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("7.Bean后处理器的after方法执行，已完成初始化");
return bean;
}
}
执行结果：
通过测试可以看出来：
的方法早于init-的执行。
的方法早于-的执行。
对于的生命周期，掌握之前的7步即可。够用。
6. Bean的作用域不同bean的生命周期，管理方式不同
根据Bean的作用域来选择管理方式。
对于作用域的Bean， 能够精确地知道该Bean何时被创建，何时初始化完成，以及何时被销毁；
而对于 作用域的Bean， 只负责创建，当容器创建了 Bean 的实例后，Bean 的实例就交给客户端代码管理， 容器将不再跟踪其生命周期。
把之前User类的.xml文件中的配置scope设置为：
执行测试程序：
通过测试一目了然。只执行了前8步，第9和10都没有执行。
7. 自己new的对象如何让管理
有些时候可能会遇到这样的需求bean的生命周期，某个java对象是我们自己new的，然后我们希望这个对象被容器管理，怎么实现？
package com.*.spring6.bean;
/**
* @author
* @version 1.0
* @className User
* @since 1.0
**/
public class User {
}
//*************************************
package com.*.spring6.test;
import com.*.spring6.bean.User;
import org.junit.Test;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
/**
* @author
* @version 1.0
* @className RegisterBeanTest
* @since 1.0
**/
public class RegisterBeanTest {
@Test
public void testBeanRegister(){
// 自己new的对象
User user = new User();
System.out.println(user);
// 创建 默认可列表BeanFactory 对象
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
// 注册Bean
factory.registerSingleton("userBean", user);
// 从spring容器中获取bean
User userBean = factory.getBean("userBean", User.class);
System.out.println(userBean);
}
}