Bean的生命周期分析

Java小胡

于 2024-08-30 13:41:25 发布

阅读量773

点赞数 10

文章标签： java mysql Spring bean

本文链接：https://blog.csdn.net/weixin_42131843/article/details/141716107

版权

一：Bean的生命周期

什么是Bean的生命周期
（1）Spring其实就是一个管理Bean对象的工厂，它负责对象的创建，对象的销毁等。

（2）所谓的生命周期就是：对象从创建开始到最终销毁的整个过程。

（3）为什么要知道Bean的生命周期？

生命周期的本质是：在哪个时间节点上调用了哪个类的哪个方法？我们需要充分的了解在这个生命线上，都有哪些特殊的时间节点！只有我们知道了特殊的时间节点都在哪，到时我们才可以确定代码写到哪。我们可能需要在某个特殊的时间点上执行一段特定的代码，这段代码就可以放到这个节点上；当生命线走到这里的时候，自然会被调用。

（4）下面我会按照由浅入深，按照5步、7步、10步法，讲解Bean的生命周期！

Bean的生命周期之五步分析法
（1）Bean生命周期的管理，可以参考Spring的源码：AbstractAutowireCapableBeanFactory类的doCreateBean()方法。

（2）Bean生命周期可以粗略的划分为五大步：

第一步：实例化Bean
第二步：Bean属性赋值
第三步：初始化Bean
第四步：使用Bean
第五步：销毁Bean

编写测试程序：

Bean的生命周期按照粗略的五步的话：

第一步：实例化Bean（调用无参数构造方法）
第二步：给Bean属性赋值（调用set方法）
第三步：初始化Bean（会调用Bean的init方法。注意：这个init方法需要自己写）
第四步：使用Bean
第五步：销毁Bean（会调用Bean的destroy方法。注意：这个destroy方法需要自己写）

定义一个Bean

package com.bjpowernode.spring.bean;

public class User {
private String username;

public void setUsername(String username) {
    System.out.println("第二步：给对象的属性赋值");
    this.username = username;
}

public User() {
    System.out.println("第一步：实例化Bean，无参数构造方法执行了");
}

// 初始化Bean，需要自己写，自己配，方法名随意
public void initBean(){
    System.out.println("第三步：初始化Bean");
}

// 销毁Bean，需要自己写，自己配，方法名随意
public void destroyBean(){
    System.out.println("第五步：销毁Bean");
}

@Override
public String toString() {
    return "User{" +
            "username='" + username + '\'' +
            '}';
}

}

spring.xml配置

需要在标签中调用init-method和destroy-method属性，手动指定初始化方法和销毁方法！

<?xml version="1.0" encoding="UTF-8"?>

<bean id="user" class="com.bjpowernode.spring.bean.User"
      init-method="initBean" destroy-method="destroyBean">
      <!--给属性赋值-->
     <property name="username" value="张三"/>
</bean>

测试程序

①需要手动关闭Spring容器（调用close方法），这样Spring容器才会销毁Bean，才会去调用我们定义的destroyBean方法！
② 注意：只有ApplicationContext的实现类ClassPathXmlApplicationContext有close方法，ApplicationContext没有，所以需要强制类型转换；然后调用close方法！

package com.bjpowernode.spring.test;

import com.bjpowernode.spring.bean.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanLifecycleTest {
@Test
public void testBeanLifeCycleFive(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(“spring.xml”);
User user = applicationContext.getBean(“user”, User.class);
System.out.println(“第四步：使用Bean”+user);

    // 需要手动关闭Spring容器
    ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
    context.close();
}

}

执行结果：从这里我们也可看出执行的顺序

总结要点：

第一：只有正常关闭spring容器(调用close方法)，bean的销毁方法才会被调用。

第二：ClassPathXmlApplicationContext类才有close()方法，ApplicationContext中没有。

第三：配置文件中的init-method指定初始化方法，destroy-method指定销毁方法。

Bean生命周期之七步分析法
（1）在以上的5步中，第3步是初始化Bean，如果你还想在初始化前和初始化后添加代码，可以加入“Bean后处理器”；需要编写一个类实现BeanPostproccessor接口，并重写里面的befor和after方法。

（2）Bean生命周期可以细化为七大步：

第一步：实例化Bean
第二步：Bean属性赋值
第三步：执行“Bean后处理器”的before方法
第四步：初始化Bean
第五步：执行“Bean后处理器”的after方法
第六步：使用Bean
第七步：销毁Bean

编写一个类实现BeanPostProcessor类，并且重写before和after方法

注意：方法中有两个参数：

①第一个参数是创建的Bean对象！

②第二个参数是Bean的名字！

package com.bjpowernode.spring.test;

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

public class LogBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println(“Bean后处理器的before方法执行，即将开始初始化”);
return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
}

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    System.out.println("Bean后处理器的after方法执行，已完成初始化");
    return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
}

}

在spring.xml文件中配置“Bean后处理器”

注意：在spring.xml文件中配置的Bean后处理器将作用于当前配置文件中所有的Bean！

<?xml version="1.0" encoding="UTF-8"?>

<bean id="user" class="com.bjpowernode.spring.bean.User"
      init-method="initBean" destroy-method="destroyBean">
      <!--给属性赋值-->
     <property name="username" value="张三"/>
</bean>

<!--配置Bean后处理器。这个后处理器将作用于当前配置文件中所有的bean。-->
<bean class="com.bjpowernode.spring.bean.LogBeanPostProcessor"/>

