Spring之IOC中Bean的生命周期(二)

一.Bean的生命周期

过程: 指bean的创建——初始化——销毁的过程。

bean的创建跟初始化销毁的几种方式:

①.指定初始化和销毁方法 <之前在beanx.xml, 可以指定init-method和destory-mothod>

用注释如何做: 新建Bike.java

public class Bike {
	public Bike(){
		System.out.println("Bike constructor..............");
	}
	public void init(){
		System.out.println("Bike .....init.....");
	}
	public void destory(){
		System.out.println("Bike.....destory");
	}
}

***指定***初始化和销毁方法在配置类里通过@Bean(initMethod=“init”, destroyMethod=“destroy”)指定

@ComponentScan("com.enjoy.cap7.bean")
@Configuration
public class Cap7MainConfigOfLifeCycle {
	@Bean("person")
	public Person person(){
		System.out.println("给容器中添加person.......");
		return new Person("person",20);
	}
	@Bean(initMethod="init", destroyMethod="destory")
	public Bike bike(){
		return new Bike();
	}
}

2)让Bean实现 InitializingBean 和 DisposableBean接口

A, InitializingBean(定义初始化逻辑,可点进去看此类):afterPropertiesSet()方法:当beanFactory创建好对象,且把bean所有属性设置好之后,会调这个方法,相当于初始化方法

B, DisposableBean(定义销毁逻辑,可点进去看此类):destory()方法,当bean销毁时,会把单实例bean进行销毁

操作步骤:

2.1> 新建Train.java类, 实现 InitializingBean, DisposableBean 接口

@Component
public class Train implements InitializingBean, DisposableBean{

	public Train(){
		System.out.println("Train......constructor............");
	}
	//当我们bean销毁时,调用此方法
	@Override
	public void destroy() throws Exception {
		System.out.println("Train......destory......");
		//logger.error
	}
	//当我们的bean属性赋值和初始化完成时调用
	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println("Train.......afterPropertiesSet()...");
	}
}

可以使用JSR250规则定义的(java规范)两个注解来实现

@PostConstruct: 在Bean创建完成,且属于赋值完成后进行初始化,属于JDK规范的注解

@PreDestroy: 在bean将被移除之前进行通知, 在容器销毁之前进行清理工作

步骤:新建Jeep.java

@Component
public class Plane implements ApplicationContextAware{
	private ApplicationContext applicationContext;
	public Plane(){
		System.out.println("Plane.....constructor........");
	}
	@PostConstruct
	public void init(){
		System.out.println("Plane.....@PostConstruct........");
	}
	
	@PreDestroy
	public void destory(){
		System.out.println("Plane.....@PreDestroy......");
	}
	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		//将applicationContext传进来,可以拿到
		this.applicationContext = applicationContext;
	}
}

说明:只有以上三种:

***BeanPostProcessor***类[interface]: bean的后置处理器,在bean初始化之前调用进行拦截

作用:在bean初始化前后进行一些处理工作, 打开此类

a> postProcessBeforeInitialization():在初始化之前进行后置处理工作(在init-method之前),

什么时候调用:它任何初始化方法调用之前(比如在InitializingBean的afterPropertiesSet初始化之前,或自定义init-method调用之前使用)

b> postProcessAfterInitialization():在初始化之后进行后置处理工作, 比如在InitializingBean的afterPropertiesSet()

步骤: 新建后置处理器类JamesBeanPostProcessor

@Component
public class JamesBeanPostProcessor implements BeanPostProcessor{
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		//返回一个的对象(传过来的对象)
		//在初始化方法调用之前进行后置处理工作,
		//什么时候调用它: init-method=init之前调用
		System.out.println("postProcessBeforeInitialization...."+beanName+"..."+bean);
		return bean;
	}
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("postProcessAfterInitialization...."+beanName+"..."+bean);
		return bean;
	}
}

BeanPostProcessor的原理如下:

可从容器类跟进顺序为:

AnnotationConfigApplicationContext–>refresh()–>

finishBeanFactoryInitialization(beanFactory)—>

beanFactory.preInstantiateSingletons()–>

760行getBean(beanName)—>

199行doGetBean(name, null, null, false)–>

317行createBean(beanName, mbd, args)–>

501行doCreateBean(beanName, mbdToUse, args)–>

