Spring【版本5.2.2】容器初始化过程（五）finishBeanFactoryInitialization

刺骨的言语ヽ痛彻心扉 2023-06-16 08:27 16阅读 0赞

#### 11.finishBeanFactoryInitialization ####

篇幅原因，可能会删除一些不重要的代码，是不重要，不是没用。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { 
    		// 1. 判断是否有bdName为conversionService的bd(实现ConversionService接口)，有的话注册为格式转换器服务类,
    		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));
    		}
    		// 2.如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器：主要用于注解属性值的解析。
    		if (!beanFactory.hasEmbeddedValueResolver()) { 
    			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    		}
    		// 3.获取LoadTimeWeaverAware类型的bd，提前实例化
    		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    		for (String weaverAwareName : weaverAwareNames) { 
    			getBean(weaverAwareName);
    		}
    
    		beanFactory.setTempClassLoader(null);
    		// 4. 设置configurationFrozen属性，并记录frozenBeanDefinitionNames，冻结上下文，不允许再进行修改配置
    		beanFactory.freezeConfiguration();
    		// 5.实例化所有剩余（非懒加载）单例对象
    		beanFactory.preInstantiateSingletons();
    	}

##### 重点说一下5. preInstantiateSingletons #####

@Override
    	public void preInstantiateSingletons() throws BeansException { 
    		if (logger.isTraceEnabled()) { 
    			logger.trace("Pre-instantiating singletons in " + this);
    		}
    		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
    		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    		// 1. 创建beanDefinitionNames的副本beanNames用于后续的遍历，以允许init等方法注册新的bean定义
    		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    		// 2. 触发所有非Lazy单例bean的初始化，通过getBean
    		// Trigger initialization of all non-lazy singleton beans...
    		for (String beanName : beanNames) { 
    			// 4. 获取指定beanNamed对应的MergedDefinition,主要是合并父类的BeanDefinition
    			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    			// 三个条件，非抽象，单例，非懒加载
    			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { 
    				// 5.判断beanName对应的bean是否为FactoryBean
    				if (isFactoryBean(beanName)) { 
    					// 是FactoryBean，加上&
    					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
    					if (bean instanceof FactoryBean) { 
    						// 5.1 通过beanName获取FactoryBean实例
    						// 通过getBean(&beanName)拿到的是FactoryBean本身；通过getBean(beanName)拿到的是FactoryBean创建的Bean实例
    						final FactoryBean<?> factory = (FactoryBean<?>) bean;
    						// 5.2 判断这个FactoryBean是否希望急切的初始化
    						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) { 
    							// 5.3 如果希望急切的初始化，则通过beanName获取bean实例
    							getBean(beanName);
    						}
    					}
    				}
    				else { 
    					// 6.如果beanName对应的bean不是FactoryBean，只是普通Bean，通过beanName获取bean实例
    					getBean(beanName);
    				}
    			}
    		}
    
    		// Trigger post-initialization callback for all applicable beans...
    		// 7.遍历beanNames，触发所有SmartInitializingSingleton的后初始化回调
    		for (String beanName : beanNames) { 
    			// 7.1 拿到beanName对应的bean实例
    			Object singletonInstance = getSingleton(beanName);
    			// 7.2 判断singletonInstance是否实现了SmartInitializingSingleton接口
    			if (singletonInstance instanceof SmartInitializingSingleton) { 
    				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
    				// 7.3 触发SmartInitializingSingleton实现类的afterSingletonsInstantiated方法
    				if (System.getSecurityManager() != null) { 
    					AccessController.doPrivileged((PrivilegedAction<Object>) () -> { 
    						smartSingleton.afterSingletonsInstantiated();
    						return null;
    					}, getAccessControlContext());
    				}
    				else { 
    					smartSingleton.afterSingletonsInstantiated();
    				}
    			}
    		}
    	}

