背景
在Spring中，Bean的加载和管理是其核心功能之一，包括配置元数据解析、Bean定义注册、实例化、属性填充、初始化、后置处理器处理、完成创建和销毁等步骤。
源码入口
AbstractBeanFactory#doGetBean
具体源码流程如下：
bean加载流程（#getBean方法）分析：
1、提取beanName
提取FactoryBean修饰符，比如name=“&aa”，那么就要去掉&，使得name=“aa”
或者，提取指定的beanName，比如别名A->B的bean则返回B
2、从缓存中加载单例
创建单例时，为避免循环依赖，不等完全bean创建，就将创建bean的ObjectFactory提早曝光；即，ObjectFactory放到缓存Map中，一旦下一个bean需要依赖上个bean，就直接使用 ObjectFactory即可。
singletonObjects：key=BeanName，value=构造完成的bean实例
earlySingletonObjects：key=BeanName，value=构造完成的bean实例，用来解决循环依赖问题
singletonFactories：key=BeanName，value=ObjectFactory工厂实例
三级缓存实现原理
当Spring容器创建Bean时，首先会从singletonObjects缓存中查找Bean实例，如果能找到则直接返回。
如果在singletonObjects缓存中没有找到Bean实例，则从earlySingletonObjects缓存中查找，如果找到了一个未完成初始化的Bean实例，则将其返回，并在后续的处理中完成初始化。
如果在earlySingletonObjects缓存中也没有找到Bean实例，则从singletonFactories缓存中查找是否存在创建Bean实例的工厂对象，如果存在，则通过工厂对象创建一个新的Bean实例，并将工厂对象从singletonFactories缓存中移除。
如果在singletonFactories缓存中也没有找到工厂对象，则需要创建一个新的工厂对象，并放到singletonFactories缓存中，以便后续使用。
创建Bean实例时，如果Bean存在循环依赖，那么Spring框架会先创建一个用于创建Bean实例的工厂对象，放到singletonFactories缓存中。然后通过工厂对象创建一个新的Bean实例，并将其放到earlySingletonObjects缓存中，以便后续处理。
下面是DefaultSingletonBeanRegistry源码
/** 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);@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {Object singletonObject = this.singletonObjects.get(beanName);// 【1】if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {// 【2】synchronized (this.singletonObjects) {// 【3】singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null && allowEarlyReference) {// 【4】ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {// 【5】singletonObject = singletonFactory.getObject();// 【6】this.earlySingletonObjects.put(beanName, singletonObject);// 【7】this.singletonFactories.remove(beanName);}}}}return singletonObject;}代码分析：
【1】isSingletonCurrentlyInCreation 判断是否循环依赖
【2】用synchronized 锁住singleObjects一级缓存全局变量，确保线程安全，因为有3个全局变量要修改的
【3】从 earlySingletonObjects 二级缓存取 object
如果object不为空，说明bean正在被创建，则跳出来
如果object为空，说明bean没在被创建，需要执行下面逻辑
【4】从 singletonFactories 三级缓存取 ObjectFactory（某些方法提前初始化了ObjectFactory策略到 singletonFactories 中）
【5】如果object不为空，说明已经有预设好的ObjectFactory，可以实例化它：通过预设的getBean ObjectFactory@getObject() 创建bean实例
【6】记录到 earlySingletonObjects 中，说明此bean正在被创建
【7】earlySingletonObjects 和 singletonFactories是互斥的，因此要remove调
3、多例对象-是否创建中检测
if (isPrototypeCurrentlyInCreation(beanName)) {throw new BeanCurrentlyInCreationException(beanName);
}单例才检测循环依赖，多例抛异常。
4、检测parentBeanFactory
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {// Not found -> check parent.String nameToLookup = originalBeanName(name);if (parentBeanFactory instanceof AbstractBeanFactory) {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 {return (T) parentBeanFactory.getBean(nameToLookup);}
}缓存没有数据，直接转到父类工厂上去加载工厂方法
5、解析Defination类的类型转换，换成可用的BeanDefination
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);6、寻找递归解决bean依赖，并加载和初始化这些依赖 -- 递归思想哦！
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {for (String dep : dependsOn) {if (isDependent(beanName, dep)) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");}registerDependentBean(dep, beanName);try {getBean(dep);}catch (NoSuchBeanDefinitionException ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"'" + beanName + "' depends on missing bean '" + dep + "'", ex);}}
}7、正式根据scope去创建bean
bean创建的特别之处
Spring 解决循环依赖依靠的是 Bean 的 " 中间态 " 这个概念，而这个中间态指的是已经实例化但还没初始化的状态 —>半成品。
实例化的过程又是通过构造器创建的，如果 A 还没创建好出来怎么可能提前曝光，所以构造器的循环依赖无法解决。
由于 spring 中的 bean 的创建过程为先实例化 再初始化 ( 在进行对象实例化的过程中不必赋值 ) 将实例化好的对象暴露出去, 供其他对象调用 , 然而使用构造器注入 , 必须要使用构造器完成对象的初始化的操作 ,就会陷入死循环的状态。
单例scope：实例化bean
if (mbd.isSingleton()) {sharedInstance = getSingleton(beanName, () -> {try {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);
}代码分析：
实例化bean：createBean -》
doCreateBean -》，参考下面的源码分析【1】
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
createBeanInstance，参考下面的源码分析【2】
getSingleton：beanName是一个参数，另一个匿名函数则是ObjectFactory<?> singletonFactory，即构造bean的工厂方法
singletonObjects：添加经过了实例化+初始化的bean实例
singletonFactories：移除
earlySingletonObjects：移除
addSingleton(beanName, singletonObject)：三级缓存的清理赋值
【1】源码addSingletonFactory：创建bean实例
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {Assert.notNull(singletonFactory, "Singleton factory must not be null");synchronized (this.singletonObjects) {if (!this.singletonObjects.containsKey(beanName)) {this.singletonFactories.put(beanName, singletonFactory);this.earlySingletonObjects.remove(beanName);this.registeredSingletons.add(beanName);}}
}代码分析：该方法用于添加单例工厂，主要功能包括：
检查传入的单例工厂是否为null，若为null则抛出异常。
同步锁住singletonObjects确保线程安全。
若singletonObjects中没有beanName对应的对象，则将singletonFactory放入singletonFactories映射中，并移除earlySingletonObjects中的对应项，最后将beanName加入registeredSingletons集合。
这也侧面说明了，bean还没有完全初始化，就把工厂方法提前暴露到了singletonFactories
【2】源码createBeanInstance：bean实例化
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {// Make sure bean class is actually resolved at this point.Class<?> beanClass = resolveBeanClass(mbd, beanName);if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());}Supplier<?> instanceSupplier = mbd.getInstanceSupplier();if (instanceSupplier != null) {return obtainFromSupplier(instanceSupplier, beanName);}if (mbd.getFactoryMethodName() != null) {return instantiateUsingFactoryMethod(beanName, mbd, args);}// Shortcut when re-creating the same bean...boolean resolved = false;boolean autowireNecessary = false;if (args == null) {synchronized (mbd.constructorArgumentLock) {if (mbd.resolvedConstructorOrFactoryMethod != null) {resolved = true;autowireNecessary = mbd.constructorArgumentsResolved;}}}if (resolved) {if (autowireNecessary) {return autowireConstructor(beanName, mbd, null, null);}else {return instantiateBean(beanName, mbd);}}// Candidate constructors for autowiring?Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {return autowireConstructor(beanName, mbd, ctors, args);}// Preferred constructors for default construction?ctors = mbd.getPreferredConstructors();if (ctors != null) {return autowireConstructor(beanName, mbd, ctors, null);}// No special handling: simply use no-arg constructor.return instantiateBean(beanName, mbd);
}代码分析：
createBeanInstance 用于创建 Bean 的实例，负责根据不同的条件和配置来实例化 Bean，并处理相关的异常情况：
解析并验证 Bean 类。
如果允许，尝试从 Supplier 获取实例。
若配置了工厂方法，则通过工厂方法实例化。
否则，根据参数情况选择构造器自动装配或直接实例化。
初始化bean：填充属性
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean#populateBean
@SuppressWarnings("deprecation") // for postProcessPropertyValues
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {//【1】if (bw == null) {if (mbd.hasPropertyValues()) {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");}else {return;}}//【2】if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {return;}}}}PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);//【3】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;}boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);PropertyDescriptor[] filteredPds = null;if (hasInstAwareBpps) {if (pvs == null) {pvs = mbd.getPropertyValues();}//【4】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;}}}if (needsDepCheck) {if (filteredPds == null) {filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);}//【5】checkDependencies(beanName, mbd, filteredPds, pvs);}if (pvs != null) {//【6】applyPropertyValues(beanName, mbd, bw, pvs);}
}代码分析：
【1】检查BeanWrapper是否为空，若为空且存在属性值，则抛出异常；否则跳过属性填充。
【2】若存在实例化需要的后置处理器，则调用它们对bean进行处理。
【3】根据自动装配模式（按名或按类型）添加属性值。
【4】调用实例化后置处理器处理属性值。
【5】检查依赖关系并进行依赖检查。
【6】应用最终的属性值到bean上
多例scope：实例化bean
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);
}代码分析：
createBean：流程参考单例scope的创建，是类似的。
8、通用：初始化bean & 注入依赖
之前已经实例化过bean了，现在则是完成注入属性；属性注入的顺序是，优先通过autowireByName，然后才是autowireByType。
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;
}9、再执行当前bean的initializeBean初始化
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {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()) {wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);}try {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()) {wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);}return wrappedBean;
}该Java函数initializeBean用于初始化一个Bean：
初始化前
根据系统安全设置，以特权操作方式或直接调用invokeAwareMethods方法，即Aware接口方法调用
执行BeanPostProcessor接口的postProcessBeforeInitialization方法，即Bean应用前置处理器
初始化时
调用InitializingBean接口的afterPropertiesSet方法，完成初始化
BeanPostProcessor接口的applyBeanPostProcessorsBeforeInitialization
调用初始化方法，对bean 进行初始化，若失败则抛出异常。
执行BeanPostProcessor接口的postProcessAfterInitialization方法，即对Bean应用后置处理器。
初始化后
DisposableBean接口的destroy方法执行（有必要的话）
