文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

详解Spring 如何创建 Bean 对象?

2024-12-03 10:04

关注

前情回顾前文「Spring 如何从 IoC 容器中获取对象?」从整体上分析了如何从 Spring IoC 容器获取一个 bean 对象。该逻辑由 AbstractBeanFactory#doGetBean 方法实现,主要流程如下:


本文进一步深入细节,主要分析如何创建 singleton(单例)类型的对象。

如何创建单例对象?

从流程图可以看出,当获取一个 bean 对象时,Spring 会首先尝试从缓存中获取单例对象。

值得注意是的:

  1. 只有对象是单例的场景,即 scope 为 singleton 时才会缓存对象。
  2. 这里其实涉及到了所谓的「三级缓存」,为了更容易理解三级缓存,本文先研究这个 bean 对象是什么时候放入缓存的,后面再研究三级缓存。

既然能取,必然有地方把 bean 对象存入了缓存,那缓存中的数据是从哪里来的呢?

下面主要分析单例对象是如何创建、并放入缓存中的。

该逻辑在 AbstractBeanFactory#doGetBean 方法中,主要代码如下(保留了创建单例 bean 对象的代码,其他部分暂时忽略):

  1. public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory { 
  2.     // ... 
  3.  
  4.     protected  T doGetBean( 
  5.             String name, @Nullable Class requiredType, @Nullable Object[] args, boolean typeCheckOnly) 
  6.             throws BeansException { 
  7.  
  8.         String beanName = transformedBeanName(name); 
  9.         Object bean; 
  10.  
  11.         // 从缓存中获取单例 bean 对象 
  12.         Object sharedInstance = getSingleton(beanName); 
  13.          
  14.         // 缓存中不存在 bean 对象 
  15.         else { 
  16.  
  17.             // ... 
  18.  
  19.             try { 
  20.                 // 获取 BeanDefinition 
  21.                 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); 
  22.  
  23.                 // 获取依赖的 bean 对象 
  24.                 // 若创建一个 bean 对象时依赖其他对象,则先创建被依赖对象 
  25.                 // ... 
  26.  
  27.                 // 创建 scope 为 singleton(单例)的对象 
  28.                 if (mbd.isSingleton()) { 
  29.                     sharedInstance = getSingleton(beanName, () -> { 
  30.                         try { 
  31.                             return createBean(beanName, mbd, args); 
  32.                         } 
  33.                         catch (BeansException ex) { 
  34.                             // ... 
  35.                         } 
  36.                     }); 
  37.                     // 处理 FactoryBean 的场景 
  38.                     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); 
  39.                 } 
  40.  
  41.                 // 创建 scope 为 prototype 的对象 
  42.                 else if (mbd.isPrototype()) { 
  43.                     // ... 
  44.                 } 
  45.  
  46.                 // 创建其他类型对象 
  47.                 else { 
  48.                     // ... 
  49.                 } 
  50.             } 
  51.             catch (BeansException ex) { 
  52.                 // ... 
  53.             } 
  54.         } 
  55.  
  56.         // 类型检查 
  57.  
  58.         return (T) bean; 
  59.     } 