###### 代码块1：getMergedLocalBeanDefinition ######

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException { 
    		// Quick check on the concurrent map first, with minimal locking.
    		// 1.检查beanName对应的MergedBeanDefinition是否存在于缓存中
    		RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
    		if (mbd != null && !mbd.stale) { 
    			// 2.如果存在于缓存中则直接返回
    			return mbd;
    		}
    		// 3.如果不存在于缓存中
    		// 3.1 getBeanDefinition(beanName)： 获取beanName对应的BeanDefinition，从beanDefinitionMap缓存中获取
    		// 3.2 getMergedBeanDefinition: 根据beanName和对应的BeanDefinition，获取MergedBeanDefinition
    		return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
    	}
    	
    	protected RootBeanDefinition getMergedBeanDefinition(
    			String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
    			throws BeanDefinitionStoreException { 
    		// 涉及到mergedBeanDefinitions的数据变更，所以枷锁操作
    		synchronized (this.mergedBeanDefinitions) { 
    			// 用于存储bd的MergedBeanDefinition，也就是该方法的结果
    			RootBeanDefinition mbd = null;
    
    			RootBeanDefinition previous = null;
    
    			// Check with full lock now in order to enforce the same merged instance.
    			if (containingBd == null) { 
    				// 2.检查beanName对应的MergedBeanDefinition是否存在于缓存中
    				mbd = this.mergedBeanDefinitions.get(beanName);
    			}
    			// 3.如果beanName对应的MergedBeanDefinition不存在于缓存中
    			if (mbd == null || mbd.stale) { 
    				// 这里和以前版本有点区别就是添加了stale属性，区分!=null的时候，对原来的mbd进行处理
    				previous = mbd;
    				// 似乎没啥用
    				mbd = null;
    				if (bd.getParentName() == null) { 
    					// Use copy of given root bean definition.
    					// 4.如果bd的parentName为空，代表bd没有父定义，无需与父定义进行合并操作，
    					// 也就是bd的MergedBeanDefinition就是bd本身（可能需要转成RootBeanDefinition）
    					if (bd instanceof RootBeanDefinition) { 
    						mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
    					}
    					else { 
    						mbd = new RootBeanDefinition(bd);
    					}
    				}
    				else { 
    					// 5.否则，bd存在父定义，需要与父定义合并
    					// Child bean definition: needs to be merged with parent.
    					BeanDefinition pbd;
    					try { 
    						// 5.1 获取父定义的beanName
    						String parentBeanName = transformedBeanName(bd.getParentName());
    						// 5.2 如果父定义的beanName与该bean的beanName不同
    						if (!beanName.equals(parentBeanName)) { 
    							// 5.3 获取父定义的MergedBeanDefinition，
    							// 因为父定义也可能有父定义，也就是bd的爷爷定义...所以这里面直接用了迭代
    							pbd = getMergedBeanDefinition(parentBeanName);
    						}
    						else { 
    							// 5.4 如果父定义的beanName与bd的beanName相同，则拿到父BeanFactory，
    							// 只有在存在父BeanFactory的情况下，才允许父定义beanName与自己相同，否则就是将自己设置为父定义
    							BeanFactory parent = getParentBeanFactory();
    							if (parent instanceof ConfigurableBeanFactory) { 
    								// 5.5 如果父BeanFactory是ConfigurableBeanFactory，
    								// 则通过父BeanFactory获取父定义的MergedBeanDefinition
    								pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
    							}
    							else { 
    								// 5.6 如果父BeanFactory不是ConfigurableBeanFactory，则抛异常
    								throw new NoSuchBeanDefinitionException(parentBeanName,
    										"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
    										"': cannot be resolved without an AbstractBeanFactory parent");
    							}
    						}
    					}
    					catch (NoSuchBeanDefinitionException ex) { 
    						throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
    								"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
    					}
    					// Deep copy with overridden values.
    					// 5.7 使用父定义pbd构建一个新的RootBeanDefinition对象（深拷贝）
    					mbd = new RootBeanDefinition(pbd);
    					// 5.8 使用bd覆盖父定义
    					mbd.overrideFrom(bd);
    				}
    
    				// Set default singleton scope, if not configured before.
    				// 6.如果没有配置scope，则设置成默认的singleton
    				if (!StringUtils.hasLength(mbd.getScope())) { 
    					mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
    				}
    
    				// A bean contained in a non-singleton bean cannot be a singleton itself.
    				// Let's correct this on the fly here, since this might be the result of
    				// parent-child merging for the outer bean, in which case the original inner bean
    				// definition will not have inherited the merged outer bean's singleton status.
    				// 7.如果containingBd不为空 && containingBd不为singleton && mbd为singleton，则将mdb的scope设置为containingBd的scope
    				if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) { 
    					mbd.setScope(containingBd.getScope());
    				}
    
    				// Cache the merged bean definition for the time being
    				// (it might still get re-merged later on in order to pick up metadata changes)
    				// 8.将beanName与mbd放到mergedBeanDefinitions缓存，以便之后可以直接使用
    				if (containingBd == null && isCacheBeanMetadata()) { 
    					this.mergedBeanDefinitions.put(beanName, mbd);
    				}
    			}
    			if (previous != null) { 
    				// 如果previous和mdb的ResolvableType不同，则用某些老的属性覆盖掉新生成的
    				copyRelevantMergedBeanDefinitionCaches(previous, mbd);
    			}
    			// 9.返回MergedBeanDefinition
    			return mbd;
    		}
    	}
    
    	/** * 如果previous和mdb的ResolvableType不同，则用某些老的属性覆盖掉新生成的 * @param previous 老的 * @param mbd 新生成的 */
    	private void copyRelevantMergedBeanDefinitionCaches(RootBeanDefinition previous, RootBeanDefinition mbd) { 
    		if (ObjectUtils.nullSafeEquals(mbd.getBeanClassName(), previous.getBeanClassName()) &&
    				ObjectUtils.nullSafeEquals(mbd.getFactoryBeanName(), previous.getFactoryBeanName()) &&
    				ObjectUtils.nullSafeEquals(mbd.getFactoryMethodName(), previous.getFactoryMethodName())) { 
    			ResolvableType targetType = mbd.targetType;
    			ResolvableType previousTargetType = previous.targetType;
    			if (targetType == null || targetType.equals(previousTargetType)) { 
    				mbd.targetType = previousTargetType;
    				mbd.isFactoryBean = previous.isFactoryBean;
    				mbd.resolvedTargetType = previous.resolvedTargetType;
    				mbd.factoryMethodReturnType = previous.factoryMethodReturnType;
    				mbd.factoryMethodToIntrospect = previous.factoryMethodToIntrospect;
    			}
    		}
    	}

