spring容器refresh建立過程學習筆記

Spring容器的refresh()【建立重新整理】

文章目錄

- Spring容器的refresh()【建立重新整理】
- - this.refresh()
  - - BeanFactory建立和預先準備
    - - this.prepareRefresh();重新整理前的預處理
      - this.obtainFreshBeanFactory();擷取到BeanFactory
      - this.prepareBeanFactory(beanFactory);預準備工作
      - this.postProcessBeanFactory(beanFactory);BeanFactory準備工作完成後的後置處理工作
    - 後面的工作
    - - this.invokeBeanFactoryPostProcessors(beanFactory);執行BeanFactory的後置處理器
      - this.registerBeanPostProcessors(beanFactory);注冊Bean的後置處理器【攔截Bean的建立過程】
      - this.initMessageSource();初始化MessageSource元件（國際化功能）
      - this.initApplicationEventMulticaster();初始化時間派發器
      - this.onRefresh();讓子容器重寫容器重新整理時自定義的邏輯
      - this.registerListeners();注冊所有的ApplicationListener元件
      - this.finishBeanFactoryInitialization(beanFactory);初始化剩下的單執行個體Bean
      - this.finishRefresh();完成BeanFactory的初始化建立工作，IOC容器建立完成

this.refresh()

public void refresh() throws BeansException, IllegalStateException {
    synchronized(this.startupShutdownMonitor) {   // 一個線程安全的鎖機制
        this.prepareRefresh();
        ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
        this.prepareBeanFactory(beanFactory);

        try {
            this.postProcessBeanFactory(beanFactory);
            this.invokeBeanFactoryPostProcessors(beanFactory);
            this.registerBeanPostProcessors(beanFactory);
            this.initMessageSource();
            this.initApplicationEventMulticaster();
            this.onRefresh();
            this.registerListeners();
            this.finishBeanFactoryInitialization(beanFactory);
            this.finishRefresh();
        } catch (BeansException var9) {
            if (this.logger.isWarnEnabled()) {
                this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
            }

            this.destroyBeans();
            this.cancelRefresh(var9);
            throw var9;
        } finally {
            this.resetCommonCaches();
        }

    }
}

BeanFactory建立和預先準備

this.prepareRefresh();重新整理前的預處理

protected void prepareRefresh() {
    this.startupDate = System.currentTimeMillis();
    this.closed.set(false);
    this.active.set(true);
    if (this.logger.isDebugEnabled()) {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Refreshing " + this);
        } else {
            this.logger.debug("Refreshing " + this.getDisplayName());
        }
    }

    this.initPropertySources();
    this.getEnvironment().validateRequiredProperties();
    if (this.earlyApplicationListeners == null) {
        this.earlyApplicationListeners = new LinkedHashSet(this.applicationListeners);
    } else {
        this.applicationListeners.clear();
        this.applicationListeners.addAll(this.earlyApplicationListeners);
    }

    this.earlyApplicationEvents = new LinkedHashSet();
}

自定義時使用，初始化一些屬性設定，由子類自定義個性化的屬性，父類不提供具體實作。
```
this.initPropertySources();
-->
	protected void initPropertySources() {
	}
           
```
校驗屬性的合法性
1. 儲存容器中一些早期的事件，當派發器準備好後将這些事件給派發出去
```
this.earlyApplicationListeners = new LinkedHashSet(this.applicationListeners);
           
```

this.obtainFreshBeanFactory();擷取到BeanFactory

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        this.refreshBeanFactory();
        return this.getBeanFactory();
    }

重新整理【建立】BeanFactory

将beanFactory這個對象給建立好了在GenericApplicationContext類的構造方法中
```
this.beanFactory = new DefaultListableBeanFactory(); 
           
```
同時給這個beanFactory對象設定一個序列号ID
擷取剛才GenericApplicationContext建立的beanFactory對象并且return傳回
1. ```
return this.getBeanFactory();
           
```
預設beanFactory的名稱為DefaultListableBeanFactory

this.prepareBeanFactory(beanFactory);預準備工作

