详解Spring 如何创建 Bean 对象?

开发 前端
本文在前文的基础上又进一步细化,主要从整体上探讨了 Spring 如何创建单例的 bean 对象。

[[385910]]

前情回顾前文「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> T doGetBean( 
  5.             String name, @Nullable Class<T> 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<String, Object> 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<T> { 
  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.     } 
  • 值得注意的是,resolveBeforeInstantiation 方法其实是跟 AOP 实现相关的,可能在这里生成代理对象就返回了。由于现在主要分析 IoC 的流程,因此这里暂时略过,有兴趣的朋友们可以自行研究。

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

创建 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<String> 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.  
  • 注意:Instantiate 和 Initialize 虽然看起来有点像,但它俩不是一回事,前者是“实例化”,后者是“初始化”。

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

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

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

就是这样。

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

小结

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

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

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

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

 

责任编辑:姜华 来源: WriteOnRead
相关推荐

2011-03-18 09:27:00

Spring

2021-02-03 08:02:50

Spring Bean框架

2023-10-07 08:35:07

依赖注入Spring

2023-02-27 08:09:42

SpringAOP代理

2023-11-03 08:19:18

SpringBean容器

2011-04-12 09:53:32

Spring

2020-12-11 08:04:22

SpringAOPBean

2024-05-29 08:19:03

2021-12-08 11:18:21

Spring Bean面试题生命周期

2024-05-28 07:55:31

SpringBean用域

2019-07-24 08:34:35

Java对象数据结构

2021-05-11 07:42:59

BeanSpring属性

2022-05-27 08:25:55

容器Spring

2024-02-23 10:33:34

SpringBean容器

2022-06-23 10:47:57

Spring容器工具

2011-08-01 09:50:46

iPhone 获取对象 UIView

2009-06-17 17:04:37

BeanFactorySpring

2023-09-28 08:15:05

SpringBean加载

2021-12-06 08:30:49

SpringSpring Bean面试题

2009-06-17 17:20:14

BeanFactorySpring
点赞
收藏

51CTO技术栈公众号