SpringIOC refresh()初始化程式碼例項
阿新 • • 發佈:2020-03-09
finishBeanFactoryInitialization(beanFactory):初始化不需要延遲例項化的單例bean
/* org/springframework/context/support/AbstractApplicationContext.java:870 */ protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {//初始化容器的conversionService if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME,ConversionService.class)) { beanFactory.setConversionService( beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME,ConversionService.class)); } //如果沒有任何一個類似PropertyPlaceholderConfigurer bean處理器 //預設一個嵌入式值解析器,主要是為了解析屬性值例如資料庫連線中${password}等屬性解析 if (!beanFactory.hasEmbeddedValueResolver()) { beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal)); } // 先例項化LoadTimeWeaverAware相關的beans,以便儘早轉換,AOP相關 String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class,false,false); for (String weaverAwareName : weaverAwareNames) { getBean(weaverAwareName); } //刪除臨時類載入器,停止臨時類載入器進行型別匹配 beanFactory.setTempClassLoader(null); //拷貝beandefinitionNames到frozenBeanDefinitionNames beanFactory.freezeConfiguration(); // 例項化所有不需要延遲初始化的單例bean beanFactory.preInstantiateSingletons(); }
beanFactory.preInstantiateSingletons():例項化所有不需要延遲初始化的單例bean
/* org/springframework/beans/factory/support/DefaultListableBeanFactory.java:885 */ public void preInstantiateSingletons() throws BeansException { if (logger.isTraceEnabled()) { logger.trace("Pre-instantiating singletons in " + this); } // Iterate over a copy to allow for init methods which in turn register new bean definitions. // While this may not be part of the regular factory bootstrap,it does otherwise work fine. //拷貝beanDefinitionNames副本,考慮到遍歷中其他執行緒可能修改beandefinitionNames // ArrayList型別遍歷時規避fast-fail,實現fast-safe List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); // Trigger initialization of all non-lazy singleton beans... for (String beanName : beanNames) { //當bean存在parentBean時的繼承關係 //① bean不存在parentBean時,建立一個new RootBeanDefinition(beandefinition)返回。 //② bean存在parentBean時,支援繼承關係 // 需要先建立parentBean的new RootBeanDefinition(parentBeanDefinition) // 然後用beandefinition覆蓋parentBean的RootBeanDefinition的相關屬性並返回。superBean.overrideFrom(subBean); RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); //用mergedLocalBeanDefinition判斷是否需要初始化 //篩選不是抽象類且不是延遲例項化的單例進行初始化 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { if (isFactoryBean(beanName)) { //工廠Bean beanName=&beanName Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); if (bean instanceof FactoryBean) { final FactoryBean<?> factory = (FactoryBean<?>) bean; boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,getAccessControlContext()); } else { isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } if (isEagerInit) { getBean(beanName); } } } else { //不是工廠bean 直接初始化 getBean(beanName); } } } //SmartInitializingSingleton型別的單例初始化後的回撥 for (String beanName : beanNames) { Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton) { final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { smartSingleton.afterSingletonsInstantiated(); return null; },getAccessControlContext()); } else { smartSingleton.afterSingletonsInstantiated(); } } } }
getBean(beanName):Bean初始化
/* org/springframework/beans/factory/support/AbstractBeanFactory.java:414 */ protected <T> T doGetBean(final String name,@Nullable final Class<T> requiredType,@Nullable final Object[] args,boolean typeCheckOnly) throws BeansException { //如果是aliaName,解析成beanName final String beanName = transformedBeanName(name); Object bean; // Eagerly check singleton cache for manually registered singletons. //檢查單例快取中是否存在bean的例項化物件、初始化物件 (涉及迴圈依賴解決,需要先分清出Bean的兩個階段例項化、初始化) Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { if (logger.isTraceEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"); } else { logger.trace("Returning cached instance of singleton bean '" + beanName + "'"); } } bean = getObjectForBeanInstance(sharedInstance,name,beanName,null); } else { if (isPrototypeCurrentlyInCreation(beanName)) { //多例bean正在初始化時丟擲異常 //由於多例bean,每呼叫一次getBean就會建立一個例項, //所以通過ThreadLocal打標,來避免單個執行緒的重複建立 throw new BeanCurrentlyInCreationException(beanName); } BeanFactory parentBeanFactory = getParentBeanFactory(); //父容器不為空,用父容器初始化 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. String nameToLookup = originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { return ((AbstractBeanFactory) parentBeanFactory).doGetBean( nameToLookup,requiredType,args,typeCheckOnly); } else if (args != null) { // Delegation to parent with explicit args. return (T) parentBeanFactory.getBean(nameToLookup,args); } else if (requiredType != null) { // No args -> delegate to standard getBean method. return parentBeanFactory.getBean(nameToLookup,requiredType); } else { return (T) parentBeanFactory.getBean(nameToLookup); } } if (!typeCheckOnly) { //alreadyCreated容器記錄已經被例項化的beanName, //這裡將beanName新增到alreadyCreated markBeanAsCreated(beanName); } try { //重新獲取mergedLocalBeanDefinition(bean與parentBean合併) final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); //檢查mbd不是抽象類 checkMergedBeanDefinition(mbd,args); //建立bean單例之前,需要保證先bean所依賴的Bean單例已建立, //這裡的依賴對應@dependsOn宣告的依賴,這個註解不常用,這裡也會出現一種迴圈依賴場景,與我們平常討論的引用迴圈依賴不同 //@dependsOn(value = "b") class A;@dependsOn(value = "a") class B //如果出現這種迴圈依賴 會直接丟擲異常 啟動失敗 String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { for (String dep : dependsOn) { if (isDependent(beanName,dep)) { throw new BeanCreationException(mbd.getResourceDescription(),"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } //儲存依賴關係到dependentBeanMap容器中 registerDependentBean(dep,beanName); try { //例項化依賴的bean 這裡就是常見迴圈依賴地點 A依賴B B依賴A getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(mbd.getResourceDescription(),"'" + beanName + "' depends on missing bean '" + dep + "'",ex); } } } // Create bean instance. if (mbd.isSingleton()) { //單例Bean建立 先取快取,沒有才createBean sharedInstance = getSingleton(beanName,() -> { try { //建立Bean例項 return createBean(beanName,mbd,args); } catch (BeansException ex) { destroySingleton(beanName); throw ex; } }); bean = getObjectForBeanInstance(sharedInstance,mbd); } else if (mbd.isPrototype()) { //多例Bean建立 直接createbean Object prototypeInstance = null; try { //正在建立bean打標prototypesCurrentlyInCreation //與上面isPrototypeCurrentlyInCreation()聯合 beforePrototypeCreation(beanName); prototypeInstance = createBean(beanName,args); } finally { //正在建立bean打標prototypesCurrentlyInCreation刪除標記 afterPrototypeCreation(beanName); } bean = getObjectForBeanInstance(prototypeInstance,mbd); } else { //自定義scope初始化、scope.get() String scopeName = mbd.getScope(); final Scope scope = this.scopes.get(scopeName); if (scope == null) { throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); } try { Object scopedInstance = scope.get(beanName,() -> { beforePrototypeCreation(beanName); try { return createBean(beanName,args); } finally { afterPrototypeCreation(beanName); } }); bean = getObjectForBeanInstance(scopedInstance,mbd); } catch (IllegalStateException ex) { throw new BeanCreationException(beanName,"Scope '" + scopeName + "' is not active for the current thread; consider " + "defining a scoped proxy for this bean if you intend to refer to it from a singleton",ex); } } } catch (BeansException ex) { cleanupAfterBeanCreationFailure(beanName); throw ex; } } //getBean(beanName,requiredType)時檢查建立的例項是否需要的型別,容器初始化時不會走進裡面 if (requiredType != null && !requiredType.isInstance(bean)) { try { T convertedBean = getTypeConverter().convertIfNecessary(bean,requiredType); if (convertedBean == null) { throw new BeanNotOfRequiredTypeException(name,bean.getClass()); } return convertedBean; } catch (TypeMismatchException ex) { if (logger.isTraceEnabled()) { logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'",ex); } throw new BeanNotOfRequiredTypeException(name,bean.getClass()); } } return (T) bean; }
sharedInstance = getSingleton(beanName,() -> {try {return createBean(beanName,args);}:單例初始化,這個方法比較簡單,主要關注下和循壞依賴相關的邏輯
/* org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java:201 */ public Object getSingleton(String beanName,ObjectFactory<?> singletonFactory) { Assert.notNull(beanName,"Bean name must not be null"); synchronized (this.singletonObjects) { Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { if (this.singletonsCurrentlyInDestruction) { throw new BeanCreationNotAllowedException(beanName,"Singleton bean creation not allowed while singletons of this factory are in destruction " + "(Do not request a bean from a BeanFactory in a destroy method implementation!)"); } if (logger.isDebugEnabled()) { logger.debug("Creating shared instance of singleton bean '" + beanName + "'"); } //迴圈依賴相關:初始化前先singletonsCurrentlyInCreation.add(beanName) beforeSingletonCreation(beanName); boolean newSingleton = false; boolean recordSuppressedExceptions = (this.suppressedExceptions == null); if (recordSuppressedExceptions) { this.suppressedExceptions = new LinkedHashSet<>(); } try { //lamda表示式:其實是呼叫createBean(beanName,args):Bean初始化 singletonObject = singletonFactory.getObject(); newSingleton = true; } catch (IllegalStateException ex) { // Has the singleton object implicitly appeared in the meantime -> // if yes,proceed with it since the exception indicates that state. singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { throw ex; } } catch (BeanCreationException ex) { if (recordSuppressedExceptions) { for (Exception suppressedException : this.suppressedExceptions) { ex.addRelatedCause(suppressedException); } } throw ex; } finally { if (recordSuppressedExceptions) { this.suppressedExceptions = null; } //迴圈依賴相關:初始化後singletonsCurrentlyInCreation.remove(beanName) afterSingletonCreation(beanName); } if (newSingleton) { //初始化完後 //this.singletonObjects.put(beanName,singletonObject);放入到單例容器中 //this.singletonFactories.remove(beanName);清空迴圈依賴相關的兩個打標 //this.earlySingletonObjects.remove(beanName); //this.registeredSingletons.add(beanName);放入單例beanName容器中 addSingleton(beanName,singletonObject); } } return singletonObject; } }
createBean(beanName,args):初始化例項,這個表方法注意一下,初始化例項前,留機會給BeanPostProcessor初始化代理類直接返回代理類初始化例項
/* org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java:467 */ protected Object createBean(String beanName,RootBeanDefinition mbd,@Nullable Object[] args) throws BeanCreationException { if (logger.isTraceEnabled()) { logger.trace("Creating instance of bean '" + beanName + "'"); } RootBeanDefinition mbdToUse = mbd; Class<?> resolvedClass = resolveBeanClass(mbd,beanName); if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { //確保beanclass確實被解析了,若合併出錯,重新定義bean定義 mbdToUse = new RootBeanDefinition(mbd); mbdToUse.setBeanClass(resolvedClass); } // Prepare method overrides. try { //校驗需要重寫方法是否全部重寫,並且會給重寫方法是否過載打標 mbdToUse.prepareMethodOverrides(); } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),"Validation of method overrides failed",ex); } try { //resolveBeforeInstantiation方法是呼叫BeanPostProcessor處理器 //後續研究一下BeanPostProcessor //這裡是給AOP相關BeanPostProcessor處理器生成代理類例項的機會,直接生成初始化代理類例項返回 //會面研究AOP時發現,proxy object不是在這裡初始化,這裡只是提供一個機會 //proxy object具體是在的下面doCreateBean時裡先建立target object //然後通過後置處理器的後置方法初始化的 Object bean = resolveBeforeInstantiation(beanName,mbdToUse); if (bean != null) { return bean; } } catch (Throwable ex) { throw new BeanCreationException(mbdToUse.getResourceDescription(),"BeanPostProcessor before instantiation of bean failed",ex); } try { //初始化例項 Object beanInstance = doCreateBean(beanName,mbdToUse,args); if (logger.isTraceEnabled()) { logger.trace("Finished creating instance of bean '" + beanName + "'"); } return beanInstance; } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { // A previously detected exception with proper bean creation context already,// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry. throw ex; } catch (Throwable ex) { throw new BeanCreationException( mbdToUse.getResourceDescription(),"Unexpected exception during bean creation",ex); } }
doCreateBean(beanName,args):beanClass例項化(即earlysingleton,注意不是初始化)然後DI完成初始化
/* org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java:549 */ protected Object doCreateBean(final String beanName,final RootBeanDefinition mbd,final @Nullable Object[] args) throws BeanCreationException { // Instantiate the bean. BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { //反射呼叫beanClass的構造方法建立例項幷包裝成beanwrapper-- instanceWrapper = createBeanInstance(beanName,args); } final Object bean = instanceWrapper.getWrappedInstance(); Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } // Allow post-processors to modify the merged bean definition. //允許MergedBeanDefinitionPostProcessors後置管理器修改rootBeandefinition synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { applyMergedBeanDefinitionPostProcessors(mbd,beanType,beanName); } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(),"Post-processing of merged bean definition failed",ex); } mbd.postProcessed = true; } } // Eagerly cache singletons to be able to resolve circular references // even when triggered by lifecycle interfaces like BeanFactoryAware. boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { if (logger.isTraceEnabled()) { logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } //迴圈依賴相關邏輯: //this.singletonFactories.put(beanName,singletonFactory); //將例項化bean、beanName組裝成singletonFactory裝入singletonFactories容器 //this.earlySingletonObjects.remove(beanName); //刪除earlySingletonObjects中beanName addSingletonFactory(beanName,() -> getEarlyBeanReference(beanName,bean)); } // Initialize the bean instance. //建立例項 Object exposedObject = bean; try { //例項初始化 就是在這裡面實現依賴注入DI的: //具體是呼叫AutowiredAnnotationBeanPostProcessor.postProcessProperties populateBean(beanName,instanceWrapper);//呼叫Bean後置管理器前置方法BeanPostProcessor.postProcessBeforeInitialization //instanceof aware介面,setBeanName setBeanClassLoader setBeanFactory //呼叫Bean後置管理器後置方法BeanPostProcessor.postProcessAfterInitialization exposedObject = initializeBean(beanName,exposedObject,mbd); } catch (Throwable ex) { if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { throw (BeanCreationException) ex; } else { throw new BeanCreationException( mbd.getResourceDescription(),"Initialization of bean failed",ex); } } //... return exposedObject; }
populateBean(beanName,instanceWrapper):依賴注入DI執行時機
/* org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java:1381 */ protected void populateBean(String beanName,@Nullable BeanWrapper bw) { //... PropertyDescriptor[] filteredPds = null; if (hasInstAwareBpps) { if (pvs == null) { pvs = mbd.getPropertyValues(); } for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; //這裡呼叫AutowiredAnnotationBeanPostProcessor.postProcessProperties() //完成註解自動注入(DI) PropertyValues pvsToUse = ibp.postProcessProperties(pvs,bw.getWrappedInstance(),beanName); if (pvsToUse == null) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw,mbd.allowCaching); } pvsToUse = ibp.postProcessPropertyValues(pvs,filteredPds,beanName); if (pvsToUse == null) { return; } } pvs = pvsToUse; } } } if (needsDepCheck) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw,mbd.allowCaching); } checkDependencies(beanName,pvs); } if (pvs != null) { applyPropertyValues(beanName,bw,pvs); } }
DI結束,bean初始化基本結束了。然後就是bean初始化的BeanPostProcessor執行前置後置方法
BeanPostProcessor前置後置方法:一些很重要架構都需要依靠實現,例如AOP動態代理產生代理物件
AnnotationAwareAspectJAutoProxyCreator.postProcessAfterInitialization
/* org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String,java.lang.Object,org.springframework.beans.factory.support.RootBeanDefinition) */ protected Object initializeBean(final String beanName,final Object bean,@Nullable RootBeanDefinition mbd) { if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { invokeAwareMethods(beanName,bean); return null; },getAccessControlContext()); } else { invokeAwareMethods(beanName,bean); } Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { //呼叫所有BeanPostProcessor前置方法BeanPostProcessor.postProcessBeforeInitialization wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean,beanName); } try { invokeInitMethods(beanName,wrappedBean,mbd); } catch (Throwable ex) { throw new BeanCreationException( (mbd != null ? mbd.getResourceDescription() : null),"Invocation of init method failed",ex); } if (mbd == null || !mbd.isSynthetic()) { //呼叫所有BeanPostProcessor前置方法BeanPostProcessor.postProcessAfterInitialization //例如AOP代理物件就是這裡初始化的,AnnotationAwareAspectJAutoProxyCreator.postProcessAfterInitialization wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean,beanName); } return wrappedBean; }
以上就是本文的全部內容,希望對大家的學習有所幫助,也希望大家多多支援我們。