执行测试程序：

Bean生命周期之十步分析法
Bean生命周期十步：比七步添加的那三步在哪里？

（1）在“Bean后处理器”before方法之前干了什么事儿？
检查Bean是否实现了Aware相关的接口，如果实现了接口则调用这些接口中的方法；调用这些方法的目的是为了给你传递一些数据，让你更加方便使用。

（2）在“Bean后处理器”before方法之后干了什么事儿？
检查Bean是否实现了InitializingBean接口，如果实现了，则调用接口中的方法。

（3）使用Bean之后，或者说销毁Bean之前干了什么事儿？
检查Bean是否实现了DisposableBean接口，如果实现了，则调用接口中的方法。

总结：添加的这三个点位的特点，都是在检查你这个Bean是否实现了某些特定的接口，如果实现了这些接口，则Spring容器会调用这个接口中的方法！

Aware相关的接口包括：BeanNameAware、BeanClassLoaderAware、BeanFactoryAware

①当Bean实现了BeanNameAware，Spring会将Bean的名字传递给Bean。

②当Bean实现了BeanClassLoaderAware，Spring会将加载该Bean的类加载器传递给Bean。

③当Bean实现了BeanFactoryAware，Spring会将Bean工厂对象传递给Bean。

测试以上10步，可以让User类实现5个接口，并实现所有方法：

①BeanNameAware

②BeanClassLoaderAware

③BeanFactoryAware

④InitializingBean

⑤DisposableBean

User类

package com.bjpowernode.spring.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;

public class User implements
BeanNameAware, BeanClassLoaderAware, BeanFactoryAware,
InitializingBean, DisposableBean{
private String username;

public void setUsername(String username) {
    System.out.println("第二步：给对象的属性赋值");
    this.username = username;
}

public User() {
    System.out.println("第一步：实例化Bean，无参数构造方法执行了");
}

// 初始化Bean，需要自己写，自己配，方法名随意
public void initBean(){
    System.out.println("第四步：初始化Bean");
}

// 销毁Bean，需要自己写，自己配，方法名随意
public void destroyBean(){
    System.out.println("第七步：销毁Bean");
}

@Override
public String toString() {
    return "User{" +
            "username='" + username + '\'' +
            '}';
}

@Override
public void setBeanClassLoader(ClassLoader classLoader) {
    System.out.println("类加载器：" + classLoader);
}

@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    System.out.println("Bean工厂：" + beanFactory);
}

@Override
public void setBeanName(String name) {
    System.out.println("Bean的名字：" + name);
}

@Override
public void destroy() throws Exception {
    System.out.println("DisposableBean destroy方法执行了");
}

@Override
public void afterPropertiesSet() throws Exception {
    System.out.println("InitializingBean afterPropertiesSet方法执行了");
}

}

执行结果：

总结：

①InitializingBean的方法早于init-method的执行。

②DisposableBean的方法早于destroy-method的执行。

Bean的scop（作用域）不同，管理方式不同
Spring 根据Bean的作用域来选择管理方式！

（1）对于singleton（单例）作用域的Bean：Spring 能够精确地知道该Bean何时被创建，何时初始化完成，以及何时被销毁。

（2）而对于 prototype（多例/原型）作用域的 Bean：Spring 只负责创建，当容器创建了 Bean 的实例后，Bean 的实例就交给客户端代码管理，Spring 容器将不再跟踪其生命周期。

把spring.xml配置文件当中scop属性的singleton改成property

再次执行测试程序：

当是多例的实际上只有前8步了，对于后两步的：检查Bean是否实现了DisposableBean接口和销毁Bean就不管了！

自己new的对象如何让Spring管理
有些时候可能会遇到这样的需求，某个java对象是我们自己手动new的，然后我们希望这个对象被Spring容器管理，怎么实现呢？

Student类

package com.bjpowernode.spring.bean;

public class Student {
}
进行测试：

第一步：创建DefaultListableBeanFactory对象！

第二步：注册Bean，调用这个对象的registerSingleton()方法，把自己创建的对象传进去，并起一个名字！

第三步：根据名字，调用getBean方法从Spring容器当中获取Bean对象！

package com.bjpowernode.spring.test;

import com.bjpowernode.spring.bean.Student;
import com.bjpowernode.spring.bean.User;
import org.junit.Test;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanLifecycleTest {

@Test
public void testBeanRegister(){
    // 自己new的对象，没有被Spring管理
    Student student = new Student();
    System.out.println(student);
    // 创建DefaultListableBeanFactory对象
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    // 调用registerSingleton方法注册Bean
    factory.registerSingleton("studentBean",student);
    // 从Spring容器当中取出Bean
    Student studentBean = factory.getBean("studentBean", Student.class);
    System.out.println(studentBean);

}

}

执行结果：

获取到的是同一个Bean对象，说明确实是把我们创建的对象放到Spring容器当中进行管理！

Java小胡

关注

10
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
Bean的生命周期分析

（2）而对于 prototype（多例/原型）作用域的 Bean：Spring 只负责创建，当容器创建了 Bean 的实例后，Bean 的实例就交给客户端代码管理，Spring 容器将不再跟踪其生命周期。总结：添加的这三个点位的特点，都是在检查你这个Bean是否实现了某些特定的接口，如果实现了这些接口，则Spring容器会调用这个接口中的方法！①需要手动关闭Spring容器（调用close方法），这样Spring容器才会销毁Bean，才会去调用我们定义的destroyBean方法！
复制链接

扫一扫