對beanFactory進行各種各樣的設定

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    beanFactory.setBeanClassLoader(this.getClassLoader());
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment()));
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
    if (beanFactory.containsBean("loadTimeWeaver")) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

    if (!beanFactory.containsLocalBean("environment")) {
        beanFactory.registerSingleton("environment", this.getEnvironment());
    }

    if (!beanFactory.containsLocalBean("systemProperties")) {
        beanFactory.registerSingleton("systemProperties", this.getEnvironment().getSystemProperties());
    }

    if (!beanFactory.containsLocalBean("systemEnvironment")) {
        beanFactory.registerSingleton("systemEnvironment", this.getEnvironment().getSystemEnvironment());
    }

}

設定類加載器，支援表達式解析器等等。
添加部分的後置處理器beanFactory.addBeanPostProcessor()。
設定需要忽略的自動裝配接口。不能通過Aware自動注入。
注冊可以解析的自動裝配。在任何元件中可以自動注入
添加編譯時的AspectJ支援
給BeanFactory注冊一些能用的元件：environment、systemProperties、systemEnvironment等等

this.postProcessBeanFactory(beanFactory);BeanFactory準備工作完成後的後置處理工作

子類可以重寫來在BeanFactory建立并預準備完成以後做進一步的設定

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}

後面的工作

this.invokeBeanFactoryPostProcessors(beanFactory);執行BeanFactory的後置處理器

BeanFactoryPostProcessors的作用：在BeanFactory标準初始化之後執行【以上的四步】

執行兩大接口的方法【先子後父】：BeanFactoryPostProcessors和它的子接口BeanDefinitionRegistryPostProcessor

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

}

執行PostProcessorRegistrationDelegate的BeanFactoryPostProcessor的方法

PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());

先執行BeanDefinitionRegistryPostProcessor

擷取所有的BeanDefinitionRegistryPostProcessor

postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

優先執行實作了PriorityOrdered優先級接口的BeanDefinitionRegistryPostProcessor

if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {

invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
--->
	postProcessor.postProcessBeanDefinitionRegistry(registry);

再執行實作了Ordered優先級接口的BeanDefinitionRegistryPostProcessor

if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class))

invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
--->
	postProcessor.postProcessBeanDefinitionRegistry(registry);

最後執行沒有實作任何優先級接口或者是順序的BeanDefinitionRegistryPostProcessor

再執行BeanFactoryPostProcessor

流程和上面類似

this.registerBeanPostProcessors(beanFactory);注冊Bean的後置處理器【攔截Bean的建立過程】

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;  // 統計數量
    beanFactory.addBeanPostProcessor(new PostProcessorRegistrationDelegate.BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));  // 給Bean工廠自己加了個檢查的後置處理器
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList();
    List<BeanPostProcessor> internalPostProcessors = new ArrayList();
    List<String> orderedPostProcessorNames = new ArrayList();
    List<String> nonOrderedPostProcessorNames = new ArrayList();
    String[] var8 = postProcessorNames;
    int var9 = postProcessorNames.length;

    String ppName;
    BeanPostProcessor pp;
    for(int var10 = 0; var10 < var9; ++var10) {
        ppName = var8[var10];
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        } else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, (List)priorityOrderedPostProcessors);
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList();
    Iterator var14 = orderedPostProcessorNames.iterator();

    while(var14.hasNext()) {
        String ppName = (String)var14.next();
        BeanPostProcessor pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }

    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, (List)orderedPostProcessors);
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList();
    Iterator var17 = nonOrderedPostProcessorNames.iterator();

    while(var17.hasNext()) {
        ppName = (String)var17.next();
        pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }

    registerBeanPostProcessors(beanFactory, (List)nonOrderedPostProcessors);
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, (List)internalPostProcessors);
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

BeanPostProcessor的幾個接口：

不同的後置處理器在Bean建立前後的後置處理器是不一樣的

BeanPostProcessor
DestructionAwareBeanPostProcessor【Bean銷毀方法】
InstantiationAwareBeanPostProcessor【擷取Bean的代理對象】：在Bean的執行個體建立之前執行
SmartInstantiationAwareBeanPostProcessor
MergedBeanDefinitionPostProcessor【internalPostProcessors】：Bean執行個體建立之後執行

執行流程

擷取所有的後置處理器

String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

