spring源码进修(二)
2019-11-18杂谈搜奇网32°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容器