1.BeanDefinition
2.构造函数
在此期间,调用Bean的构造函数,实例化对象 (但是还未赋值!)
3.依赖注入
Spring容器会将Bean的属性设置为Bean定义中指定的值。这个过程也被称为依赖注入,因为Spring容器会自动寻找并注入Bean所依赖的其他Bean。
4.Aware接口
用于增强Bean的功能
如果Bean实现了以Aware结尾的接口,就要重写里面的方法。图中三个接口,就是分别用于在Bean的初始化过程中,用于获取:Bean的名字、Bean的工厂、容器的上下文对象(Spring容器本身)。
5.BeanPostProcessor#before
bean的后置处理器,在初始化方法调用之前执行。
6.初始化方法
1.InitalizingBean接口,实现了该接口,就要实现里面的方法。而在这一步就会执行重写方法。
2.自定义init:在bean中某个方法上标注了@PostConstruct注解。就会在这一步执行这个方法。
7.BeanPostProcessor#before
bean的后置处理器,在初始化方法调用之后执行。
当一个类的功能被增强了使用到了AOP,大概率就是使用后置处理器被增强的。
8.销毁Bean
如果在哪个方法上标注了@PreDestroy方法,Spring容器在关闭前就会调用该方法。
注:
1.Bean的创建和初始化是分开的,第2步是创建bean,3-7是初始化赋值
2.第5步和第7步的两个后置处理器。都是某个类实现了BeanPostProcessor接口,所重写的两个方法。分别在初始化方法前后执行。
测试代码:
第一个类User类,作为我们测试的Bean
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
@Component
public class User implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean {
public User() {
System.out.println("1.User的构造方法执行了.........");
}
private String name;
@Value("张三")
public void setName(String name) {
System.out.println("2.依赖注入执行了..........");
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("3.BeanNameAware的实现方法执行了.......");
}
@Override
public void setBeanName(String s) {
System.out.println("3.BeanNameAware的实现方法执行了.......");
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("3.ApplicationContextAware的实现方法执行了.......");
}
@PostConstruct
public void init() {
System.out.println("5.自定义初始化方法执行了..........");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("5.InitializingBean的实现方法执行了..........");
}
@PreDestroy
public void destroy(){
System.out.println("7.destroy方法执行了.........");
}
}
第二个类:实现了BeanPostProcessor重写了其中方法的类。里面是两个后置处理器。
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (beanName.equals("user")) {
System.out.println("4.postProcessBeforeInitialization方法执行了 -> user对象初始化方法之前执行");
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (beanName.equals("user")) {
System.out.println("6.postProcessAfterInitialization方法执行了 -> user对象初始化方法之后执行");
}
return bean;
}
}
执行结果
destroy方法要在容器关闭时执行
总结:
1.首先会通过一个非常重要的类,叫做BeanDefinition 获取 bean 的定义信息, 这里面就封装了bean的所有信息,比如,类的全路径,是否是延迟加载,是否是单例等等这些信息。 2.在创建bean 的时候,第一步是调用构造函数实例化 bean 3.第二步是 bean 的依赖注入,比如一些 set 方法注入,像平时开发用的@Autowire都是这一步完成。 4.第三步是处理Aware 接口,如果某一个 bean 实现了 Aware 接口就会重写方法执行。 5.第四步是bean 的后置处理器 BeanPostProcessor ,这个是前置处理器。 6.第五步是初始化方法,比如实现了接口InitializingBean 或者自定义了方init-method标签或 @PostContruct。 7.第六步是执行了bean 的后置处理器 BeanPostProcessor ,主要是对 bean 进行增强,有可能在这里产生代理对象。 8.最后一步是销毁bean。 标签:生命周期,Spring,bean,springframework,Bean,org,import,public From: https://blog.csdn.net/qq_64064246/article/details/136810366