Spring学习笔记之Bean的“出生入死”

什么是Bean的生命周期

Spring其实就是一个管理Bean对象的工厂。它负责对象的创建，对象的销毁等。

---

所谓的生命周期就是：对象从创建开始到最终销毁的整个过程。
什么时候创建Bean对象？
创建Bean对象的前后会调用什么方法？
Bean对象什么时候销毁（去世）？
Bean对象的销毁前后调用什么方法？

为什么要知道Bean的生命周期

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

Bean的生命周期之五个阶段

Bean生命周期的管理，可以参考Spring的源码：
AbstractAutowireCapableBeanFactory类的doCreateBean（）方法。

---

Bean的出生入死大概可以分为五个阶段：

• 第一阶段：实例化Bean（小屁孩）
• 第二阶段：Bean属性赋值（少年）
• 第三阶段：初始化Bean（青年）
• 第四阶段：使用Bean（中年）
• 第五阶段：销毁Bean（老年）

---

package org.powernode;

public class User {
    private String name;
    public User(){
        System.out.println("1.小破孩Bean");
    }
    public void setName(String name){
        System.out.println("2.少年Bean");
    }
    public void initBean(){
        System.out.println("3.青年Bean");
    }
    public void destroyBean(){
        System.out.println("5.老年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">
        <bean id="userBean" class="org.powernode.User" init-method="initBean" destroy-method="destroyBean">
            <property name="name" value="gouba"/>
        </bean>
</beans>

//test
    @Test
    public void test(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        User userBean = applicationContext.getBean("userBean", User.class);
        System.out.println("4.中年Bean");
        ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
        context.close();
    }

---

注意：

• 只有正常关闭spring容器，bean的销毁方法才会被调用
• ClassPathXmlApplicationContext类才有close（）方法
• 配置文件中的init-method指定初始化方法。destroy-method指定销毁方法

Bean生命周期之七个阶段

在上面五个阶段中，第三个阶段是初始化Bean，如果还想在初始化前和初始化后添加代码，可以加入”Bean后处理器“

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

package com.powernode.spring6.bean;

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 bean;
    }

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

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

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

Bean生命周期的十个阶段

• 实例化Bean
• Bean属性赋值
• 检查Bean是否实现了Aware的相关接口，并设置相关依赖
• Bean后处理器before执行
• 检查Bean是否实现了InitializingBean接口，并调用接口方法
• 初始化Bean
• Bean后处理器after执行
• 使用Bean
• 检查Bean是否实现了DisposableBean接口，并调用接口方法
• 销毁Bean

---

检查Bean是否实现了Aware的相关接口是什么意思？
Aware相关的接口包括：BeanNameAware、BeanClassLoaderAware、BeanFactoryAware

• 当Bean实现了BeanNameAware，Spring会将Bean的名字传递给Bean。
• 当Bean实现了BeanClassLoaderAware，Spring会将加载该Bean1的类加载器传递给Bean。
• 当Bean实现了BeanFactoryAware，Spring会将Bean工厂对象传递给Bean。

---

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

• BeanNameAware
• BeanClassLoaderAware
• BeanFactoryAware
• InitializingBean
• DisposableBean

---

//User.java
package com.powernode.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执行");
    }
}

//LogBeanPostProcessor.java
package com.powernode.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;
    }
}

• InitializingBean的方法早于init-method的执行
• DisposbleBean的方法早于destroy-method的执行。

Bean的作用域不同，管理方式不同

Spring根据Bean的作用域来选择管理方式。

• 对于singleton作用域的Bean，Spring能够精确地知道该Bean何时被创建，何时初始化完成，以及何时被销毁。
• 而对于prototype作用域的Bean，Spring只负责创建，当容器创建了Bean的实例后，Bean的实例就交给客户端代码管理，Spring容器将不再跟踪其生命周期。

<!-- spring.xml -->
<?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="userBean" class="com.powernode.spring6.bean.User" init-method="initBean" destroy-method="destroyBean" scope="prototype">
        <property name="name" value="zhangsan"/>
    </bean>

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

</beans>

自己new的对象如何让Spring管理

有时候会遇到这样的需求，某个java对象是我们自己new的，然后希望这个对象被Spring容器管理，该如何实现

package com.powernode.spring6.bean;

public class User {
}

package com.powernode.spring6.test;

import com.powernode.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);
    }
}