###### 代码块2：isFactoryBean ######

@Override
    	public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException { 
    		// 1.拿到真正的beanName（去掉&前缀、解析别名）
    		String beanName = transformedBeanName(name);
    		// 2.尝试从缓存获取Bean实例对象
    		Object beanInstance = getSingleton(beanName, false);
    		if (beanInstance != null) { 
    			// 3.beanInstance存在，则直接判断类型是否为FactoryBean
    			return (beanInstance instanceof FactoryBean);
    		}
    		// No singleton instance found -> check bean definition.
    		// 4.如果beanInstance为null，并且beanName在单例对象缓存中，则代表beanName对应的单例对象为空对象
    		if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) { 
    			// No bean definition found in this factory -> delegate to parent.
    			// 用迭代的方式，检查父类
    			return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);
    		}
    		// 6.通过MergedBeanDefinition来检查beanName对应的Bean是否为FactoryBean
    		return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));
    	}
    	
    	protected boolean isFactoryBean(String beanName, RootBeanDefinition mbd) { 
    		Boolean result = mbd.isFactoryBean;
    		if (result == null) { 
    			// 1.拿到beanName对应的Bean实例的类型
    			Class<?> beanType = predictBeanType(beanName, mbd, FactoryBean.class);
    			// beanType是否为FactoryBean本身、子类或子接口
    			result = (beanType != null && FactoryBean.class.isAssignableFrom(beanType));
    			// 更新mbd的isFactoryBean属性
    			mbd.isFactoryBean = result;
    		}
    		// 返回mbd.isFactoryBean
    		return result;
    	}

###### 代码块3：getSingleton ######

由方法头部的@Nullable注解，可以知道，当前方法可以返回null的，

@Nullable
    	protected Object getSingleton(String beanName, boolean allowEarlyReference) { 
    		// 1.从单例对象缓存中获取beanName对应的单例对象
    		Object singletonObject = this.singletonObjects.get(beanName);
    		// 2.如果单例对象缓存中没有，并且该beanName对应的单例bean正在创建中
    		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { 
    			// 3.设计对singletonObjects的修改，加锁进行操作
    			synchronized (this.singletonObjects) { 
    				// 4.从早期单例对象缓存中获取单例对象（之所称成为早期单例对象，是因为earlySingletonObjects里
    				// 的对象的都是通过提前曝光的ObjectFactory创建出来的，还未进行属性填充等操作）
    				singletonObject = this.earlySingletonObjects.get(beanName);
    				// 5.如果在早期单例对象缓存中也没有，并且允许创建早期单例对象引用
    				if (singletonObject == null && allowEarlyReference) { 
    					// 从 singletonFactories 中获取，这应该是最底层的存储了，如果这里面也没有。
    					// 那就返回null了
    					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
    					if (singletonFactory != null) { 
    						// 如果有，那么把这个对象从singletonFactories移动到earlySingletonObjects里面
    						singletonObject = singletonFactory.getObject();
    						// 8.将通过单例对象工厂创建的单例对象，放到早期单例对象缓存中
    						this.earlySingletonObjects.put(beanName, singletonObject);
    						// 9.移除该beanName对应的单例对象工厂，因为该单例工厂已经创建了一个实例对象，
    						// 并且放到earlySingletonObjects缓存了，
    						// 因此，后续获取beanName的单例对象，可以通过earlySingletonObjects缓存拿到，
    						// 不需要在用到该单例工厂
    						this.singletonFactories.remove(beanName);
    					}
    				}
    			}
    		}
    		// 10.返回单例对象 或者null
    		return singletonObject;
    	}
    	
     
    	public boolean isSingletonCurrentlyInCreation(String beanName) { 
    	    return this.singletonsCurrentlyInCreation.contains(beanName);
    	}