先注冊實作PriorityOrdered優先級接口的postProcessor

if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {

注冊就是将後置處理器添加到Bean工廠中

registerBeanPostProcessors(beanFactory, (List)priorityOrderedPostProcessors);
--> 
	beanFactory.addBeanPostProcessor(postProcessor);

再注冊實作Ordered優先級接口的postProcessor
最後注冊實作PriorityOrdered優先級接口的postProcessor

再在最後注冊MergedBeanDefinitionPostProcessor

registerBeanPostProcessors(beanFactory, (List)internalPostProcessors);

再會額為注冊一個ApplicationListenerDetector，判斷Bean建立完後是否是ApplicationListener類型，是的話
```
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
           
```

this.initMessageSource();初始化MessageSource元件（國際化功能）

protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
    if (beanFactory.containsLocalBean("messageSource")) {
        this.messageSource = (MessageSource)beanFactory.getBean("messageSource", MessageSource.class);
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource)this.messageSource;
            if (hms.getParentMessageSource() == null) {
                hms.setParentMessageSource(this.getInternalParentMessageSource());
            }
        }

        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Using MessageSource [" + this.messageSource + "]");
        }
    } else {
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(this.getInternalParentMessageSource());
        this.messageSource = dms;
        beanFactory.registerSingleton("messageSource", this.messageSource);
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("No 'messageSource' bean, using [" + this.messageSource + "]");
        }
    }

}

先擷取BeanFactory

ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();

檢視容器中是否有ID為messageSource的元件

MessageSource的作用：按照區域資訊取出國際化配置中某個Key的值

if (beanFactory.containsLocalBean("messageSource")) {

有的話直接指派

hms.setParentMessageSource(this.getInternalParentMessageSource());

沒有的話就建立一個然後指派

DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(this.getInternalParentMessageSource());

把建立好的messageSource注入到容器當中，需要擷取國際化配置的key的值時可以自動注入messageSource後擷取
```
beanFactory.registerSingleton("messageSource", this.messageSource);
           
```

this.initApplicationEventMulticaster();初始化時間派發器

先擷取BeanFactory

ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();

從BeanFactory中擷取applicationEventMulticaster的ApplicationEventMulticaster元件，擷取自己配置的時間派發器

this.applicationEventMulticaster = (ApplicationEventMulticaster)beanFactory.getBean("applicationEventMulticaster", ApplicationEventMulticaster.class);

沒有自定義配置就會自動建立一個，并注冊到容器中，供其他元件自動注入

this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton("applicationEventMulticaster", this.applicationEventMulticaster);

this.onRefresh();讓子容器重寫容器重新整理時自定義的邏輯

protected void onRefresh() throws BeansException {
}

this.registerListeners();注冊所有的ApplicationListener元件

拿到所有的ApplicationListener元件的名字【注意是名字，因為還沒有建立】

String[] listenerBeanNames = this.getBeanNamesForType(ApplicationListener.class, true, false);

将每個監聽器添加到事件派發器中

this.getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);

派發之間的早期事件【預設不會有】

this.getApplicationEventMulticaster().multicastEvent(earlyEvent);

this.finishBeanFactoryInitialization(beanFactory);初始化剩下的單執行個體Bean

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
        beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
    }

    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver((strVal) -> {
            return this.getEnvironment().resolvePlaceholders(strVal);
        });
    }

    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    String[] var3 = weaverAwareNames;
    int var4 = weaverAwareNames.length;

    for(int var5 = 0; var5 < var4; ++var5) {
        String weaverAwareName = var3[var5];
        this.getBean(weaverAwareName);
    }

    beanFactory.setTempClassLoader((ClassLoader)null);
    beanFactory.freezeConfiguration();
    beanFactory.preInstantiateSingletons();
}

初始化剩下的單執行個體Bean

beanFactory.preInstantiateSingletons();

擷取剩下的Bean的名字，依次周遊來建立和初始化Bean

List<String> beanNames = new ArrayList(this.beanDefinitionNames);

拿到所有Bean的定義資訊

