spring学习-第三讲-bean的生命周期

前言

bean的生命周期，说简单点，无非就是实例化，依赖注入，初始化，销毁四个步骤，中间配合了众多的processor来对现有的功能进行扩展。就像AOP这些，便是依赖于某一个BeanPostProcessor来实现的，通过代码来看看流程吧。

代码编写

主类（创建容器并从容器中获取元素的操作）

package com.bo.beanfactoryapplicationcontextstudy.lifeCycle;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Auther: zeroB
 * @Date: 2023/4/4 15:25
 * @Description: bean生命周期，我需要带着问题去看，生命周期的过程
 * 实例化，依赖注入，初始化，销毁，并且整合postProcessor中
 */
public class Lifecycle {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(TestBeanPostProcessor.class);
        context.register(TestBean.class);
        context.register(SecondTestBean.class);
        context.refresh();


        TestBean testBean = (TestBean)context.getBean("testBean");
        System.out.println(testBean);

        context.destroy();

    }

}

定义的TestBean(从这个bean上看spring生命周期流程)

package com.bo.beanfactoryapplicationcontextstudy.lifeCycle;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;

/**
 * @Auther: zeroB
 * @Date: 2023/4/4 15:33
 * @Description: 测试bean对象，我想在这个类中体现出实例化，依赖注入，初始化三个过程
 */
//configyration注解，用来定义扫描类的位置，我这里会使用注解容器，暂时不需要它
//@Configuration
@Slf4j
public class TestBean implements InitializingBean {

    private String name;

    private int age;

    private String address;

    @Resource
    private SecondTestBean secondTestBean;

    public TestBean(){
        System.out.println("TestBean构造方法执行");
    }


    public SecondTestBean getSecondTestBean() {
        return secondTestBean;
    }

    public void setSecondTestBean(SecondTestBean secondTestBean) {
        log.info("SecondTestBean被依赖注入进来");
        this.secondTestBean = secondTestBean;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }


    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("对这个对象进行初始化操作，依赖注入之后");
        this.setAge(100000);
    }

    @PostConstruct
    public void after(){
        System.out.println("执行初始化之后的方法，虽然这个注解翻译是实例化之后，但实际是初始化之后");
    }

    @PreDestroy
    public void beforeDestory(){
        System.out.println("销毁对象之前要执行这步");
    }

    @Override
    public String toString() {
        return "TestBean{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                ", secondTestBean=" + secondTestBean +
                '}';
    }
}

在上面类中依赖注入的Bean

package com.bo.beanfactoryapplicationcontextstudy.lifeCycle;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * @Auther: zeroB
 * @Date: 2023/4/4 15:43
 * @Description: 第二个测试Bean，试试依赖注入
 */
@Component
@Slf4j
public class SecondTestBean {

    public SecondTestBean(){
        log.info("SecondTestBean构造方法已经完成");
    }
    
}

自定义的BeanPostProcessor，观察其在生命周期的流程

package com.bo.beanfactoryapplicationcontextstudy.lifeCycle;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * @Auther: zeroB
 * @Date: 2023/4/4 15:47
 * @Description: BeanPostProcessor，这个怎么和现有的bean整合起来呢
 *
 */
@Slf4j
public class TestBeanPostProcessor implements BeanPostProcessor {

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        log.info("bean对象在初始化前调用processor方法");
        return bean;
    }


    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        log.info("bean对象在初始化后调用了processor方法");
        return bean;
    }

}

分析

先看看打印后的结果。

