Spring得Bean生命周期
文章目录
- Spring得Bean生命周期
- 一、Spring生命周期
- 二、生命周期图解
- 二、源码
- 1.refresh()方法
- 2.finishBeanFactoryInitialization()方法
- 3.preInstantiateSingletons()方法
- 4.doGetBean()方法
- 5.getSingleton()方法
- 6.getSingleton(String beanName, ObjectFactory<?> singletonFactory)方法
- 7.createBean()方法
- 8.doCreateBean()方法
- 9.populateBean()方法
- 10.initializeBean()方法
- 三.如何解决循环依赖
- 1.什么是循环依赖
- 2.Spring是如何解决的
- 3.为什么使用二级缓存,只用一级缓存可以解决问题么
- 4.为什么用三级缓存
- 总结
一、Spring生命周期
1.读取配置文件,解析成Document对象,将Document对象封装为BeanDefinition对象,然后注册该对象,将Definition对象添加到beanDefinitionMap中,beanName添加到beanDefinitionNames中
2.实例化Bean,反射的方式生成对象
3.填充bena的属性:populateBean(),循环依赖的问题(三级缓存)
4.调用aware接口相关的方法:invokeAwareMethod(完成BeanName可以获取容器bean的名称,BeanFactory获取当前bean factory这也可以调用容器的服务,BeanClassLoader对象的属性设置)
5.调用BeanPostProcessor中的前置处理方法:使用比较多的有(ApplicationContextPostProcessor设置ApplicationContext,Environment,ResourceLoader,EmbeddValueResolver等对象)
6.调用initmethod方法:invokeInitmethod(),判断是否实现了InitializingBean接口,如果有,调用afterPropertiesSet方法,
7.调用BeanPostProcessor的后置处理方法:spring的aop就是在此处实现的,AbstractAutoProxyCreator,注册Destuction相关的回调接口
8.获取到完整的对象,可以通过getBean的方式来进行对象的获取
9.销毁流程 ①判断是否实现了DispoableBean接口②调用destroyMethod方法
二、生命周期图解
refresh方法图解
二、源码
1.refresh()方法
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
//前戏 做容器刷新前的准备工作
//1.设置容器的启动时间 2.设置活跃状态为true 3.设置关闭状态为false 4.获取Environment对象 加载当前系统的属性值到Environment对象中 5.准备监听器和事件的集合对象 默认为空集合
prepareRefresh();
// 创建容器对象:DefaultListableBeanFactory
//加载配置文件到工厂中 bean对象封装为BeanDefinition对象(很复杂的流程)
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//beanFactory的准备工作 对各种属性进行填充
prepareBeanFactory(beanFactory);
try {
//子类覆盖方法做额外的处理,此处我们自己一般不做任何扩展工作,但是可以看web的代码,有具体实现
postProcessBeanFactory(beanFactory);
//调用各种beanFactory处理器
invokeBeanFactoryPostProcessors(beanFactory);
//注册bean处理器,这里只是注册功能,真正调用的是getBean方法
registerBeanPostProcessors(beanFactory);
//为上下文初始化message源,即不同语言消息体,国际化处理
initMessageSource();
//初始化时间监听多播器
initApplicationEventMulticaster();
//留给子类来初始化其他bean 方便扩展,SpringBoot内嵌tomcat就是在这里实现的
onRefresh();
//在所有注册的bean中查找listener bean,注册到消息广播器中
registerListeners();
// 实例化剩下的单实例(非懒加载的)bean的声明周期(进行bean的对象创建工作,主要源码)
finishBeanFactoryInitialization(beanFactory);
// 完成刷新过程 通知生命周期处理器lifecycleProcessor刷新过程,同时发出ContextRefreshEvent通知别人
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
2.finishBeanFactoryInitialization()方法
代码如下(示例):
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 为上下文初始化类型转换器
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
//如果beanFactory之前没有注册嵌入值解析器,则注册默认的嵌入值解析器,主要用于注解属性值的解析
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
//尽早初始化loadTimeWeaverAware bean以便尽早注册他们的转换器
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
//禁止使用临时类加载器进行类型匹配
beanFactory.setTempClassLoader(null);
//冻结所有的bean定义,说明注册的bean定义将不被修改活任何进一步的处理
beanFactory.freezeConfiguration();
//实例化剩下的单例对象
beanFactory.preInstantiateSingletons();
}
3.preInstantiateSingletons()方法
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
//将所有beanDefinition的名字创建一个集合
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
//遍历集合对象 出发所有非延迟加载单例bean的初始化
for (String beanName : beanNames) {
//合并父类beanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//条件判断 抽象 单例 非懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//判断是否实现了FactoryBean接口
if (isFactoryBean(beanName)) {
//根据&+beanName来获取具体对象 beanName是获取具体容器对象 加&是获取FactoryBean对象
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
//普通bean获取
getBean(beanName);
}
}
}
//遍历beanNames 触发所有SmartInitializingSingleton的后初始化回调
for (String beanName : beanNames) {
//获取bean实例
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
4.doGetBean()方法
public Object getBean(String name) throws BeansException {
//此方法是实际获取bean的方法
return doGetBean(name, null, null, false);
}
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
//提前检查缓存中是否有手动注册的单例对象(循环依赖处理有关)
Object sharedInstance = getSingleton(beanName);
//如果找到了bean的单例对象 且没有创建bean实例时要使用的参数
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//返回对象的实例,
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 当对象都是单例的时候会尝试解决循环依赖的问题 但是原型模式下如果存在循环依赖的情况 直接抛出异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//如果bean定义不存在 就检查父工厂是否有
BeanFactory parentBeanFactory = getParentBeanFactory();
//如果beanDefinitionMap(已经加载的类)中不包含beanName,那么就尝试从父容器中获取
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 获取Name对应的规范名称(全类名)如果那么前面有‘&’则会返回‘&’+规范名称(全类名)
String nameToLookup = originalBeanName(name);
//如果父工厂是AbstractBeanFactory的实例
if (parentBeanFactory instanceof AbstractBeanFactory) {
//调用父工厂的doGetBean 递归
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
//使用父工厂获取bean 通过全类名
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
//如果不是做类型检查 那么表示要创建bean 此处在集合中做一个记录
if (!typeCheckOnly) {
//为beanName标记为已经创建(或将要创建)
markBeanAsCreated(beanName);
}
}
try {
//BeanDefinition对象转换,
//此处要做类型转换 如果子类是bean的话 会合并父类的相关属性
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//检查mbd的合法性 不合格抛出异常
checkMergedBeanDefinition(mbd, beanName, args);
// 如果存在依赖的bean的话 那么则优先实例化依赖的bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
//遍历实例化依赖的baen
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
//注册各个bean的依赖关系 方便进行销毁
registerDependentBean(dep, beanName);
try {
//递归优先实例化被依赖的bean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// 创建bean的实例对象 单例对象
if (mbd.isSingleton()) {
//返回beanName的单例对象 如果未注册 则使用singletonFactory创建并注册一个对象
sharedInstance = getSingleton(beanName, () -> {
try {
//为给定的合并后的BeanDefinition创建一个bean实例
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//原型模式
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
5.getSingleton()方法
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从一级缓存中加载 bean
Object singletonObject = this.singletonObjects.get(beanName);
// 缓存中的 bean 为空,且当前 bean 正在创建
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 从 二级缓存 获取,表示此bean正在创建,不进行后续处理
singletonObject = this.earlySingletonObjects.get(beanName);
// 二级缓存中没有,且允许提前创建
if (singletonObject == null && allowEarlyReference) {
// 从 三级缓存中获取
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
//实际上调用的是getEarlyBeanReference(beanName, mbd, bean)
singletonObject = singletonFactory.getObject();
//三级缓存中移除 加入到二级缓存中
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
6.getSingleton(String beanName, ObjectFactory<?> singletonFactory)方法
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
//保证线程同步
synchronized (this.singletonObjects) {
//从一级缓存中拿单例对象
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
//创建单例之前的回调 默认实现将单例注册为当前正在创建中
beforeSingletonCreation(beanName);
//表示生成了新的单例对象的标记 默认false
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//函数式接口 会调用createBean方法
singletonObject = singletonFactory.getObject();
//表示生成了单例对象
newSingleton = true;
}
catch (IllegalStateException ex) {
// 同时 单例对象是否隐式出现 如果是 请继续操作 因为异常表明该状态
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
//如果生成了新对象 则加入到一级缓存中
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
protected void addSingleton(String beanName, Object singletonObject) {
//创建对象成功后则将成品对象加入到一级缓存中 移除二级缓存和三级缓存
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
7.createBean()方法
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
// 根据bean定义信息和bean名称解析得到bean的Class类型
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
//验证并准备为此 bean 定义的方法覆盖
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
//给InstantiationAwareBeanPostProcessor后置处理器一个机会,返回代理对象用来替换目标bean实例
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
// 如果bean不为空的话,则直接返回,不执行下面的doCreateBean创建bean实例操作
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
//创建bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
//返回创建好的bean实例
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
8.doCreateBean()方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 如果是单例bean,尝试从未完成创建的包装Bean缓存(factoryBeanInstanceCache)中获取BeanWrapper(bean的包装类), 如果获取成功,还将清除这个缓存
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
// 如果缓存中不存在的话,则调用createBeanInstance创建一个BeanWrapper(bean的包装类)
if (instanceWrapper == null) {
// 完成bean的实例化的方法,根据指定bean使用的策略创建bean的实例,如工厂方法、构造方法自动注入、简单初始化
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 获取包装器里面刚创建好的bean实例
final Object bean = instanceWrapper.getWrappedInstance();
// 获取实例化对象的类型
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
// 允许后处理器修改合并的 bean 定义
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//应用合并后的BeanDefinition后置处理器:执行MergedBeanDefinitionPostProcessor后置处理器增强方法postProcessMergedBeanDefinition()
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
// 是否允许提前暴露bean对象(即半成品对象)
// earlySingletonExposure的值由三部分确定:单例bean && 允许循环依赖 && 当前bean正在创建中
// isSingletonCurrentlyInCreation(beanName)的作用:返回指定的单例 bean 当前是否正在创建中
// allowCircularReferences:是否允许循环依赖,默认为true
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
// 为避免循环依赖,可以在bean初始化完成前将创建实例的ObjectFactory加入工厂,将生成bean的工厂添加到三级缓存(singletonFactories)中
// 第二个参数同样是一个ObjectFactory,是一个函数式接口,当执行ObjectFactory的getObject()方法的时候,实际上执行的是getEarlyBeanReference(beanName, mbd, bean)
// getEarlyBeanReference(beanName, mbd, bean)的作用: 获取早期访问指定 bean 的引用
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//属性填充,对bean各个属性值进行注入,可能存在依赖于其它bean的属性,则会递归初始依赖的bean(循环依赖就在此进行)
populateBean(beanName, mbd, instanceWrapper);
//初始化Bean,如执行aware接口、执行init-method方法、BeanPostProcessor后置增强等等
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
// 如果允许早期暴露,需要进行循环依赖检查
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
// 能进入这里,说明Spring检测到发生了循环依赖
// exposedObject == bean:两者相等,说明bean在执行initializeBean()初始化的时候,没有被后置处理器增强,还是原来那个对象
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
// allowRawInjectionDespiteWrapping: 表示是否允许在循环引用的情况下注入原始 bean 实例,即使注入的 bean 最终被增强器增强包装过,默认是false
// hasDependentBean(beanName):是否存在其他bean依赖了当前bean
// 获取到依赖当前bean的所有bean的beanName
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
// 尝试移除bean实例,因为执行到这里,说明exposedObject != bean,也就是bean已经被后置处理器增强,不是原来的对象了,
// 他们依赖的是原来的对象,属于脏数据,所以需要移除掉
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
// 使用actualDependentBeans记录那些移除失败的dependentBean
actualDependentBeans.add(dependentBean);
}
}
// 如果存在移除失败的,则需要抛出异常,Spring不允许脏依赖的存在(通过allowRawInjectionDespiteWrapping设置)
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
// 注册DisposableBean的实现,在注销时执行来源于DestructionAwareBeanPostProcessors、实现的DisposableBean的destroy方法还有自己配置的destroy-method的处理
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
9.populateBean()方法
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
// 针对bean的包装器是否为空、是否存在为此 bean 定义的属性值,做不同的处理
if (bw == null) {
// 如果bean的包装器为空,但是又存在为此 bean 定义的属性值,Spring则会抛出BeanCreationException异常
// 因为属性填充就是要给BeanWrapper 中的 bean 实例中的属性进行赋值的过程,存在属性,但是BeanWrapper为空,也就是BeanWrapper 中的 bean 实例为空,那么显然不行
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
} else {
// 如果没有为此 bean 定义的属性值,即没有可填充的属性,则直接返回
// Skip property population phase for null instance.
return;
}
}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
// InstantiationAwareBeanPostProcessor后置处理器:可以在属性设置前修改bean
// 如果bean定义不是合成的,并且工厂中存在创建时应用于单例 bean 的 InstantiationAwareBeanPostProcessor后置处理器,则需要处理执行它的postProcessAfterInstantiation()方法
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
// 获取到bean工厂所有已经注册的BeanPostProcessor
for (BeanPostProcessor bp : getBeanPostProcessors()) {
// 判断是否属于InstantiationAwareBeanPostProcessor类型
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 如果类型匹配的话,将会执行InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation()方法
// postProcessAfterInstantiation()方法:在bean实例化后,属性填充之前被调用,允许修改bean的属性,默认实现是返回true
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
// 如果postProcessAfterInstantiation()方法返回false,则跳过后面的属性填充过程
return;
}
}
}
}
// 获取到bean定义中封装好的属性值
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
// 根据设置的自动注入方式(名称或者类型)获取属性bean(递归getBean)存入PropertyValues中
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 根据名称自动注入
// Add property values based on autowire by name if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
//根据类型自动注入
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
// hasInstAwareBpps:工厂是否存在将在创建时应用于单例 bean 的 InstantiationAwareBeanPostProcessor后置处理器
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
// needsDepCheck:是否需要进行依赖检查
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
// 如果存在InstantiationAwareBeanPostProcessor后置处理器,需要执行InstantiationAwareBeanPostProcessor的postProcessProperties()以及postProcessPropertyValues()方法回调
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
// 执行InstantiationAwareBeanPostProcessor的postProcessProperties()以及postProcessPropertyValues()方法回调
// postProcessProperties(): 允许对填充前的属性进行处理(如对属性的验证)
// postProcessPropertyValues(): 对属性值进行修改,通过基于原始的PropertyValues创建一个新的MutablePropertyValues实例,添加或删除特定的值。
// 不过目前方法已经被标记为过期,在后续Spring版本中可能会被删除
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
// 执行依赖检查,对应depend-on属性
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
// 依赖检查,对应depend-on属性
checkDependencies(beanName, mbd, filteredPds, pvs);
}
// 属性填充的具体过程,即将属性值赋值到beanWrapper中bean实例的具体属性中
if (pvs != null) {
// 开始填充属性值
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
10.initializeBean()方法
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
// 执行Aware方法,如BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
} else {
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 执行BeanPostProcessor后置处理器的前置处理方法:postProcessBeforeInitialization(),允许对bean实例进行包装
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 执行初始化方法,包括InitializingBean的afterPropertiesSet()方法、自定义的初始化方法init-method
invokeInitMethods(beanName, wrappedBean, mbd);
} catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
// 执行BeanPostProcessor后置处理器的后置处理方法:postProcessAfterInitialization(),允许对bean实例进行包装
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
三.如何解决循环依赖
1.什么是循环依赖
例如往容器中注册一个bean实例A以及实例B,A中实例引用了实例B,B对象也引用了A,那么Spring创建单实例对象是一个一个来创建的,假设先创建A,那么在初始化A对象时发现A用到了B对象,那么这时候为了完成A对象的初始化,则要创建B对象,创建B对象后初始化时,发现B引用了A,那么这时候需要从容器中获取A,这时A未初始化完成,是半成品对象,那么就不能给B对象完成引用,这时候就又要创建A,此时就陷入了死循环
2.Spring是如何解决的
利用三级缓存
先看下三级缓存长什么样子
//一级缓存 存储的为成品对象 可暴漏出去
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
//三级缓存 value是一个函数式接口 只有真正调用getObject时才会执行
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
//二级缓存 存储的为半成品对象
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
从源码分析画图流程图
3.为什么使用二级缓存,只用一级缓存可以解决问题么
一级缓存不能解决循环依赖,因为一级缓存存的是成品对象,是真正暴漏出去的对象,二级缓存中是存储的半成品对象,是不能对外暴漏的,如果对外暴漏出去,其他线程去引用的时候是个半成品对象的时候,可能会出现空指针异常
4.为什么用三级缓存
二级缓存可以解决循环依赖问题,但是加三级缓存时为了解决aop下的循环依赖 ,如果有a有代理对象 那么 a引用b ,b再引用a时候 返回的如果是a,而不是a的代理对象 那么会出问题,报错, 那么如果不加三级缓存也可以,那每次我创建对象的时候,都要判断是都要创建代理对象,这样就不符合spring的逻辑,spring的逻辑是创建对象后才会去生成代理对象;加个三级缓存,只是当在循环依赖下的时候 ,才会出现去判断是不是代理对象,因为是函数式接口,只有在循环依赖的情况下才会从三级缓存中获取,获取之后调用getObject方法才会真正判断该对象是否需要创建代理对象,如果需要,返回的就是一个代理对象,那么这时候再回到正常的逻辑之后,在beanpostprocessorAfter方法中不会再次创建该代理对象;