do {
    while(true) {
        RootBeanDefinition bd;
        do {
            do {

判斷Bean是不是抽象、單執行個體、懶加載

} while(bd.isAbstract());
    } while(!bd.isSingleton());
} while(bd.isLazyInit());

判斷Bean是不是BeanFactory

if (this.isFactoryBean(beanName)) {

不是工廠Bean，利用getBean(beanName);建立對象，和app.getBean()的那個一樣

this.getBean(beanName);
-->
   return this.doGetBean(name, (Class)null, (Object[])null, false);

先擷取之前緩存中的單執行個體Bean,也就是這個Bean是被建立過的

Object sharedInstance = this.getSingleton(beanName);
-->
   return this.getSingleton(beanName, true);
   -->
      Object singletonObject = this.singletonObjects.get(beanName);
	  -->
         private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);

singletonObjects這個Map就是儲存的所有單執行個體Bean，bean的名字和bean的執行個體對象

緩存中擷取不到，開始Bean的建立流程

标記目前Bean已經被建立

if (!typeCheckOnly) {
    this.markBeanAsCreated(beanName);
}

拿到Bean的定義資訊

RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);

擷取目前Bean的依賴Bean
```
String[] dependsOn = mbd.getDependsOn();
           
```
1. 有依賴Bean則通過getBean先将依賴的Bean給建立出來

啟動單執行個體Bean的建立流程

if (mbd.isSingleton()) {
    sharedInstance = this.getSingleton(beanName, () -> {
        try {
            return this.createBean(beanName, mbd, args);
        } catch (BeansException var5) {
            this.destroySingleton(beanName);
            throw var5;
        }
    });
    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

return this.createBean(beanName, mbd, args);

讓BeanPostProcessor攔截傳回代理對象【InstantiationAwareBeanPostProcessor】，在Bean的建立之前就被調用了

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
            Class<?> targetType = this.determineTargetType(beanName, mbd);
            if (targetType != null) {
                bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
                    bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }

        mbd.beforeInstantiationResolved = bean != null;
    }

    return bean;
}

beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse)
-->
    bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);

觸發方法：

有傳回代理對象的情況下：

if (bean != null) {
    bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
}

InstantiationAwareBeanPostProcessor沒有傳回代理對象，則開始建立Bean

beanInstance = this.doCreateBean(beanName, mbdToUse, args);
-->
    doCreateBean()

建立Bean的執行個體【方法調用結束Bean就被建立】

if (instanceWrapper == null) {
    instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}

利用工廠方法或者對象的構造器建立出Bean執行個體

} else if (mbd.getFactoryMethodName() != null) {
    return this.instantiateUsingFactoryMethod(beanName, mbd, args);

調用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法

this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

Bean建立完執行個體後開始初始化操作

一、為Bean的執行個體進行指派

擷取InstantiationAwareBeanPostProcessor後置處理器的postProcessAfterInstantiation()方法

if (bp instanceof InstantiationAwareBeanPostProcessor) {
    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
        return;
    }
}

擷取InstantiationAwareBeanPostProcessor後置處理器的postProcessPropertyValues()方法

BeanPostProcessor bp = (BeanPostProcessor)var9.next();
if (bp instanceof InstantiationAwareBeanPostProcessor) {
    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
    PropertyValues pvsToUse = ibp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);

指派之前

應用Bean屬性的值，用setter方法給屬性指派

if (pvs != null) {
    this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
}

二、Bean的初始化

exposedObject = this.initializeBean(beanName, exposedObject, mbd);

執行Aware接口的方法

this.invokeAwareMethods(beanName, bean);

-->
private void invokeAwareMethods(String beanName, Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof BeanNameAware) {
                ((BeanNameAware)bean).setBeanName(beanName);
            }

            if (bean instanceof BeanClassLoaderAware) {
                ClassLoader bcl = this.getBeanClassLoader();
                if (bcl != null) {
                    ((BeanClassLoaderAware)bean).setBeanClassLoader(bcl);
                }
            }

            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware)bean).setBeanFactory(this);
            }
        }

    }

執行初始化之前的後置處理器

BeanPostProcessor.postProcessBeforeInitialization()

if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
}

執行初始化方法：

this.invokeInitMethods(beanName, wrappedBean, mbd);

1.判斷是否是InitializingBean接口的實作類，是的話執行規定的初始化方法

