描述
Bean 的生命周期,就是一个 Bean 从创建到销毁,所经历的各种方法调用。 简单的来说,一个Bean的生命周期分为四个阶段: 实例化(Instantiation)、 属性设置(populate)、初始化(Initialization)、销毁(Destruction)
注意 单例bean 和容器同生共死,多例bean才会被jvm 垃圾回收
实例化
程序启动后,Spring把注解或者配置文件定义好的Bean对象转换成一个BeanDefination对象,然后完成整个BeanDefination的解析和加载的过程。Spring获取到这些完整的对象之后,会对整个BeanDefination进行实例化操作,实例化是通过反射的方式创建对象。
属性设置
实例化后的对象被封装在BeanWrapper对象中,并且此时对象仍然是一个原生的状态,并没有进行依赖注入。Spring根据BeanDefinition中的信息进行依赖注入, populateBean方法来完成属性的注入。
初始化
- 调用Aware接口相关的方法:invokeAwareMethod(完成beanName, beanClassLoader, beanFactory对象的属性设置)
- 调用beanPostProcessor中的前置处理方法(applyBeanPostProcessorsBeforeInitialization)
- 调用InitMethod方法:invokeInitMethod(),判断是否实现了initializingBean接口,如果有,调用afterPropertiesSet方法,没有就不调用
- 调用BeanPostProcessor后置处理方法(applyBeanPostProcessorsAfterInitialization),Spring 的Aop就是在此处实现的
销毁
判断是否实现了DisposableBean接口,调用destoryMethod方法
代码验证
- bean的配置类
package com.tk.bean.config;
import com.tk.bean.entity.Book;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
* @author taoke
* @desc 实体类配置
* @date 2022/3/23
*/
@Configuration
public class BookConfig {
@Bean(initMethod = "myPostConstruct", destroyMethod = "myPreDestroy")
public Book getBook() {
Book book = new Book();
book.setBookName("水浒传");
return book;
}
}
- 实体类Book
package com.tk.bean.entity;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
/**
* @author taoke
* @desc 书
* @date 2022/3/21
*/
public class Book implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean {
private String bookName;
public String getBookName() {
return bookName;
}
public Book() {
System.out.println("构造方法执行了。。。。 ");
}
public void setBookName(String bookName) {
this.bookName = bookName;
System.out.println("设置属性执行了,书名是: " getBookName());
}
@Override
public void setBeanName(String name) {
System.out.println("setBeanName 方法执行了。。。");
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("setBeanFactory 方法执行了。。。");
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("setApplicationContext 方法执行了。。。");
}
//MyBeanPostProcessor.postProcessBeforeInitialization
@PostConstruct
public void springPostConstruct() {
System.out.println("@PostConstruct 执行了。。。");
}
@Override
public void afterPropertiesSet() {
System.out.println("afterPropertiesSet 执行了。。。");
}
public void myPostConstruct() {
System.out.println("自定义方法 myPostConstruct 执行了。。。");
}
//MyBeanPostProcessor.postProcessAfterInitialization
//Book name = thing king in java
@PreDestroy
public void springPreDestroy() {
System.out.println("@PreDestroy 方法执行了。。。");
}
@Override
public void destroy() {
System.out.println("destroy 方法执行了。。。");
}
public void myPreDestroy() {
System.out.println("自定义方法 myPreDestroy 执行了。。。 ");
}
}
BeanPostProcessor
代码语言:javascript复制package com.tk.bean.processor;
import com.tk.bean.entity.Book;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
/**
* @author taoke
* @desc 增强处理
* @date 2022/3/21
*/
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof Book) {
System.out.println("MyBeanPostProcessor 前置方法 postProcessBeforeInitialization 执行了。。。");
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof Book) {
System.out.println("MyBeanPostProcessor 后置方法 postProcessAfterInitialization 执行了。。。");
}
return bean;
}
}
- 启动类
package com.tk.bean;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* @author taoke
* @desc 启动类
* @date 2022/3/21
*/
@SpringBootApplication
public class BeanTestApplication {
public static void main(String[] args) {
SpringApplication.run(BeanTestApplication.class);
}
}
- 运行结果
小结
main方法启动后,Spring读@Bean注解,将注解修饰的对象加载到IOC容器,IOC容器将其转化为BeanDefination对象,并进行实例化,实例化后封装为BeanWrapper对象。然后Spring调用populateBean方法对BeanDefination对象进行属性填充,再调用initializeBean方法完成一些Aware操作,然后调用beanPostProcessor中的前置处理方法,如果实现了initializingBean,则调用afterPropertiesSet方法,然后调用BeanPostProcessor后置处理方法,Aop就是在此处实现的。处理完成后,bean就处于一个就绪状态,等待被调用。销毁时判断是否实现了DisposableBean接口,调用destoryMethod方法。