// Instantiate all remaining (non-lazy-init) singletons.
		beanFactory.preInstantiateSingletons();

    public void preInstantiateSingletons() throws BeansException {
        if (logger.isTraceEnabled()) {
            logger.trace("Pre-instantiating singletons in " + this);
        }
        //所有要進(jìn)行初始的Bean
        List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
        // 對(duì)所有Bean進(jìn)行初始化，除了懶加載
        for (String beanName : beanNames) {
            // 去合并Bean
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            //非抽象、單例、懶加載才會(huì)進(jìn)行注冊(cè)
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                //判斷是不是 FactoryBean，簡(jiǎn)單說(shuō)是我們這個(gè) Bean 實(shí)現(xiàn)了
                if (isFactoryBean(beanName)) {
                    // 是不是 FactoryBean，獲取 FactoryBean 的方式就是  前綴+beanName
                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                    // 判斷是否 FactoryBean
                    if (bean instanceof FactoryBean) {
                        // 強(qiáng)轉(zhuǎn)
                        FactoryBean<?> factory = (FactoryBean<?>) bean;
                        boolean isEagerInit;
                        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                            isEagerInit = AccessController.doPrivileged(
                                    (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
                                    getAccessControlContext());
                        } else {
                            // 判斷 是不是 這個(gè)類(lèi)的，如果是就去創(chuàng)建 SmartFactoryBean 屬于 FactoryBean 子接口，擁有更加細(xì)粒度操作原數(shù)據(jù)的方式，
                            isEagerInit = (factory instanceof SmartFactoryBean &&
                                    ((SmartFactoryBean<?>) factory).isEagerInit());
                        }
                        if (isEagerInit) {
                            getBean(beanName);
                        }
                    }
                } else {
                    //獲取具體的Bean
                    getBean(beanName);
                }
            }
        }
        // Trigger post-initialization callback for all applicable beans...
        for (String beanName : beanNames) {
            Object singletonInstance = getSingleton(beanName);
            // 執(zhí)行所有 單例Bean 的回調(diào)，當(dāng)然Bean 需要實(shí)現(xiàn)這個(gè)接口~~~
            if (singletonInstance instanceof SmartInitializingSingleton) {
                SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                        smartSingleton.afterSingletonsInstantiated();
                        return null;
                    }, getAccessControlContext());
                } else {
                    smartSingleton.afterSingletonsInstantiated();
                }
            }
        }
    }

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
    //從當(dāng)前 BeanFactory 中的緩存中獲取
    RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
    // 不是NUll 并且  沒(méi)有過(guò)期的話，如果過(guò)期了或者修改了 會(huì)重新去查找
    if (mbd != null && !mbd.stale) {
        //返回當(dāng)前的
        return mbd;
    }
    // 先去 beanDefinitionMap 中去獲取
    BeanDefinition thisBeanDefinition=   getBeanDefinition(beanName);
    // 緩存中未找到，就到 BeanFactory 中尋找
    return getMergedBeanDefinition(beanName, thisBeanDefinition);
}
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
    throws BeanDefinitionStoreException {
    //傳遞Name 和BeanDefinition
    return getMergedBeanDefinition(beanName, bd, null);
}

    protected RootBeanDefinition getMergedBeanDefinition(
            String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
            throws BeanDefinitionStoreException {
        // 將 mergedBeanDefinitions 防止線程安全，為什么？
        // 雖然 ConcurrentHashMap 是線程安全的，但是下面的業(yè)務(wù)并不一定是線程安全的，所以要加鎖
        synchronized (this.mergedBeanDefinitions) {
            RootBeanDefinition mbd = null;
            RootBeanDefinition previous = null;
            // 這里為空，代表的是 當(dāng)前的 BeanDefinition 是頂層的 Bean 不存在 嵌套Bean
            if (containingBd == null) {
                // 獲取當(dāng)前Bean，為什么又一次獲取了呢？因?yàn)槿绻诙嗑€程操作下 可能 這個(gè)Bean已經(jīng)被修改了，所以重新獲取一次
                mbd = this.mergedBeanDefinitions.get(beanName);
            }
            //如果緩存中沒(méi)有，或者過(guò)期了，則會(huì)重新創(chuàng)建一個(gè)
            if (mbd == null || mbd.stale) {
                previous = mbd;
                //如果 父 parentName 為空
                if (bd.getParentName() == null) {
                    // 如果當(dāng)前類(lèi)型就是 RootBeanDefinition
                    if (bd instanceof RootBeanDefinition) {
                        // 進(jìn)行克隆~~~
                        mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
                    } else {
                        // 如果不是就會(huì)將 其他 BeanDefinition 轉(zhuǎn)換成 RootBeanDefinition 代表的是當(dāng)前 BeanDefinition 為頂級(jí) Bean
                        mbd = new RootBeanDefinition(bd);
                    }
                }
                //  如果父 BeanDefinition 不為 空，也就代表了 當(dāng)前類(lèi)存在繼承，如果不理解這段的話，可以看一下<bean parent=""> bean標(biāo)簽中的 paretn 屬性，
                else {
                    // 子bean定義：需要與父bean合并。
                    BeanDefinition pbd;
                    try {
                        String parentBeanName = transformedBeanName(bd.getParentName());
                        // 當(dāng)前的 BeanName 不是 parentBeanName，會(huì)去獲取 父BeanDefinition，否則則會(huì)去父工廠去獲取
                        if (!beanName.equals(parentBeanName)) {
                            // 獲取 parent BeanDefinition這里會(huì)進(jìn)行一個(gè)遞歸操作，
                            pbd = getMergedBeanDefinition(parentBeanName);
                        } else {
                            // 如果當(dāng)前的BeanName 和傳遞的 parentName 一模一樣 則會(huì)去父 ParentBeanFactory 查找
                            BeanFactory parent = getParentBeanFactory();
                            // 如果當(dāng)前是層次 BeanFactory 轉(zhuǎn)換查找，如果不是 拋出異常
                            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);
                    }
                    // 進(jìn)行合并
                    // 進(jìn)行合并，這里的合并是指將 父級(jí)的Bean 合并到子 中，例如  user extends superUser
                    // 也就說(shuō)講 super中的 屬性 合并到 user 中
                    // Deep copy with overridden values.
                    mbd = new RootBeanDefinition(pbd);
                    mbd.overrideFrom(bd);
                }
                //設(shè)置成單例，如果之前沒(méi)設(shè)置的話~~~~
                if (!StringUtils.hasLength(mbd.getScope())) {
                    // 默認(rèn)為單例
                    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)
                // 是否緩存Bean的元數(shù)據(jù)
                if (containingBd == null && isCacheBeanMetadata()) {
                    // 將當(dāng)前的 BeanDefinitions 放入到map中，進(jìn)行緩存
                    this.mergedBeanDefinitions.put(beanName, mbd);
                }
            }
            if (previous != null) {
                copyRelevantMergedBeanDefinitionCaches(previous, mbd);
            }
            return mbd;
        }
    }

if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {<!--{cke_protected}{C}%3C!%2D%2D%20%2D%2D%3E-->

@Service("helloServiceB")
@Lazy
public class HelloServiceB {
············

@Service("helloServiceA")
public class HelloServiceA implements HelloService {
    @Autowired
    private HelloService helloServiceB;

if (this.lazyInitialization) {
			context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
	}

public final class LazyInitializationBeanFactoryPostProcessor implements BeanFactoryPostProcessor, Ordered {
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		// Take care not to force the eager init of factory beans when getting filters
		Collection<LazyInitializationExcludeFilter> filters = beanFactory
				.getBeansOfType(LazyInitializationExcludeFilter.class, false, false).values();
		for (String beanName : beanFactory.getBeanDefinitionNames()) {
			BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
			if (beanDefinition instanceof AbstractBeanDefinition) {
				postProcess(beanFactory, filters, beanName, (AbstractBeanDefinition) beanDefinition);
			}
		}
	}
	private void postProcess(ConfigurableListableBeanFactory beanFactory,
			Collection<LazyInitializationExcludeFilter> filters, String beanName,
			AbstractBeanDefinition beanDefinition) {
		Boolean lazyInit = beanDefinition.getLazyInit();
		if (lazyInit != null) {
			return;
		}
		Class<?> beanType = getBeanType(beanFactory, beanName);
		if (!isExcluded(filters, beanName, beanDefinition, beanType)) {
			beanDefinition.setLazyInit(true);
		}
	}

@Lazy(false)
@Configuration
public class DemoConfig {}

@Bean LazyInitializationExcludeFilter integrationLazyInitExcludeFilter() {<!--{cke_protected}{C}%3C!%2D%2D%20%2D%2D%3E--> return LazyInitializationExcludeFilter.forBeanTypes(DemoConfig.class); }