其实就是这个 DefaultSingletonBeanRegistry#getSingleton 方法,代码如下:

  1. public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry { 
  2.     // 单例 bean 对象缓存(beanName, bean) 
  3.     private final Map singletonObjects = new ConcurrentHashMap<>(256); 
  4.  
  5.     public Object getSingleton(String beanName, ObjectFactory singletonFactory) { 
  6.         Assert.notNull(beanName, "Bean name must not be null"); 
  7.         synchronized (this.singletonObjects) { 
  8.             // 先从缓存中获取 bean 对象 
  9.             Object singletonObject = this.singletonObjects.get(beanName); 
  10.             // 缓存中不存在时再去创建 
  11.             if (singletonObject == null) { 
  12.                 // ... 
  13.                 // 创建单例对象前 
  14.                 beforeSingletonCreation(beanName); 
  15.                 boolean newSingleton = false
  16.                 boolean recordSuppressedExceptions = (this.suppressedExceptions == null); 
  17.                 if (recordSuppressedExceptions) { 
  18.                     this.suppressedExceptions = new LinkedHashSet<>(); 
  19.                 } 
  20.                 try { 
  21.                     // 创建单例对象 
  22.                     singletonObject = singletonFactory.getObject(); 
  23.                     newSingleton = true
  24.                 } 
  25.                 // catch ... 
  26.                 finally { 
  27.                     if (recordSuppressedExceptions) { 
  28.                         this.suppressedExceptions = null
  29.                     } 
  30.                     // 创建单例对象后 
  31.                     afterSingletonCreation(beanName); 
  32.                 } 
  33.                 if (newSingleton) { 
  34.                     // 将对象添加到缓存 
  35.                     addSingleton(beanName, singletonObject); 
  36.                 } 
  37.             } 
  38.             // 缓存中有的话直接返回 
  39.             return singletonObject; 
  40.         } 
  41.     } 
  42.  

getSingleton 方法会先从缓存 singletonObjects(其实就是一个 Map)中获取 bean 对象,如果缓存有就直接返回,否则再去创建。创建成功后,会把该对象存入缓存。

创建的逻辑在哪呢?

看代码是通过 ObjectFactory#getObject 方法来创建的,ObjectFactory 是一个函数式接口:

  1. @FunctionalInterface 
  2. public interface ObjectFactory { 
  3.     T getObject() throws BeansException; 

这个方法的实现是什么呢?退回上一层,即 getBean 方法,看这里:

  1. sharedInstance = getSingleton(beanName, () -> { 
  2.     try { 
  3.         // 创建 bean 对象 
  4.         return createBean(beanName, mbd, args); 
  5.     } 
  6.     catch (BeansException ex) { 
  7.         // ... 
  8.     } 
  9. }); 

这里用到了 Lambda 表达式,将如下表达式作为参数:

  1. () -> { 
  2.     try { 
  3.         // 创建 bean 对象 
  4.         return createBean(beanName, mbd, args); 
  5.     } 
  6.     catch (BeansException ex) { 
  7.         // ... 
  8.     } 

创建 bean 对象的逻辑就在这个 createBean 方法中,它在 AbstractAutowireCapableBeanFactory 类中:

  1. public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory 
  2.         implements AutowireCapableBeanFactory { 
  3.  
  4.     @Override 
  5.     protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) 
  6.             throws BeanCreationException { 
  7.  
  8.         RootBeanDefinition mbdToUse = mbd; 
  9.  
  10.         Class resolvedClass = resolveBeanClass(mbd, beanName); 
  11.         if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { 
  12.             mbdToUse = new RootBeanDefinition(mbd); 
  13.             mbdToUse.setBeanClass(resolvedClass); 
  14.         } 
  15.  
  16.         // Prepare method overrides. 
  17.         try { 
  18.             mbdToUse.prepareMethodOverrides(); 
  19.         } 
  20.         // catch ... 
  21.  
  22.         try { 
  23.             // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. 
  24.             // 这里可能返回代理对象 
  25.             Object bean = resolveBeforeInstantiation(beanName, mbdToUse); 
  26.             if (bean != null) { 
  27.                 return bean; 
  28.             } 
  29.         } 
  30.         // catch ... 
  31.  
  32.         try { 
  33.             // 创建 bean 对象 
  34.             Object beanInstance = doCreateBean(beanName, mbdToUse, args); 
  35.             if (logger.isTraceEnabled()) { 
  36.                 logger.trace("Finished creating instance of bean '" + beanName + "'"); 
  37.             } 
  38.             return beanInstance; 
  39.         } 
  40.         // catch ... 
  41.     } 

这里继续沿着主线逻辑走。

创建 bean 对象是在 doCreateBean 方法中实现的,如下:

  1. public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory 
  2.         implements AutowireCapableBeanFactory { 
  3.  
  4.     protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) 
  5.             throws BeanCreationException { 
  6.  
  7.         // Instantiate the bean. 
  8.         // 1. 实例化 bean 
  9.         BeanWrapper instanceWrapper = null
  10.         if (mbd.isSingleton()) { 
  11.             instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); 
  12.         } 
  13.         if (instanceWrapper == null) { 
  14.             instanceWrapper = createBeanInstance(beanName, mbd, args); 
  15.         } 
  16.         Object bean = instanceWrapper.getWrappedInstance(); 
  17.         Class beanType = instanceWrapper.getWrappedClass(); 
  18.         if (beanType != NullBean.class) { 
  19.             mbd.resolvedTargetType = beanType; 
  20.         } 
  21.  
  22.         // Allow post-processors to modify the merged bean definition. 
  23.         synchronized (mbd.postProcessingLock) { 
  24.             if (!mbd.postProcessed) { 
  25.                 try { 
  26.                     applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); 
  27.                 } 
  28.                 // catch ... 
  29.                 mbd.postProcessed = true
  30.             } 
  31.         } 
  32.  
  33.         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && 
  34.                 isSingletonCurrentlyInCreation(beanName)); 
  35.         if (earlySingletonExposure) { 
  36.             addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); 
  37.         } 
  38.  
  39.         // Initialize the bean instance. 
  40.         Object exposedObject = bean; 
  41.         try { 
  42.             // 2. 填充属性 
  43.             populateBean(beanName, mbd, instanceWrapper); 
  44.             // 3. 初始化 
  45.             exposedObject = initializeBean(beanName, exposedObject, mbd); 
  46.         } 
  47.         // catch ... 
  48.  
  49.         if (earlySingletonExposure) { 
  50.             Object earlySingletonReference = getSingleton(beanName, false); 
  51.             if (earlySingletonReference != null) { 
  52.                 if (exposedObject == bean) { 
  53.                     exposedObject = earlySingletonReference; 
  54.                 } 
  55.                 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { 
  56.                     String[] dependentBeans = getDependentBeans(beanName); 
  57.                     Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); 
  58.                     for (String dependentBean : dependentBeans) { 
  59.                         if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { 
  60.                             actualDependentBeans.add(dependentBean); 
  61.                         } 
  62.                     } 
  63.                     // ... 
  64.                 } 
  65.             } 
  66.         } 
  67.  
  68.         // Register bean as disposable. 
  69.         try { 
  70.             registerDisposableBeanIfNecessary(beanName, bean, mbd); 
  71.         } 
  72.         // catch ... 
  73.  
  74.         return exposedObject; 
  75.     } 
  76.  

这个方法看起来有点长,但最主要的事情只有三件:

  1. 创建 bean 对象:createBeanInstance 方法
  2. 填充属性:populateBean 方法
  3. 初始化 bean:initializeBean 方法

这几个方法内部其实都有一大堆堆堆堆堆……的代码,再对照一下前面给出的整体流程图 :

就是这样。

本文在前文整体分析的基础上又进一步细化,先到这里吧,后面再继续分析~

小结

如何从 Spring IoC 容器中获取 bean 对象?前文对此进行了整体流程的分析。

本文在前文的基础上又进一步细化,主要从整体上探讨了 Spring 如何创建单例的 bean 对象,整体上分为三个步骤:

  1. 创建 bean 对象。
  2. 填充 bean 属性
  3. 初始化 bean 对象

至于这三个步骤具体又做了什么,且听下回分解。

 

来源:WriteOnRead内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