一.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();
}
}
5566
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
