这篇文章主要讲解了“Spring 如何创建 Bean 对象”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Spring 如何创建 Bean 对象”吧！
从整体上分析了如何从 Spring IoC 容器获取一个 bean 对象。该逻辑由 AbstractBeanFactory#doGetBean 方法实现，主要流程如下：
本文进一步深入细节，主要分析如何创建 singleton(单例)类型的对象。
如何创建单例对象?
从流程图可以看出，当获取一个 bean 对象时，Spring 会首先尝试从缓存中获取单例对象。
值得注意是的：
鸿蒙官方战略合作共建——HarmonyOS技术社区
只有对象是单例的场景，即 scope 为 singleton 时才会缓存对象。
这里其实涉及到了所谓的「三级缓存」，为了更容易理解三级缓存，本文先研究这个 bean 对象是什么时候放入缓存的，后面再研究三级缓存。
既然能取，必然有地方把 bean 对象存入了缓存，那缓存中的数据是从哪里来的呢?
下面主要分析单例对象是如何创建、并放入缓存中的。
该逻辑在 AbstractBeanFactory#doGetBean 方法中，主要代码如下(保留了创建单例 bean 对象的代码，其他部分暂时忽略)：
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory { // ... protected <T> T doGetBean( String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException { String beanName = transformedBeanName(name); Object bean; // 从缓存中获取单例 bean 对象 Object sharedInstance = getSingleton(beanName); // 缓存中不存在 bean 对象 else { // ... try { // 获取 BeanDefinition RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // 获取依赖的 bean 对象 // 若创建一个 bean 对象时依赖其他对象，则先创建被依赖对象 // ... // 创建 scope 为 singleton（单例）的对象 if (mbd.isSingleton()) { sharedInstance = getSingleton(beanName, () -> { try { return createBean(beanName, mbd, args); } catch (BeansException ex) { // ... } }); // 处理 FactoryBean 的场景 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } // 创建 scope 为 prototype 的对象 else if (mbd.isPrototype()) { // ... } // 创建其他类型对象 else { // ... } } catch (BeansException ex) { // ... } } // 类型检查 return (T) bean; } }其实就是这个 DefaultSingletonBeanRegistry#getSingleton 方法，代码如下：
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry { // 单例 bean 对象缓存（beanName, bean） private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { Assert.notNull(beanName, "Bean name must not be null"); synchronized (this.singletonObjects) { // 先从缓存中获取 bean 对象 Object singletonObject = this.singletonObjects.get(beanName); // 缓存中不存在时再去创建 if (singletonObject == null) { // ... // 创建单例对象前 beforeSingletonCreation(beanName); boolean newSingleton = false; boolean recordSuppressedExceptions = (this.suppressedExceptions == null); if (recordSuppressedExceptions) { this.suppressedExceptions = new LinkedHashSet<>(); } try { // 创建单例对象 singletonObject = singletonFactory.getObject(); newSingleton = true; } // catch ... finally { if (recordSuppressedExceptions) { this.suppressedExceptions = null; } // 创建单例对象后 afterSingletonCreation(beanName); } if (newSingleton) { // 将对象添加到缓存 addSingleton(beanName, singletonObject); } } // 缓存中有的话直接返回 return singletonObject; } } }getSingleton 方法会先从缓存 singletonObjects(其实就是一个 Map)中获取 bean 对象，如果缓存有就直接返回，否则再去创建。创建成功后，会把该对象存入缓存。
创建的逻辑在哪呢?
看代码是通过 ObjectFactory#getObject 方法来创建的，ObjectFactory 是一个函数式接口：
@FunctionalInterface public interface ObjectFactory<T> { T getObject() throws BeansException; }这个方法的实现是什么呢?退回上一层，即 getBean 方法，看这里：
sharedInstance = getSingleton(beanName, () -> { try { // 创建 bean 对象 return createBean(beanName, mbd, args); } catch (BeansException ex) { // ... } });这里用到了 Lambda 表达式，将如下表达式作为参数：
() -> { try { // 创建 bean 对象 return createBean(beanName, mbd, args); } catch (BeansException ex) { // ... } }创建 bean 对象的逻辑就在这个 createBean 方法中，它在 AbstractAutowireCapableBeanFactory 类中：
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory { @Override protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { RootBeanDefinition mbdToUse = mbd; Class<?> resolvedClass = resolveBeanClass(mbd, beanName); if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { mbdToUse = new RootBeanDefinition(mbd); mbdToUse.setBeanClass(resolvedClass); } // Prepare method overrides. try { mbdToUse.prepareMethodOverrides(); } // catch ... try { // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. // 这里可能返回代理对象 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null) { return bean; } } // catch ... try { // 创建 bean 对象 Object beanInstance = doCreateBean(beanName, mbdToUse, args); if (logger.isTraceEnabled()) { logger.trace("Finished creating instance of bean '" + beanName + "'"); } return beanInstance; } // catch ... } }值得注意的是，resolveBeforeInstantiation 方法其实是跟 AOP 实现相关的，可能在这里生成代理对象就返回了。由于现在主要分析 IoC 的流程，因此这里暂时略过，有兴趣的朋友们可以自行研究。
这里继续沿着主线逻辑走。
创建 bean 对象是在 doCreateBean 方法中实现的，如下：
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory { protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { // Instantiate the bean. // 1. 实例化 bean BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { instanceWrapper = createBeanInstance(beanName, mbd, args); } Object bean = instanceWrapper.getWrappedInstance(); Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } // Allow post-processors to modify the merged bean definition. synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } // catch ... mbd.postProcessed = true; } } boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } // Initialize the bean instance. Object exposedObject = bean; try { // 2. 填充属性 populateBean(beanName, mbd, instanceWrapper); // 3. 初始化 exposedObject = initializeBean(beanName, exposedObject, mbd); } // catch ... if (earlySingletonExposure) { Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) { if (exposedObject == bean) { exposedObject = earlySingletonReference; } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { String[] dependentBeans = getDependentBeans(beanName); Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } // ... } } } // Register bean as disposable. try { registerDisposableBeanIfNecessary(beanName, bean, mbd); } // catch ... return exposedObject; } }注意：Instantiate 和 Initialize 虽然看起来有点像，但它俩不是一回事，前者是“实例化”，后者是“初始化”。
这个方法看起来有点长，但最主要的事情只有三件：
鸿蒙官方战略合作共建——HarmonyOS技术社区
创建 bean 对象：createBeanInstance 方法
填充属性：populateBean 方法
初始化 bean：initializeBean 方法
这几个方法内部其实都有一大堆堆堆堆堆……的代码，再对照一下前面给出的整体流程图 :
就是这样。
本文在前文整体分析的基础上又进一步细化，先到这里吧，后面再继续分析~
小结
如何从 Spring IoC 容器中获取 bean 对象?前文对此进行了整体流程的分析。
本文在前文的基础上又进一步细化，主要从整体上探讨了 Spring 如何创建单例的 bean 对象，整体上分为三个步骤：
创建 bean 对象。
填充 bean 属性
初始化 bean 对象
感谢各位的阅读，以上就是“Spring 如何创建 Bean 对象”的内容了，经过本文的学习后，相信大家对Spring 如何创建 Bean 对象这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是亿速云，小编将为大家推送更多相关知识点的文章，欢迎关注！
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
