日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯網營銷解決方案
詳解Spring如何創(chuàng)建Bean對象？

前情回顧前文「Spring 如何從 IoC 容器中獲取對象?」從整體上分析了如何從 Spring IoC 容器獲取一個 bean 對象。該邏輯由 AbstractBeanFactory#doGetBean 方法實現，主要流程如下：

目前成都創(chuàng)新互聯公司已為千余家的企業(yè)提供了網站建設、域名、虛擬空間、綿陽服務器托管、企業(yè)網站設計、揭西網站維護等服務，公司將堅持客戶導向、應用為本的策略，正道將秉承"和諧、參與、激情"的文化，與客戶和合作伙伴齊心協力一起成長，共同發(fā)展。

本文進一步深入細節(jié)，主要分析如何創(chuàng)建 singleton(單例)類型的對象。

如何創(chuàng)建單例對象?

從流程圖可以看出，當獲取一個 bean 對象時，Spring 會首先嘗試從緩存中獲取單例對象。

值得注意是的：

  1. 只有對象是單例的場景，即 scope 為 singleton 時才會緩存對象。
  2. 這里其實涉及到了所謂的「三級緩存」，為了更容易理解三級緩存，本文先研究這個 bean 對象是什么時候放入緩存的，后面再研究三級緩存。

既然能取，必然有地方把 bean 對象存入了緩存，那緩存中的數據是從哪里來的呢?

下面主要分析單例對象是如何創(chuàng)建、并放入緩存中的。

該邏輯在 AbstractBeanFactory#doGetBean 方法中，主要代碼如下(保留了創(chuàng)建單例 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.                 // 若創(chuàng)建一個 bean 對象時依賴其他對象，則先創(chuàng)建被依賴對象
    25. 
  
  
  
  
  25.                 // ...
    26. 
  
  
  
  
  26. 
  
  
  
  
  27.                 // 創(chuàng)建 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.                 // 創(chuàng)建 scope 為 prototype 的對象
    42. 
  
  
  
  
  42.                 else if (mbd.isPrototype()) {
    43. 
  
  
  
  
  43.                     // ...
    44. 
  
  
  
  
  44.                 }
    45. 
  
  
  
  
  45. 
  
  
  
  
  46.                 // 創(chuàng)建其他類型對象
    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.             // 緩存中不存在時再去創(chuàng)建
    11. 
  
  
  
  
  11.             if (singletonObject == null) {
    12. 
  
  
  
  
  12.                 // ...
    13. 
  
  
  
  
  13.                 // 創(chuàng)建單例對象前
    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.                     // 創(chuàng)建單例對象
    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.                     // 創(chuàng)建單例對象后
    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 對象，如果緩存有就直接返回，否則再去創(chuàng)建。創(chuàng)建成功后，會把該對象存入緩存。

創(chuàng)建的邏輯在哪呢?

看代碼是通過 ObjectFactory#getObject 方法來創(chuàng)建的，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.         // 創(chuàng)建 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.         // 創(chuàng)建 bean 對象
    4. 
  
  
  
  
  4.         return createBean(beanName, mbd, args);
    5. 
  
  
  
  
  5.     }
    6. 
  
  
  
  
  6.     catch (BeansException ex) {
    7. 
  
  
  
  
  7.         // ...
    8. 
  
  
  
  
  8.     }
    9. 
  
  
  
  
  9. }
    10.

創(chuàng)建 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.             // 創(chuàng)建 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 的流程，因此這里暫時略過，有興趣的朋友們可以自行研究。

這里繼續(xù)沿著主線邏輯走。

創(chuàng)建 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. 創(chuàng)建 bean 對象：createBeanInstance 方法
  2. 填充屬性：populateBean 方法
  3. 初始化 bean：initializeBean 方法

這幾個方法內部其實都有一大堆堆堆堆堆……的代碼，再對照一下前面給出的整體流程圖 :

就是這樣。

本文在前文整體分析的基礎上又進一步細化，先到這里吧，后面再繼續(xù)分析~

小結

如何從 Spring IoC 容器中獲取 bean 對象?前文對此進行了整體流程的分析。

本文在前文的基礎上又進一步細化，主要從整體上探討了 Spring 如何創(chuàng)建單例的 bean 對象，整體上分為三個步驟：

  1. 創(chuàng)建 bean 對象。
  2. 填充 bean 屬性
  3. 初始化 bean 對象

至于這三個步驟具體又做了什么，且聽下回分解。


文章題目：詳解Spring如何創(chuàng)建Bean對象？
網頁鏈接：http://m.5511xx.com/article/cdcejoj.html