541行createBeanInstance(beanName, mbd, args)(完成bean创建)–>

578行populateBean(beanName, mbd, instanceWrapper)(属性赋值)–>

579行initializeBean(beanName, exposedObject, mbd)(Bean初始化)->

1069行到1710行,后置处理器完成对init方法的前后处理.

最终得到如下如下

createBeanInstance(beanName, mbd, args)(完成bean创建)

populateBean(beanName, mbd, instanceWrapper); 给bean进行属性赋值

initializeBean() //初始化Bean方法内容如下,后置处理器对init方法的前后处理

{

applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

invokeInitMethods(beanName, wrappedBean, mbd) //执行自定义初始化

applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)

}

从以上分析不难发现,bean的生命周期为bean的创建, 初始化, 当容器关闭时对单实例的bean进行销毁.

BeanPostProcessor的原理后面再IOC的创建流程会分析。

二,Spring底层对BeanPostProcessoe的使用

在这里插入图片描述
1,ApplicationContextAwareProcessor实现分析:

此类帮我们组建IOC容器,跟进ApplicationContextAwareProcessor我们发现, 这个后置处理器其实就是判断我们的bean有没有实现ApplicationContextAware 接口,并处理相应的逻辑,其实所有的后置处理器原理均如此.

那么怎么组建呢? 只需要实现 ApplicationContextAware 接口

@Component
public class Plane implements ApplicationContextAware{
	private ApplicationContext applicationContext;
	public Plane(){
		System.out.println("Plane.....constructor........");
	}
	@PostConstruct
	public void init(){
		System.out.println("Plane.....@PostConstruct........");
	}
	@PreDestroy
	public void destory(){
		System.out.println("Plane.....@PreDestroy......");
	}
	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		//将applicationContext传进来,可以拿到
		this.applicationContext = applicationContext;
	}
}

重点:分析一下***ApplicationContextAwareProcessor***类的方法

在这里插入图片描述
a,在创建Plane对象,还没初始化之前, 先判断是不是实现了ApplicationContextAware接口,

如果是的话就调用invokeAwareInterfaces方法, 并给里面注入值;

b,进入invokeAwareInterfaces()方法,判断是哪个aware, 如果是ApplicationContextAware, 就将当前的bean转成ApplicationContextAware类型, 调用setApplicationContext(), 把IOC容器注入到Plane里去;

c,用debug调用; 测试用例打断点测试

d,也可看debug调用栈来分析;

注: debug可以打在ApplicationContextAwareProcessor处理器类的applyBeanPostProcessorsBeforeInitialization()方法里, 方便调试, 当bean为Plane类型时,F5跟进看, 最终在 InvokeAwareInterfaces()方法里返回我们的IOC容器applicationContext.

了解即可,处理器的原理和其它处理器一致.

当对象创建完,给bean赋值后,在WEB用得特别多;把页面提交的值进行校验

总结: Spring底层对BeanPostProcessor的使用, 包括bean的赋值, 注入其它组件, 生命周期注解功能,@Async, 等等

循环依赖的解决方式:

循环依赖步骤：

1）A类无参构造函数实例化后，设置三级缓存；

2）A类populateBean进行依赖注入，这里触发了B类属性的getBean操作；

3）B类无参构造函数实例化后，设置三级缓存；

4）B类populateBean进行依赖注入，这里触发了A 类属性的getBean操作；

5）A类之前正在实例化，singletonsCurrentlyInCreation集合中有已经有这个A类了，三级缓存里面也有了，所以这时候是从三级缓存中拿到的提前暴露的A实例，该实例还没有进行B类属性的依赖注入的，B类属性为空；

6）B类拿到了A的提前暴露实例注入到A类属性中了；

7）B类实例化已经完成，B类的实例化是由A类实例化中B属性的依赖注入触发的getBean操作进行的，现在B已经实例化，所以A类中B属性就可以完成依赖注入了，这时候A类B属性已经有值了；

8）B类A属性指向的就是A类实例堆空间，所以这时候B类A属性也会有值了。

原文链接：https://blog.csdn.net/weixin_46300935/article/details/104475788

一.Bean的生命周期

二,Spring底层对BeanPostProcessoe的使用

循环依赖的解决方式:

你可能也喜欢