boolean isInitializingBean = bean instanceof InitializingBean;

2.判斷是否有自定義的初始化方法

String initMethodName = mbd.getInitMethodName();

執行初始化之後的後置處理器BeanPostProcessor.postProcessAfterInitialization()

if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
}

容器建立和初始化完成後，注冊銷毀方法

this.registerDisposableBeanIfNecessary(beanName, bean, mbd);

将建立好的Bean添加到緩存singletonObject中

if (newSingleton) {
    this.addSingleton(beanName, singletonObject);
}

所有的Bean都通過getBean建立完成之後，判斷Bean是不是SmartInitializingSingleton接口，是的話執行afterSingletonsInstantiated()

while(var2.hasNext()) {
    beanName = (String)var2.next();
    Object singletonInstance = this.getSingleton(beanName);
    if (singletonInstance instanceof SmartInitializingSingleton) {
        SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(() -> {
                smartSingleton.afterSingletonsInstantiated();
                return null;
            }, this.getAccessControlContext());
        } else {
            smartSingleton.afterSingletonsInstantiated();
        }
    }
}

this.finishRefresh();完成BeanFactory的初始化建立工作，IOC容器建立完成

protected void finishRefresh() {
    this.clearResourceCaches();
    this.initLifecycleProcessor();
    this.getLifecycleProcessor().onRefresh();
    this.publishEvent((ApplicationEvent)(new ContextRefreshedEvent(this)));
    LiveBeansView.registerApplicationContext(this);
}

初始化和生命周期有關的後置器，通過實作LifecycleProcessor可以自定義onRefresh和onClose的方法

先判斷是否有LifecycleProcessor元件，沒有則new 一個來加入到容器中
```
this.initLifecycleProcessor();
-->
   DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
           
```
拿到前面的生命周期處理器，回調onRefresh()方法

釋出容器重新整理完成的事件

this.publishEvent((ApplicationEvent)(new ContextRefreshedEvent(this)));

spring容器refresh建立過程學習筆記

Spring容器的refresh()【建立重新整理】

文章目錄

this.refresh()

BeanFactory建立和預先準備

this.prepareRefresh();重新整理前的預處理

this.obtainFreshBeanFactory();擷取到BeanFactory

this.prepareBeanFactory(beanFactory);預準備工作

this.postProcessBeanFactory(beanFactory);BeanFactory準備工作完成後的後置處理工作

後面的工作

this.invokeBeanFactoryPostProcessors(beanFactory);執行BeanFactory的後置處理器

this.registerBeanPostProcessors(beanFactory);注冊Bean的後置處理器【攔截Bean的建立過程】

this.initMessageSource();初始化MessageSource元件（國際化功能）

this.initApplicationEventMulticaster();初始化時間派發器

this.onRefresh();讓子容器重寫容器重新整理時自定義的邏輯

this.registerListeners();注冊所有的ApplicationListener元件

this.finishBeanFactoryInitialization(beanFactory);初始化剩下的單執行個體Bean

this.finishRefresh();完成BeanFactory的初始化建立工作，IOC容器建立完成

繼續閱讀

馴服爛代碼_馴服Tomcat：Tomcat 5的過濾技巧

基于Springboot+VUE+Mysql的大學生校園疫情防控管理系統

Using MessageConverter

馴服爛代碼_C＃中的馴服配置

Spring Cloud整合Sleuth，當請求完成後，Zipkin沒有鍊路資訊

JAVA自學之路——馬士兵

Rabbitmq指令行手動建立隊列

整合 Spring 開發架構及服務端技術

SSM整合02---Spring-SpringMVC層一、添加web架構支援二、web.xml三、spring-mvc.xml

SSM架構（二）------------表現層的SpringMVC

Intellij idea基于Maven 的SSM 架構整合

Spring資料和Redis

SpringMVC的啟動過程源碼分析1 SpringMVC 配置XML的方式啟動2 SpringMVC純注解模式啟動

Java Spring 架構

spring boot @SpringBootApplication @EnableAutoConfiguration 的工作原理

SpringCloud微服務（四）之ribbon筆記ribbon是什麼？入門案例自定義均衡負載算法