hi,你好!欢迎访问本站!登录
本站由网站地图腾讯云宝塔系统阿里云强势驱动
当前位置:首页 - 教程 - 杂谈 - 正文 君子好学,自强不息!

spring源码进修(二)

2019-11-18杂谈搜奇网23°c
A+ A-

本篇文章,来引见finishBeanFactoryInitialization(beanFactory);这个要领主假如完成bean的实例化,

invokeBeanFactoryPostProcessors(beanFactory);担任把一切的bean扫描到beanDefinitionMap中;

 

下面来说是怎样初始化的

org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean

我们直接从这个要领最先提及,前面的挪用链简朴,就不说了

 1 protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
 2             @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
 3 
 4     /**
 5      * 经由过程name猎取beanName,这里不运用name直接作为beanName有两个缘由:
 6      *  1.name能够是以&开首的,表明挪用者想猎取FactoryBean自身,而非FactoryBean;在beanFactory中factoryBean的存储也是map花样
 7      *    <beanName,bean> 只是说,一般的beanName是没有&这个字符串的,所以,须要将name的首字母移除,如许才从缓存中拿到factoryBean
 8      *  2.照样别号的题目,须要转换
 9      */
10     final String beanName = transformedBeanName(name);
11     Object bean;
12 
13     /**
14      * 1.从单例池中猎取当前bean
15      * 2.这里是轮回依靠的主要要领之一
16      *
17      */
18     // Eagerly check singleton cache for manually registered singletons.
19     Object sharedInstance = getSingleton(beanName);
20     if (sharedInstance != null && args == null) {
21         if (logger.isDebugEnabled()) {
22             if (isSingletonCurrentlyInCreation(beanName)) {
23                 logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
24                         "' that is not fully initialized yet - a consequence of a circular reference");
25             }
26             else {
27                 logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
28             }
29         }
30         bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
31     }
32 
33     else {
34         // Fail if we're already creating this bean instance:
35         // We're assumably within a circular reference.
36         /**
37          * 这里揣摸bean是不是在建立过程当中,是第二次挪用的时刻 才会揣摸;假如是第一次实行到这里,set鸠合是空(这里揣摸的是原型bean)
38          */
39         if (isPrototypeCurrentlyInCreation(beanName)) {
40             throw new BeanCurrentlyInCreationException(beanName);
41         }
42 
43         //添加到alreadyCreated鸠合当中,示意当前bean已建立过一次了
44         if (!typeCheckOnly) {
45             markBeanAsCreated(beanName);
46         }
47 
48         try {
49             final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
50             checkMergedBeanDefinition(mbd, beanName, args);
51 
52             // Guarantee initialization of beans that the current bean depends on.
53             String[] dependsOn = mbd.getDependsOn();
54             if (dependsOn != null) {
55                 for (String dep : dependsOn) {
56                     if (isDependent(beanName, dep)) {
57                         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
58                                 "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
59                     }
60                     registerDependentBean(dep, beanName);
61                     try {
62                         getBean(dep);
63                     }
64                     catch (NoSuchBeanDefinitionException ex) {
65                         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
66                                 "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
67                     }
68                 }
69             }
70 
71             // Create bean instance.假如当前bean是单实例的,就挪用createBean
72             if (mbd.isSingleton()) {
73                 sharedInstance = getSingleton(beanName, () -> {
74                     try {
75                         return createBean(beanName, mbd, args);
76                     }
77                     catch (BeansException ex) {
78                         // Explicitly remove instance from singleton cache: It might have been put there
79                         // eagerly by the creation process, to allow for circular reference resolution.
80                         // Also remove any beans that received a temporary reference to the bean.
81                         destroySingleton(beanName);
82                         throw ex;
83                     }
84                 });
85                 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
86             }
87         }
88         catch (BeansException ex) {
89             cleanupAfterBeanCreationFailure(beanName);
90             throw ex;
91         }
92     }
93 
94 
95     return (T) bean;
96 }

粘贴出来的要领删减了一部分代码,我们只说单实例bean的初始化;

在揣摸当前bean是单实例的时刻,会挪用createBean;在getSingleton这里,有一行代码,是把当前bean添加到一个set鸠合中(这个set鸠合示意当前bean正在建立过程当中),

这个set是用来处理轮回依靠题目的,在背面,会零丁抽出一篇来引见轮回引用是怎样处理的,在这里就先跳过;

 

在createBean的要领中,会挪用createBeanInstance(beanName, mbd, args); 这个要领主假如完成bean的初始化,在要领中会挪用org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#determineCandidateConstructors;

这个后置处理器的determineCandidateConstructors要领来揣摸运用哪一个组织函数来初始化;

这个要领内里,我现在也正在进修,后续会贴出对这个要领的进修笔记,这里先临时跳过;(我们就以为createBeanInstance要领完成了bean的建立),

