一.doscan方法的补充:
01.在findCandidateComponents(basePackage)方法中:
优化,因为扫描package如果存在有索引的文件,使用索引文件来加载bean。
索引的文件是META-INF目录下的缓存文件
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
//* if()里面就是判断META-INF目录下面是否有写components文件
// * (在该文件里面可以直接定义bean)然后在解析这个文件,其逻辑大致和下面一样
if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
}
else {
return scanCandidateComponents(basePackage);
}
}
这一段:
if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
}
这个和spring.components有关:(这个要自己创建)
spring.components文件内部如图:
代码会看这个文件的内容
02.addCandidateComponentsFromIndex方法:从索引文件中添加bean,最后的流程和之前差不多
private Set<BeanDefinition> addCandidateComponentsFromIndex(CandidateComponentsIndex index, String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
Set<String> types = new HashSet<>();
for (TypeFilter filter : this.includeFilters) {
// 获取过滤器的名字。
String stereotype = extractStereotype(filter);
if (stereotype == null) {
throw new IllegalArgumentException("Failed to extract stereotype from " + filter);
}
// 在过滤器中添加与指定构造型关联的候选类型。
types.addAll(index.getCandidateTypes(basePackage, stereotype));
}
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
for (String type : types) {
// 读取resource的元数据,也就是class的信息
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(type);
// 根据excludeFilters和includeFilters判断是否符合处理条件
if (isCandidateComponent(metadataReader)) {
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setSource(metadataReader.getResource());
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
logger.debug("Using candidate component class from index: " + type);
}
candidates.add(sbd);
}
else {
if (debugEnabled) {
logger.debug("Ignored because not a concrete top-level class: " + type);
}
}
}
else {
if (traceEnabled) {
logger.trace("Ignored because matching an exclude filter: " + type);
}
}
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return candidates;
}
重要的是try这个语句:
try {
Set<String> types = new HashSet<>();
//includeFilters是容器存储includeFilter的地方
for (TypeFilter filter : this.includeFilters) {
// 获取过滤器的名字。
String stereotype = extractStereotype(filter);
if (stereotype == null) {
throw new IllegalArgumentException("Failed to extract stereotype from " + filter);
}
types.addAll(index.getCandidateTypes(basePackage, stereotype));
}
for循环用到的includeFilters
private final List<TypeFilter> includeFilters = new ArrayList<>();
extractStereotype 这个是获取索引结构的右边的内容
private String extractStereotype(TypeFilter filter) {
if (filter instanceof AnnotationTypeFilter) {
return ((AnnotationTypeFilter) filter).getAnnotationType().getName();
}
if (filter instanceof AssignableTypeFilter) {
return ((AssignableTypeFilter) filter).getTargetType().getName();
}
return null;
}
index.getCandidateTypes方法:这里的index是map,List<Entry>
是key 获取索引文件的左边
public Set<String> getCandidateTypes(String basePackage, String stereotype) {
List<Entry> candidates = this.index.get(stereotype);//这里的index是map
if (candidates != null) {
return candidates.parallelStream()
.filter(t -> t.match(basePackage))
.map(t -> t.type)
.collect(Collectors.toSet());
}
return Collections.emptySet();
}
运行:这个时候查看索引文件
extractStereotype方法:此时stereotype=“org.springframework.sterotype.Component”
进入getCandidateTypes时候:此时的candidate
二.合并BeanDefinition:
01.这里看扫描之后的执行的函数,beanfactory.preInstantiateSingleton : 创建非懒加载的bean的方法
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.
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
// 获取合并后的BeanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//bd.isAbstract(),这里判断 的是bean是不是有这个属性,不是类型是不是抽象类
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
// 获取FactoryBean对象
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
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) {
// 创建真正的Bean对象(getObject()返回的对象)
getBean(beanName);
}
}
}
else {
// 创建Bean对象
getBean(beanName);
}
}
}
// 所有的非懒加载单例Bean都创建完了后
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
.tag("beanName", beanName);
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
smartInitialize.end();
}
}
}
02.开头是这一段getMergedLocalBeanDefinition:
for (String beanName : beanNames) {
// 获取合并后的BeanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
}
getMergedLocalBeanDefinition:
合并的BeanDefinition,这个和bean中的一个属性有关parent:
举例:
在xml文件中声明bean标签:
<bean id="user" class="com.xxx.xxx.User" Scope="prototype">
</bean>
<bean id="userService" class="com.xxx.xxx.UserService" parent="user">
</bean>
如果BeanDefinition中有parent属性的话(userService),就会去找这个parent(user)。然后合并两个BeanDefinition,形成一个新的bean,这个bean的类型是RootBeanDefinition 。就这个例子而言,会创建两个BeanDefinition,然后创建一个合并的RootBeanDefinition 。
03.getMergedLocalBeanDefinition具体方法:
这里的mergedBeanDefinitions是一个集合,用于存储RootBeanDefinition 。
在这个集合中找有无符合条件的RootBeanDefinition
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
// 从集合中获取key值是beanName的RootBeanDefinition
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
if (mbd != null && !mbd.stale) {
return mbd;
}
//如果没有相应的RootBeanDefinition
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
第一次从mergedBeanDefinitions这个变量中取值,肯定是没有值,只有合并过后,这个mergedBeanDefinitions中才有值,
于是会调用getMergedBeanDefinition(beanName,getBeanDefinition(beanName));方法,具体的代码如下:
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
throws BeanDefinitionStoreException {
return getMergedBeanDefinition(beanName, bd, null);
}
04.发现继续调用的是getMergedBeanDefinition(beanName, bd, null);的方法,具体的代码如下:
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
throws BeanDefinitionStoreException {
synchronized (this.mergedBeanDefinitions) {
RootBeanDefinition mbd = null;
RootBeanDefinition previous = null;
// Check with full lock now in order to enforce the same merged instance.
// 第一次这个值为空
if (containingBd == null) {
//这个取出来的值也是空,因为没有合并过
mbd = this.mergedBeanDefinitions.get(beanName);
}
if (mbd == null || mbd.stale) {
previous = mbd;
//bd是参数BeanDefinition
//判断这个BeanDefinition的parentName值是不是等于null
//getParentName 返回此 bean 定义的父定义的名称。
if (bd.getParentName() == null) {
//判断这个BeanDefinition的类型是不是RootBeanDefinition的,这儿root是的
if (bd instanceof RootBeanDefinition) {
//克隆这个BeanDefinition
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
}
else {
//若不是也是直接将这个BeanDefinition变成RootBeanDefinition
mbd = new RootBeanDefinition(bd);
}
}
//这个就是需要的合并的
else {
// Child bean definition: needs to be merged with parent.
// pbd表示parentBeanDefinition
BeanDefinition pbd;
try {
//取出原始的名称,parentBeanName 可能是别名,transformedBeanName方法会找到类名
String parentBeanName = transformedBeanName(bd.getParentName());
//这里的判断条件是保证不会出现循环依赖的情况。例子A的parent属性是B,B的parent属性是A
if (!beanName.equals(parentBeanName)) {
//又调用了一次合并,等于是递归的调用,因为这个parentName的BeanDefinition的parentName的值也不等于空,
//直到找到等于null的,就不合并了,这儿返回的就是parentName表示的BeanDefinition
pbd = getMergedBeanDefinition(parentBeanName);
}
else {
//获取父工厂
BeanFactory parent = getParentBeanFactory();
if (parent instanceof ConfigurableBeanFactory) {
pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
}
else {
throw new NoSuchBeanDefinitionException(parentBeanName,"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +"': cannot be resolved without a ConfigurableBeanFactory parent");
}
}
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
}
// Deep copy with overridden values.
// 子BeanDefinition的属性覆盖父BeanDefinition的属性,这就是合并
mbd = new RootBeanDefinition(pbd);
mbd.overrideFrom(bd);
}
// Set default singleton scope, if not configured before.
if (!StringUtils.hasLength(mbd.getScope())) {
mbd.setScope(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.
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)
if (containingBd == null && isCacheBeanMetadata()) {
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
if (previous != null) {
copyRelevantMergedBeanDefinitionCaches(previous, mbd);
}
return mbd;
}
}
这一段:
//bd是参数BeanDefinition,没有parent属性的话
if (bd.getParentName() == null) {
// Use copy of given root bean definition.
if (bd instanceof RootBeanDefinition) {
//克隆一个bd的RootBeanDefinition
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
}
else {
//创建一个bd的RootBeanDefinition
mbd = new RootBeanDefinition(bd);
}
}
这一段:
try {
//取出原始的名称,parentBeanName 可能是别名,transformedBeanName方法会找到类名
String parentBeanName = transformedBeanName(bd.getParentName());
//这里的判断条件是保证不会出现循环依赖的情况。例子A的parent属性是B,B的parent属性是A
if (!beanName.equals(parentBeanName)) {
//又调用了一次合并,等于是递归的调用,因为这个parentName的BeanDefinition的parentName的值也不等于空,
//直到找到等于null的,就不合并了,这儿返回的就是parentName表示的BeanDefinition
pbd = getMergedBeanDefinition(parentBeanName);
}
else {
//获取父工厂
BeanFactory parent = getParentBeanFactory();
if (parent instanceof ConfigurableBeanFactory) {
pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
}
else {
throw new NoSuchBeanDefinitionException(parentBeanName,"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +"': cannot be resolved without a ConfigurableBeanFactory parent");
}
}
}
这一段: 子BeanDefinition的属性覆盖父BeanDefinition的属性,这就是合并
mbd = new RootBeanDefinition(pbd);
mbd.overrideFrom(bd);
overrideFrom方法:
public void overrideFrom(BeanDefinition other) {
if (StringUtils.hasLength(other.getBeanClassName())) {
setBeanClassName(other.getBeanClassName());
}
if (StringUtils.hasLength(other.getScope())) {
setScope(other.getScope());
}
setAbstract(other.isAbstract());
if (StringUtils.hasLength(other.getFactoryBeanName())) {
setFactoryBeanName(other.getFactoryBeanName());
}
if (StringUtils.hasLength(other.getFactoryMethodName())) {
setFactoryMethodName(other.getFactoryMethodName());
}
setRole(other.getRole());
setSource(other.getSource());
copyAttributesFrom(other);
if (other instanceof AbstractBeanDefinition) {
AbstractBeanDefinition otherAbd = (AbstractBeanDefinition) other;
if (otherAbd.hasBeanClass()) {
setBeanClass(otherAbd.getBeanClass());
}
if (otherAbd.hasConstructorArgumentValues()) {
getConstructorArgumentValues().addArgumentValues(other.getConstructorArgumentValues());
}
if (otherAbd.hasPropertyValues()) {
getPropertyValues().addPropertyValues(other.getPropertyValues());
}
if (otherAbd.hasMethodOverrides()) {
getMethodOverrides().addOverrides(otherAbd.getMethodOverrides());
}
Boolean lazyInit = otherAbd.getLazyInit();
if (lazyInit != null) {
setLazyInit(lazyInit);
}
setAutowireMode(otherAbd.getAutowireMode());
setDependencyCheck(otherAbd.getDependencyCheck());
setDependsOn(otherAbd.getDependsOn());
setAutowireCandidate(otherAbd.isAutowireCandidate());
setPrimary(otherAbd.isPrimary());
copyQualifiersFrom(otherAbd);
setInstanceSupplier(otherAbd.getInstanceSupplier());
setNonPublicAccessAllowed(otherAbd.isNonPublicAccessAllowed());
setLenientConstructorResolution(otherAbd.isLenientConstructorResolution());
if (otherAbd.getInitMethodName() != null) {
setInitMethodName(otherAbd.getInitMethodName());
setEnforceInitMethod(otherAbd.isEnforceInitMethod());
}
if (otherAbd.getDestroyMethodName() != null) {
setDestroyMethodName(otherAbd.getDestroyMethodName());
setEnforceDestroyMethod(otherAbd.isEnforceDestroyMethod());
}
setSynthetic(otherAbd.isSynthetic());
setResource(otherAbd.getResource());
}
else {
getConstructorArgumentValues().addArgumentValues(other.getConstructorArgumentValues());
getPropertyValues().addPropertyValues(other.getPropertyValues());
setLazyInit(other.isLazyInit());
setResourceDescription(other.getResourceDescription());
}
}
05.回到preInstantiateSingleton:下一步,在获取RootBeanDefinition后 判断是不是FactoryBean
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
// 获取FactoryBean对象 String FACTORY_BEAN_PREFIX = "&";
//查找FactoryBean 要加前缀 &
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
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) {
// 创建真正的Bean对象(getObject()返回的对象)
getBean(beanName);
}
}
}
else {
// 创建Bean对象
getBean(beanName);
}
}
关于FactoryBean 举个例子:
在扫描器扫描这个类的时候,是会产生两个bean的,分别是zhouyuFactoryBean 和 User,产生一个beanDefinition 是 zhouyuFactoryBean
@Component
public class zhouyuFactoryBean implements FactoryBean {
@Override
public Object getObject() throws Exception {
return new User();
}
@Override
public Class<?> getObjectType() {
return null;
}
}
这一段代码判断获取的RootBeanDefinition是否有abstract属性(这个属性会产生相关的beandefinition,不会有bean对象在容器中),是不是单例模式,是不是懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {}
接下来的方法isFactoryBean方法:
public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {
//拿到真正的类名
String beanName = transformedBeanName(name);
//从缓存中查找单例
Object beanInstance = getSingleton(beanName, false);
if (beanInstance != null) {
//返回ture 是不是实现了接口FactoryBean
return (beanInstance instanceof FactoryBean);
}
// 如果缓存中没有单例,并且有父工厂
if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
// No bean definition found in this factory -> delegate to parent.
return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);
}
//返回这个方法
return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));
}
//最后返回的方法
protected boolean isFactoryBean(String beanName, RootBeanDefinition mbd) {
//RootBeanDefinition 中有属性isFactoryBean
Boolean result = mbd.isFactoryBean;
if (result == null) {
// 根据BeanDefinition推测Bean类型(获取BeanDefinition的beanClass属性)
Class<?> beanType = predictBeanType(beanName, mbd, FactoryBean.class);
// 判断是不是实现了FactoryBean接口
result = (beanType != null && FactoryBean.class.isAssignableFrom(beanType));
mbd.isFactoryBean = result;
}
return result;
}
transformedBeanName方法:获取类的名字,可能存在别名
protected String transformedBeanName(String name) {
return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}
举个例子:在注解@Bean中,可以声明一组名字:UserService1,UserService1111,UserService123,UserService。这组名字可以认为是别名。类名UserService是一个最特殊的名字,存放BeanDefinition的时候用的是类名
@Bean({"UserService1","UserService1111","UserService123","UserService"})
public UserService UserService() {
return new UserService();
}
BeanFactoryUtils.transformedBeanName方法:
用到了的常量:
String FACTORY_BEAN_PREFIX = "&";
public static String transformedBeanName(String name) {
Assert.notNull(name, "'name' must not be null");
//判断name是否不含有前缀“&”
if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
return name;
}
// name含有前缀“&”,则返回将“&”去除掉后的字符串
return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
do {
beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
}
while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
return beanName;
});
}
canonicalName方法:反复从aliasMap取出类名
aliasMap是存放别名的地方:用K,V来保存。例如:<别名1,别名2>,<别名2,别名3>,<别名3,类名>
private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
public String canonicalName(String name) {
String canonicalName = name;
// Handle aliasing...
String resolvedName;
do {
resolvedName = this.aliasMap.get(canonicalName);
if (resolvedName != null) {
canonicalName = resolvedName;
}
}
while (resolvedName != null);
return canonicalName;
}
getSingleton方法:
用到了一个概念,三级缓存
/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/** Cache of singleton factories: bean name to ObjectFactory. */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/** Cache of early singleton objects: bean name to bean instance. */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
getSingleton:
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//查询一级缓存
Object singletonObject = this.singletonObjects.get(beanName);
//一级缓存中是否包含key为当前beanName的值
//beanName的Bean对象有没有在创建中
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
//加锁
synchronized (this.singletonObjects) {
//一级缓存中没用缓存key为当前beanName的值
//查找二级缓存中是否包含key为当前beanName的值
singletonObject = this.earlySingletonObjects.get(beanName);
//二级缓存中没用缓存key为当前beanName的值
//allowEarlyReference为true,表示允许创建早期的引用
if (singletonObject == null && allowEarlyReference) {
//查找三级缓存中是否包含key为当前beanName的值
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
//不为空说明存在三级缓存中
if (singletonFactory != null) {
//从三级缓存中获取当前beanName
singletonObject = singletonFactory.getObject();
//将当前beanName添加到二级缓存中
this.earlySingletonObjects.put(beanName, singletonObject);
//将当前beanName移除出三级缓存
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
06.回到preInstantiateSingleton:此时
这一段:实现了FactoryBean接口的类,会在容器明显调用getbean的时候,才会用重写的getObject()返回对象
// 获取FactoryBean对象 String FACTORY_BEAN_PREFIX = "&";
//查找FactoryBean 要加前缀 &
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
//金手指:isEagerInit 是否渴望初始化,true 表示不使用懒加载,false 表示使用懒加载。
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(
(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
//只有实现了SmartFactoryBean 的接口的类,才会在初始化的时候就调用getBean 创建真正的Bean对象(getObject()返回的对象)
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
// 创建真正的Bean对象(getObject()返回的对象)
getBean(beanName);
}
}
}
else {
// 创建Bean对象
getBean(beanName);
}
07.再回到preInstantiateSingleton方法:
SmartInitializingSingleton
// 所有的非懒加载单例Bean都创建完了后
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
.tag("beanName", beanName);
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
smartInitialize.end();
}
}