未完待续…  
参考：  
https://blog.csdn.net/v123411739/article/details/87907784

发表评论取消回复

表情：

评论列表（有 0 条评论，16人围观）

还没有评论，来说两句吧...

相关阅读

相关 Spring【版本5.2.2】容器初始化过程（六）getBean 详解

接着上文的 6.registerBeanPostProcessors 代码块4：getBean 这个是重点： @Override public

淩亂°似流年/ 2023年06月16日 10:38/ 0 赞/ 10 阅读

相关 Spring【版本5.2.2】容器初始化过程（五）finishBeanFactoryInitialization

11.finishBeanFactoryInitialization 篇幅原因，可能会删除一些不重要的代码，是不重要，不是没用。 protected void

刺骨的言语ヽ痛彻心扉/ 2023年06月16日 08:27/ 0 赞/ 17 阅读

相关 Spring【版本5.2.2】容器初始化过程（四）refresh（三）

6.registerBeanPostProcessors 这个方法主要是处理各种各样的BeanPostProcessors，并按照实现接口PriorityOrdered和

墨蓝/ 2023年06月16日 08:26/ 0 赞/ 9 阅读

相关 Spring【版本5.2.2】容器初始化过程（二）refresh（一）

下面来说说AnnotationConfigApplicationContext的第三个方法 refresh / 准备好bean工厂，实例化对象 @throws B

￡神魔★判官ぃ/ 2023年06月15日 13:28/ 0 赞/ 15 阅读

相关（Spring源码分析）AnnotationConfigApplicationContext容器初始化 refresh()#finishBeanFactoryInitialization

AnnotationConfigApplicationContext容器初始化目录 [（Spring源码分析）AnnotationConfigApplicationCont

叁歲伎倆/ 2023年05月30日 09:26/ 0 赞/ 33 阅读

相关 spring 容器初始化过程、aop、IOC过程

使用classpathXmlApplicationContext的方式加载配置文件第一步：拿到xml配置文件第二步：①创建beanFactory②xml解析，包含bea

谁践踏了优雅/ 2022年10月14日 01:09/ 0 赞/ 259 阅读

相关 Spring原理-IoC容器初始化过程

IoC容器初始化过程 IoC容器的两个核心接口BeanFactory和ApplicationContext大概功能都讲解了一些，接下来我们讲解一下IoC容器的初始化过程，让大

曾经终败给现在/ 2022年07月15日 07:23/ 0 赞/ 296 阅读

相关 Spring容器初始化过程

一、Spring 容器高层视图 Spring 启动时读取应用程序提供的Bean配置信息，并在Spring容器中生成一份相应的Bean配置注册表，然后根据这张注册表实例化B

拼搏现实的明天。/ 2022年03月15日 06:36/ 0 赞/ 334 阅读

相关 Spring容器的初始化过程

1、Spring 容器高层视图 Spring 启动时读取应用程序提供的Bean配置信息，并在Spring容器中生成一份相应的Bean配置注册表，然后根据这张注册表实例化Be

川长思鸟来/ 2022年02月26日 17:42/ 0 赞/ 375 阅读

相关 Spring容器初始化全过程

spring容器主要有三种初始化方式，xml；注解；JavaConfig+注解形式，这里以目前最前卫的JavaConfig初始化方式来解读整个容器的初始化。（毕竟spring官

深藏阁楼爱情的钟/ 2022年02月19日 17:42/ 0 赞/ 373 阅读