前言
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之类的用另外的。但容器似乎本身并不带有自动扫描功能,自动扫描在哪,带着疑问看看后续的学习。