详解Spring如何创建Bean对象？

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

其实就是这个 DefaultSingletonBeanRegistry#getSingleton 方法，代码如下：

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

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

创建的逻辑在哪呢?

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

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

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

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

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

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

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

 
 
 
 
    
  
  
  
  
  1. public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
    2. 
  
  
  
  
  2.         implements AutowireCapableBeanFactory {
    3. 
  
  
  
  
  3. 
  
  
  
  
  4.     @Override
    5. 
  
  
  
  
  5.     protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    6. 
  
  
  
  
  6.             throws BeanCreationException {
    7. 
  
  
  
  
  7. 
  
  
  
  
  8.         RootBeanDefinition mbdToUse = mbd;
    9. 
  
  
  
  
  9. 
  
  
  
  
  10.         Class resolvedClass = resolveBeanClass(mbd, beanName);
    11. 
  
  
  
  
  11.         if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
    12. 
  
  
  
  
  12.             mbdToUse = new RootBeanDefinition(mbd);
    13. 
  
  
  
  
  13.             mbdToUse.setBeanClass(resolvedClass);
    14. 
  
  
  
  
  14.         }
    15. 
  
  
  
  
  15. 
  
  
  
  
  16.         // Prepare method overrides.
    17. 
  
  
  
  
  17.         try {
    18. 
  
  
  
  
  18.             mbdToUse.prepareMethodOverrides();
    19. 
  
  
  
  
  19.         }
    20. 
  
  
  
  
  20.         // catch ...
    21. 
  
  
  
  
  21. 
  
  
  
  
  22.         try {
    23. 
  
  
  
  
  23.             // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
    24. 
  
  
  
  
  24.             // 这里可能返回代理对象
    25. 
  
  
  
  
  25.             Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    26. 
  
  
  
  
  26.             if (bean != null) {
    27. 
  
  
  
  
  27.                 return bean;
    28. 
  
  
  
  
  28.             }
    29. 
  
  
  
  
  29.         }
    30. 
  
  
  
  
  30.         // catch ...
    31. 
  
  
  
  
  31. 
  
  
  
  
  32.         try {
    33. 
  
  
  
  
  33.             // 创建 bean 对象
    34. 
  
  
  
  
  34.             Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    35. 
  
  
  
  
  35.             if (logger.isTraceEnabled()) {
    36. 
  
  
  
  
  36.                 logger.trace("Finished creating instance of bean '" + beanName + "'");
    37. 
  
  
  
  
  37.             }
    38. 
  
  
  
  
  38.             return beanInstance;
    39. 
  
  
  
  
  39.         }
    40. 
  
  
  
  
  40.         // catch ...
    41. 
  
  
  
  
  41.     }
    42. 
  
  
  
  
  42. }
    43.
  • 值得注意的是，resolveBeforeInstantiation 方法其实是跟 AOP 实现相关的，可能在这里生成代理对象就返回了。由于现在主要分析 IoC 的流程，因此这里暂时略过，有兴趣的朋友们可以自行研究。

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

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

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

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

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

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

就是这样。

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

小结

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

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

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

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

网站栏目：详解Spring如何创建Bean对象？
文章来源：http://www.shufengxianlan.com/qtweb/news8/106558.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

定制网站知识

分类信息网

成都模版网站建设　　 　LED网站设计方案　　 　温江做网站　　 　手机网站制作　　 　成都微信小程序开发　　 　虚拟主机　　 　绵阳科技城电信IDC机房　　 　成都企业网站设计　　 　网站改版　　 　腾讯云免备案主机　　 　成都小程序开发　　 　软文推广公司　　 　成都主机托管　　 　成都网站建设　　 　抖音代运营　　 　香港云服务器　　 　app软件开发公司　　 　广汉网站建设　　 　手机APP开发　　 　网站报价方案