bean的生命周期以及实例化过程

最新推荐文章于 2024-05-08 15:24:52 发布

VIP文章 xxNGSun

最新推荐文章于 2024-05-08 15:24:52 发布

阅读量1.1k

点赞数 1

分类专栏： Spring 文章标签： java 容器 spring

本文链接：https://blog.csdn.net/xxNGchi/article/details/121914142

版权

bean的生命周期

实例化的触发

在这里插入图片描述

容器启动之后，并不会马上就实例化相应的bean定义。我们知道，容器现在仅仅拥有所有对象的 BeanDefinition来保存实例化阶段将要用的必要信息。只有通过BeanFactory的 getBean() 方法才会触发Bean 的实例化。

在BeanFactory中：

对象实例化默认采用延迟初始化

而在ApplicationContext中：

依然遵循Spring容器实现流程的两个阶段，只不过它会在启动阶段的活动完成之后，紧接着调用注册到该容器的所有bean定义的实例化方法 getBean()。这就是为什么当你得到ApplicationContext类型的容器引用时，容器内所有对象已经被全部实例化完成。

（第一次调用getBean触发触发实例化，三级缓存机制createBean，第二次会直接拿到实例）

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lCejCl1y-1639399780552)(C:\Users\55488\AppData\Roaming\Typora\typora-user-images\image-20211211105434494.png)]$

实例化过程中的一些重要概念

1.生成BeanWrapper

容器只要根据相应bean定义的BeanDefintion取得实例化信息，结合CglibSubclassingInstantiationStrategy以及不同的bean定义类型，就可以返回实例化完成的对象实例。但是，返回方式上有些“点缀”。不是直接返回构造完成的对象实例，而是以BeanWrapper对构造完成的对象实例进行包裹，返回相应的BeanWrapper实例

2.设置bean的属性

使用BeanWrapper对bean实例操作很方便（对象实例化完成并且相关属性以及依赖设置），可以免去直接使用Java反射API（Java Reflection API） 5 操作对象实例的烦琐。

//代码清单4-49 使用BeanWrapper操作对象
Object provider = Class.forName("package.name.FXNewsProvider").newInstance(); 
Object listener = Class.forName("package.name.DowJonesNewsListener").newInstance(); 
Object persister = Class.forName("package.name.DowJonesNewsPersister").newInstance(); 
BeanWrapper newsProvider = new BeanWrapperImpl(provider); 8 
newsProvider.setPropertyValue("newsListener", listener); 
newsProvider.setPropertyValue("newPersistener", persister); 
//下面不是实例化需要的方法，只是校验结果对不对
assertTrue(newsProvider.getWrappedInstance() instanceof FXNewsProvider); 
assertSame(provider, newsProvider.getWrappedInstance()); 
assertSame(listener, newsProvider.getPropertyValue("newsListener")); //判断两个对象是否是同一个，不是抛出异常
assertSame(persister, newsProvider.getPropertyValue("newPersistener"));

3.BeanPostProcessor

概念辨析：

BeanPostProcessor的概念容易与BeanFactoryPostProcessor的概念混淆。但只要记住BeanPostProcessor是存在于对象实例化阶段，而BeanFactoryPostProcessor则是存在于容器启动阶段

与BeanFactoryPostProcessor通常会处理容器内所有符合条件的BeanDefinition类似，BeanPostProcessor会处理容器内所有符合条件的实例化后的对象实例。

BeanPostProcessor：bean的后置处理器主要两个方法.(因为是在bean实例化后开始工作的，所以叫做后置处理器？)ApplicationContext中一共定义了9个BeanPostProcessor，其中8个分布在bean的实例化过程中，1个在销毁的时候。走完前8个，bean才算实例化完成，被进入单例池（SingletonObjects）。我们也可以自己定义。


public interface BeanPostProcessor 
{
    
    //注意我们这里拿到了bean实例的引用，可见这个时候bean已经从beanWrapper中生产完成了。
    //前置处理
 Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException; 
    //后置处理
 Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}

BeanPostProcessor的使用场景举例

ApplicationContext对应的那些Aware接口实际上就是通过BeanPostProcessor的方式进行处理。

class ApplicationContextAwareProcessor implements BeanPostProcessor {
   
	private final ConfigurableApplicationContext applicationContext;
	private final StringValueResolver embeddedValueResolver;
	/**
	 * Create a new ApplicationContextAwareProcessor for the given context.
	 */
	public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
   
		this.applicationContext = applicationContext;
		this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
	}

	@Override
	@Nullable
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
   
		if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
				bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
				bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
   
			return bean;
		}

		AccessControlContext acc = null;

		if (System.getSecurityManager() != null) {
   
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}

		if (acc != null) {
   
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
   
				invokeAwareInterfaces(bean);
				return null;
			}, acc);
		}
		else {
   
			invokeAwareInterfaces(bean);
		}

		return bean;
	}

	private void invokeAwareInterfaces(Object bean) {
   
		if (bean instanceof EnvironmentAware) {
   
			((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
		}
		if (bean instanceof EmbeddedValueResolverAware) {
   
			((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
		}
		if (bean instanceof ResourceLoaderAware) {
   
			((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
		}
		if (bean instanceof ApplicationEventPublisherAware) {
   
			((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
		}
		if (bean instanceof MessageSourceAware) {
   
			((MessageSourceAware) bean).setMessageSource(this.applicationContext);
		}
		if (bean instanceof ApplicationContextAware) {
   
			((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
		}
	}

}

bean的生命周期

（1）实例化Bean：

补充：通过第一次getBean（）调用，然后会先去解决这个bean需要依赖的bean最后实例化这个bean。在doCreateBean（）在完成主要的生命周期（1）（2）（3）（4）
在实例化的过程中主要步骤：根据RootBeanDefinition生成BeanWrapper，然后解决循环依赖的问题调用SmartInstantiationAwareBeanPostProcessor。然后进入（2）
对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。对于ApplicationContext容器，当容器启动结束后，通过获取BeanDefinition对象中的信息，实例化所有的bean。

（2）设置对象属性（依赖注入）：

补充：在popoluteBean（）方法中完成
实例化后的对象被封装在BeanWrapper对象中，紧接着，Spring根据BeanDefinition中的信息以及通过BeanWrapper提供的设置属性的接口完成依赖注入。

（3）处理Aware接口：

接着，Spring会检测该对象是否实现了xxxAware接口，并将相关的xxxAware实例注入给Bean：
如果这个Bean已经实现了BeanNameAware接口，会调用它实现的setBeanName(String beanId)方法，此处传递的就是Spring配置文件中Bean的id值；
如果这个Bean已经实现了BeanFactoryAware接口，会调用它实现的setBeanFactory()方法，传递的是Spring工厂自身。
如果这个Bean已经实现了ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，传入Spring上下文；

（4）BeanPostProcessor：

补充：这里调用的是自定义的后置处理器，前面已经进行很多次后置处理了
如果想对Bean进行一些自定义的处理，那么可以让Bean实现了BeanPostProcessor接口，那将会调用postProcessBeforeInitialization(Object obj, String s)方法。由于这个方法是在Bean初始化结束时调用的，所以可以被应用于内存或缓存技术；