Connected to the target VM, address: '127.0.0.1:61401', transport: 'socket'
17:11:23.820 [main] DEBUG org.springframework.context.annotation.AnnotationConfigApplicationContext - Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@185d8b6
17:11:23.844 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.annotation.internalConfigurationAnnotationProcessor'
17:11:23.906 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.event.internalEventListenerProcessor'
17:11:23.910 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.event.internalEventListenerFactory'
17:11:23.912 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.annotation.internalAutowiredAnnotationProcessor'
17:11:23.915 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.annotation.internalCommonAnnotationProcessor'
17:11:23.921 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'testBeanPostProcessor'
17:11:23.932 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'testBean'
TestBean构造方法执行
17:11:23.951 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'secondTestBean'
17:11:23.951 [main] INFO com.bo.beanfactoryapplicationcontextstudy.lifeCycle.SecondTestBean - SecondTestBean构造方法已经完成
17:11:23.952 [main] INFO com.bo.beanfactoryapplicationcontextstudy.lifeCycle.TestBeanPostProcessor - bean对象在初始化前调用processor方法
17:11:23.952 [main] INFO com.bo.beanfactoryapplicationcontextstudy.lifeCycle.TestBeanPostProcessor - bean对象在初始化后调用了processor方法
17:11:23.954 [main] INFO com.bo.beanfactoryapplicationcontextstudy.lifeCycle.TestBeanPostProcessor - bean对象在初始化前调用processor方法
执行初始化之后的方法，虽然这个注解翻译是实例化之后，但实际是初始化之后
对这个对象进行初始化操作，依赖注入之后
17:11:23.954 [main] INFO com.bo.beanfactoryapplicationcontextstudy.lifeCycle.TestBeanPostProcessor - bean对象在初始化后调用了processor方法
TestBean{name='null', age=100000, address='null', secondTestBean=com.bo.beanfactoryapplicationcontextstudy.lifeCycle.SecondTestBean@d6e7bab}
17:11:23.997 [main] DEBUG org.springframework.context.annotation.AnnotationConfigApplicationContext - Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@185d8b6, started on Tue Apr 04 17:11:23 CST 2023
销毁对象之前要执行这步
Disconnected from the target VM, address: '127.0.0.1:61401', transport: 'socket'

Process finished with exit code 0
 

 把源码中加载的BeanPostProcessor中的打印信息忽略，得到如下的结果

TestBean构造方法执行

SecondTestBean构造方法已经完成

-- 这个是SecondTestBean执行的BeanPostProcessor

bean对象在初始化前调用processor方法

bean对象在初始化后调用了processor方法

-- 这个是TestBean执行的BeanPostProcessor

bean对象在初始化前调用processor方法

执行初始化之后的方法，虽然这个注解翻译是实例化之后，但实际是初始化之后
对这个对象进行初始化操作，依赖注入之后

初始化后调用了processor方法

销毁对象之前要执行这步

在这里发现了一个问题，依赖注入的打印没有输出，意味着TestBean中的secondTestBean没有调用调用set方法，但toString打印，却成功注入到TestBean中。那么，这里的实际注入方式是什么呢？留个疑问。

我把依赖注入方式使用这种，可以成功访问了，那么注入的步骤在哪里呢？

@Autowired
    public void setSecondTestBean(SecondTestBean secondTestBean) {
        log.info("SecondTestBean被依赖注入进来");
        this.secondTestBean = secondTestBean;
    }

发现了，在这个位置，secondTestBean的beanPostProcessor执行完毕，TestBeanPostProcessor执行之前出现。

 总结

根据上面的流程，我这面就突然理顺了很多东西。

首先，bean的生命周期如下：

通过构造函数，对容器内所有注册的bean进行实例化。

如果对象没有依赖注入的内容，调用beanPostProcessor，在初始化方法前后执行。

对象中存在依赖注入的内容，先对对象进行依赖注入，然后执行beanPostProcessor的方法，并在中间执行@PostConstruct注解标识的方法以及初始化方法。

执行完成后随着容器的销毁调用@PreDestory的方法来在销毁前执行一些东西。

在之前我说了，AOP是依赖BeanPostProcessor来实现的，按照上面的流程，可以理解了，SecondTestBean在BeanPostProcessor执行完后，才会依赖注入到TestBean对象中。这样也就意味着，我们动态代理生成的AOP对象才是真正的注入对象。

我目前使用了AnnotationConfigApplicationContext这种容器来实现的，这种我扫描的是class类对象。xml之类的用另外的。但容器似乎本身并不带有自动扫描功能，自动扫描在哪，带着疑问看看后续的学习。