揣摸出运用哪一个组织函数以后,会初始化bean,返回的是一个BeanWrapper对象。这里建立出来的仅仅是bean对象;须要经由背面的属性注入,以及初始化,才会变成我们所说的spring bean对象;

 

 1 protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
 2             throws BeanCreationException {
 3 
 4     // Instantiate the bean.
 5     BeanWrapper instanceWrapper = null;
 6     if (mbd.isSingleton()) {
 7         instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
 8     }
 9     if (instanceWrapper == null) {
10         /**
11          *  建立bean实例,并将bean实例包裹在BeanWrapper完成类对象中返回,
12          *  createBeanInstance中包括三种建立bean的体式格局
13          *    1.经由过程工场要领建立bean实例
14          *    2.经由过程组织要领自动注入的体式格局建立bean实例
15          *    3.经由过程无参组织要领建立bean实例
16          *
17          *  假如bean的设置中设置了lookup-method和replace-method  则会运用加强bean实例
18          *
19          * 在这个要领中完成了对bean的建立(仅仅是new出来,也就是说在这个要领内里揣摸要运用哪一个组织函数来建立bean对象)
20          * 然后完成bean的初始化
21          *
22          */
23         instanceWrapper = createBeanInstance(beanName, mbd, args);
24     }
25     final Object bean = instanceWrapper.getWrappedInstance();
26     Class<?> beanType = instanceWrapper.getWrappedClass();
27     if (beanType != NullBean.class) {
28         mbd.resolvedTargetType = beanType;
29     }
30 
31     // Allow post-processors to modify the merged bean definition.
32     synchronized (mbd.postProcessingLock) {
33         if (!mbd.postProcessed) {
34             try {
35                 //mpy 第三次挪用后置处理器  缓存注解信息
36                 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
37             }
38             catch (Throwable ex) {
39                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
40                         "Post-processing of merged bean definition failed", ex);
41             }
42             mbd.postProcessed = true;
43         }
44     }
45 
46     // Eagerly cache singletons to be able to resolve circular references
47     // even when triggered by lifecycle interfaces like BeanFactoryAware.
48     boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
49             isSingletonCurrentlyInCreation(beanName));
50     if (earlySingletonExposure) {
51         if (logger.isDebugEnabled()) {
52             logger.debug("Eagerly caching bean '" + beanName +
53                     "' to allow for resolving potential circular references");
54         }
55         //mpy 第四次挪用后置处理器 猎取一个提早暴露的对象  用来处理轮回依靠
56         addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
57     }
58 
59     // Initialize the bean instance.
60     Object exposedObject = bean;
61     try {
62         //在populateBean(beanName, mbd, instanceWrapper);要领中完成第五次第六次挪用后置处理器
63         populateBean(beanName, mbd, instanceWrapper);
64         //在initialzeBean中完成第七次第八次后置处理器挪用
65         exposedObject = initializeBean(beanName, exposedObject, mbd);
66     }
67     catch (Throwable ex) {
68         if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
69             throw (BeanCreationException) ex;
70         }
71         else {
72             throw new BeanCreationException(
73                     mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
74         }
75     }
76     return exposedObject;
77 }

 

上面这个要领中,挪用第四次后置处理器这里,返回了一个object对象,这个要领是为了完成轮回依靠的,放到背面一同讲,

在populateBean中,会完成属性的注入,比方@AutoWired,@Value这个属性值注入

initializeBean要领,主假如挪用bean的初始化要领

  bean的初始化有三种体式格局:

   1.@Bean注解中指定 initMethod destroyMethod

   2.@PostConstruct @PreDestroy

   3.完成DisposableBean和InitializingBean接口

 

 

在要领实行完以后,会把建立好的bean对象寄存到singletonObjects这个map中,这个map寄存的是一切实例化好的对象;假如bean是原型的,在第二次getBean的时刻,会从这个map中猎取到bean对象

 

从狭义上来说,singletonObjects就是我们所说的spring容器

 

  选择打赏方式
微信赞助

打赏

QQ钱包

打赏

支付宝赞助

打赏

  移步手机端
spring源码进修(二)

1、打开你手机的二维码扫描APP
2、扫描左则的二维码
3、点击扫描获得的网址
4、可以在手机端阅读此文章
未定义标签

本文来源:搜奇网

本文地址:https://www.sou7.cn/282111.html

关注我们:微信搜索“搜奇网”添加我为好友

版权声明: 本文仅代表作者个人观点,与本站无关。其原创性以及文中陈述文字和内容未经本站证实,对本文以及其中全部或者部分内容、文字的真实性、完整性、及时性本站不作任何保证或承诺,请读者仅作参考,并请自行核实相关内容。请记住本站网址https://www.sou7.cn/搜奇网。

发表评论

选填

必填

必填

选填

请拖动滑块解锁
>>