概览
- refresh
明细
- 1.prepareRefresh
- 2.obtainFreshBeanFactory
- 3.prepareBeanFactory
- 4.postProcessBeanFactory
- 5. invokeBeanFactoryPostProcessors
- 6.registerBeanPostProcessors
- 7.initMessageSource
- 8.initApplicationEventMulticaster
- 9.onRefresh
- 10.registerListeners
- 11.finishBeanFactoryInitialization
- 12.finishRefresh

对于 AbstractApplicationContex#refresh()方法逻辑，可所谓是贯通spring框架核心逻辑，溪源在debug过程中，理解起来也是懵懵懂懂，自己也买了《Spring源码深度解析》书籍学习其思想和实现逻辑，经过不断的整理学习总结，最终诞生这篇文章，方便后面自己忘记了查看和理解。
下面开始正式踏入refresh方法的整体概览浅析。

概览

refresh

该方法是 Spring Bean 加载的核心，它是 ClassPathXmlApplicationContext 的父类 AbstractApplicationContext 的一个方法，顾名思义，用于刷新整个Spring 上下文信息，定义了整个 Spring 上下文加载的流程。
先看下refresh()方法总体：

@Override
public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {// 准备预处理：记录容器的启动时间startupDate, 标记容器为激活，初始化上下文环境如文件路径信息，验证必填属性是否填写this.prepareRefresh();// **告诉子类去刷新bean工厂，此方法解析配置文件并将bean信息存储到beanDefinition中，注册到BeanFactory（但是未被初始化，仅将信息写到了beanDefination的map中）**重点方法，下面的操作都基于这个beanFactory进行的ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();// 设置beanFactory的基本属性：类加载器，添加多个beanPostProcesserthis.prepareBeanFactory(beanFactory);try {// 空实现：允许子类上下文中对beanFactory做后期处理this.postProcessBeanFactory(beanFactory);/**************************以上是BeanFactory的创建及预准备工作  ****************/// 调用BeanFactoryPostProcessor各个实现类的方法this.invokeBeanFactoryPostProcessors(beanFactory);// 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别// 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization// 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化this.registerBeanPostProcessors(beanFactory);//初始化ApplicationContext的MessageSource组件(资源文件)，如国际化文件，消息解析，绑定等this.initMessageSource();//初始化ApplicationContext事件广播器this.initApplicationEventMulticaster();// 初始化子类特殊bean（钩子方法）this.onRefresh();// 获取所有的事件监听器，并将监听器注册到事件广播器this.registerListeners();//** 初始化所有singleton bean；**重点方法this.finishBeanFactoryInitialization(beanFactory);// 广播事件：ApplicationContext初始化完成this.finishRefresh();
} catch (BeansException ex) {if (logger.isWarnEnabled()) {logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex);}// 销毁beanthis.destroyBeans();// 重置 'active' 标志.this.cancelRefresh(ex);throw ex;}}

明细

本篇文章，不会仔细往下探讨源码实现逻辑，先总结refresh()方法具体逻辑：

1.prepareRefresh

准备预处理：记录spring容器的启动时间startupDate, 标记容器为激活，初始化上下文环境如文件路径信息，验证必填属性是否填写。

initPropertySources():初始化一些属性设置;子类自定义个性化的属性设置方法；
getEnvironment().validateRequiredProperties():检验属性的合法等;
earlyApplicationEvents= new LinkedHashSet():保存容器中的一些早期的事件;

//刷新前的预处理;
protected void prepareRefresh() {this.startupDate = System.currentTimeMillis();this.closed.set(false);this.active.set(true);
if (logger.isInfoEnabled()) {logger.info("Refreshing " + this);}// 初始化一些属性设置;子类自定义个性化的属性设置方法；initPropertySources();   // 校验配置文件的属性，合法性getEnvironment().validateRequiredProperties();//保存容器中的一些事件this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}

2.obtainFreshBeanFactory

获取BeanFactory,解析配置文件，生成beanDefinition;

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {refreshBeanFactory(); //创建了一个this.beanFactory = new DefaultListableBeanFactory();设置了序列化的ID//返回刚才创建的DefaultListableBeanFactoryConfigurableListableBeanFactory beanFactory = getBeanFactory();if (logger.isDebugEnabled()) {logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);}return beanFactory;
}

3.prepareBeanFactory

该方法主要负责对BeanFactory的预准备工作，配置beanFactory的基础属性，比如ClassLoader和一些PostProcessor等。
这个方法主要是给BeanFactory设置一些基本的属性，比如类加载器、表达式解析器、属性编辑器，注册几个单例、添加一些不用注入的接口、添加解析依赖项等。

设置BeanFactory的类加载器、支持表达式解析器…
添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；
注册可以解析的自动装配；我们能直接在任何组件中自动注入：
BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
添加BeanPostProcessor【ApplicationListenerDetector】
添加编译时的AspectJ；
给BeanFactory中注册一些能用的组件；
environment【ConfigurableEnvironment】、
systemProperties【Map<String, Object>】、
systemEnvironment【Map<String, Object>】

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {// Tell the internal bean factory to use the context's class loader etc.//设置类加载器beanFactory.setBeanClassLoader(getClassLoader());//设置bean表达式解析器，详解见下文beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());//资源编辑注册器beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));//添加一个BeanPostProcessor：ApplicationContextAwareProcessor，用于向实现类ApplitionContextAware中，调用setApplicationContext方法，并将ApplicationContext作为参数。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);// 注册几个解析依赖项，意思是，当一个Bean需要注入对应的类时，使用下面注册的这些类//比如，如果@Autowire 一个BeanFactory，那么这个BeanFactory实际就是在此处注册的一个对象//这几项分别是：BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContextbeanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);beanFactory.registerResolvableDependency(ResourceLoader.class, this);beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);beanFactory.registerResolvableDependency(ApplicationContext.class, this);// Detect a LoadTimeWeaver and prepare for weaving, if found.//检查是否由LoadTimeWeaver，如果有loadTimeWeaver的bean，就放入一个BeanPostProcessor：LoadTimeWeaverAwareProcessorif (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));// Set a temporary ClassLoader for type matching.beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}// 注册environment，注册成单例if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());}//注册systemProperties 成单例if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());}//注册 systemEnvironment 成单例if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());}}

4.postProcessBeanFactory

主要负责在BeanFactory准备工作完成之后，beanFactory的后置处理工作；

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {}

5. invokeBeanFactoryPostProcessors

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {// Invoke BeanDefinitionRegistryPostProcessors first, if any.//用于存放已处理过的BeanSet<String> processedBeans = new HashSet<String>();//如果IOC容器是一个BeanDefinitionRegistry，有了注册BeanDefinition的能力，就可以执行BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法if (beanFactory instanceof BeanDefinitionRegistry) {BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;//regularPostProcessors用于存放普通的BeanFactoryPostProcessorList<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();//registryPostProcessors用于存放 BeanDefinitionRegistryPostProcessorList<BeanDefinitionRegistryPostProcessor> registryPostProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();//查询通过addBeanFactoryPostProcessor等方法设置进来的的BeanFactoryPostProcessor（不是注册到IOC容器的中）for (BeanFactoryPostProcessor postProcessor : getBeanFactoryPostProcessors()) {//如果是 BeanDefinitionRegistryPostProcessor  ，//就先执行它的postProcessBeanDefinitionRegistry，用于向IOC中注册一些BeanDefinition，//然后添加到registryPostProcessors队列中if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {BeanDefinitionRegistryPostProcessor registryPostProcessor =(BeanDefinitionRegistryPostProcessor) postProcessor;registryPostProcessor.postProcessBeanDefinitionRegistry(registry);registryPostProcessors.add(registryPostProcessor);}else {//如果是普通的BeanFactoryPostProcessor，就添加到regularPostProcessors队列中regularPostProcessors.add(postProcessor);}}//获取IOC容器中注册的BeanDefinitionRegistryPostProcessor，//放入到registryPostProcessorBeans中，//并按照Order排序Map<String, BeanDefinitionRegistryPostProcessor> beanMap =beanFactory.getBeansOfType(BeanDefinitionRegistryPostProcessor.class, true, false);List<BeanDefinitionRegistryPostProcessor> registryPostProcessorBeans =new ArrayList<BeanDefinitionRegistryPostProcessor>(beanMap.values());OrderComparator.sort(registryPostProcessorBeans);//先调用registryPostProcessorBeans中的所有postProcessBeanDefinitionRegistry方法for (BeanDefinitionRegistryPostProcessor postProcessor : registryPostProcessorBeans) {postProcessor.postProcessBeanDefinitionRegistry(registry);}//先调用 registryPostProcessors中的postProcessBeanFactory方法//再调用 registryPostProcessorBeans中的postProcessBeanFactory方法//最后调用 regularPostProcessors中的postProcessBeanFactory方法invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);invokeBeanFactoryPostProcessors(registryPostProcessorBeans, beanFactory);invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);//对于IOC容器中注册的BeanDefinitionRegistryPostProcessor来说，还要放置到processedBeans中，放置重复调用processedBeans.addAll(beanMap.keySet());}else {//如果IOC就是一个普通的BeanFacotry，就直接从context中取出所有的BeanFactoryPostProcessor，并调用他们的postProcessBeanFactory方法// Invoke factory processors registered with the context instance.invokeBeanFactoryPostProcessors(getBeanFactoryPostProcessors(), beanFactory);}// Do not initialize FactoryBeans here: We need to leave all regular beans// 查询IOC容器中所有的BeanFactoryPostProcessor，有可能上面的BeanDefinitionRegistryPostProcessor刚刚向IOC容器中注册了一些BeanFactoryPostProcessor，所以要在此处全部查出来。String[] postProcessorNames =beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);// 按照 这些BeanFactoryPostProcessor实现的排序接口（ PriorityOrdered 和 Ordered）分成3组//第一组 实现了PriorityOrdered  --- priorityOrderedPostProcessors//第二组 实现了Ordered          --- orderedPostProcessorNames//第三组 没有实现排序接口         --- nonOrderedPostProcessorNamesList<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();List<String> orderedPostProcessorNames = new ArrayList<String>();List<String> nonOrderedPostProcessorNames = new ArrayList<String>();for (String ppName : postProcessorNames) {//如果已经处理了，就跳过if (processedBeans.contains(ppName)) {// skip - already processed in first phase above}//实现PriorityOrdered 接口的else if (isTypeMatch(ppName, PriorityOrdered.class)) {priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));}// 实现Ordered 接口的else if (isTypeMatch(ppName, Ordered.class)) {orderedPostProcessorNames.add(ppName);}//普通的else {nonOrderedPostProcessorNames.add(ppName);}}//然后先执行priorityOrderedPostProcessors中的，再执行orderedPostProcessorNames的，最后执行nonOrderedPostProcessorNames//排序并执行priorityOrderedPostProcessors的OrderComparator.sort(priorityOrderedPostProcessors);invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);// 排序并执行orderedPostProcessors的List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();for (String postProcessorName : orderedPostProcessorNames) {orderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));}OrderComparator.sort(orderedPostProcessors);invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);// 最后执行普通的BeanFactoryPostProcessor的List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();for (String postProcessorName : nonOrderedPostProcessorNames) {nonOrderedPostProcessors.add(getBean(postProcessorName, BeanFactoryPostProcessor.class));}invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
}

6.registerBeanPostProcessors

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {// 获取IOC中注册的 BeanPostProcessorString[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);// BeanPostProcessorChecker 也是一个 BeanPostProcessor，用于检查一个Bean应该经过的BeanPostProcessor和int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));//按照排序接口分类。//这里需要注意的是，priorityOrderedPostProcessors里面装的是BeanPostProcessor//而orderedPostProcessorNames和nonOrderedPostProcessorNames里面装的是BeanPostProcessor的name//原因是：实例化BeanPostProcessor实现类的时候，也需要调用IOC中已有的BeanPostProcessor，所以Spring这里没有提前实例化Orderd接口和普通的BeanPostProcessor。//因此，这里有一个有趣的现象，示例化Orderd接口的BeanProcessor的时候，会使用PriorityOrdered的BeanPostProcessor进行处理//实例化普通的BeanProcessor时，会先后经过PriorityOrdered和Orderd接口的BeanPostProcessor的处理List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();List<String> orderedPostProcessorNames = new ArrayList<String>();List<String> nonOrderedPostProcessorNames = new ArrayList<String>();//分类for (String ppName : postProcessorNames) {//PriorityOrdered接口的，先行实例化，并把MergedBeanDefinitionPostProcessor放入到internalPostProcessors中if (isTypeMatch(ppName, PriorityOrdered.class)) {BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);priorityOrderedPostProcessors.add(pp);//if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}//Ordered接口的，这里只是把name记录下来。else if (isTypeMatch(ppName, Ordered.class)) {//orderedPostProcessorNames.add(ppName);}//普通的，这里只是把name记录下来。else {nonOrderedPostProcessorNames.add(ppName);}}//排序并注册PriorityOrdered接口的BeanPostProcessorOrderComparator.sort(priorityOrderedPostProcessors);registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);//排序并注册Ordered接口的BeanPostProcessorList<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();for (String ppName : orderedPostProcessorNames) {//这里才进行实例化，所以会使用实现了PriorityOrdered接口的BeanPostProcessor进行处理BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);orderedPostProcessors.add(pp);//把MergedBeanDefinitionPostProcessor放入到internalPostProcessors中if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}OrderComparator.sort(orderedPostProcessors);registerBeanPostProcessors(beanFactory, orderedPostProcessors);// 注册普通的BeanPostProcessorList<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();for (String ppName : nonOrderedPostProcessorNames) {//这里才进行实例化，所以会使用实现了PriorityOrdered接口或Orderd的BeanPostProcessor进行处理BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);nonOrderedPostProcessors.add(pp);//把 MergedBeanDefinitionPostProcessor 放入到internalPostProcessors中//同时注意到，即使在internalPostProcessors中//BeanPostProcessor的顺序也是按照 PriorityOrderd > Orderd > 普通 的顺序进入的。if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);//注册所有的MergedBeanDefinitionPostProcessorOrderComparator.sort(internalPostProcessors);registerBeanPostProcessors(beanFactory, internalPostProcessors);//最后，在末尾添加一个ApplicationListenerDetectorbeanFactory.addBeanPostProcessor(new ApplicationListenerDetector());
}

7.initMessageSource

初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；

获取BeanFactory
判断容器中是否有id为messageSource的，类型是MessageSource的组件；
如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource；
MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取；
将创建完成的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以自动注入MessageSource；

protected void initMessageSource() {ConfigurableListableBeanFactory beanFactory = getBeanFactory();if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);// Make MessageSource aware of parent MessageSource.//如果已经注册了 messageSource && messageSource是HierarchicalMessageSource && messageSource没有parent && 此IOC有parentif (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;if (hms.getParentMessageSource() == null) {// Only set parent context as parent MessageSource if no parent MessageSource// registered already.hms.setParentMessageSource(getInternalParentMessageSource());}}if (logger.isDebugEnabled()) {logger.debug("Using MessageSource [" + this.messageSource + "]");}}//如果没有注册messageSource，就创建一个DelegatingMessageSource,并注册到IOC中else {// Use empty MessageSource to be able to accept getMessage calls.DelegatingMessageSource dms = new DelegatingMessageSource();dms.setParentMessageSource(getInternalParentMessageSource());this.messageSource = dms;beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);if (logger.isDebugEnabled()) {logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +"': using default [" + this.messageSource + "]");}}
}

8.initApplicationEventMulticaster

protected void initApplicationEventMulticaster() {ConfigurableListableBeanFactory beanFactory = getBeanFactory();//如果有开发自定的applicationEventMulticaster实例bean，则设置IOC的事件广播器为该实例if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {this.applicationEventMulticaster =beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);if (logger.isDebugEnabled()) {logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");}}//如果没有applicationEventMulticaster，就设置一个SimpleApplicationEventMulticasterelse {this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);if (logger.isDebugEnabled()) {logger.debug("Unable to locate ApplicationEventMulticaster with name '" +APPLICATION_EVENT_MULTICASTER_BEAN_NAME +"': using default [" + this.applicationEventMulticaster + "]");}}
}

9.onRefresh

模板设计模式;该方法属于钩子方法；子类重写该方法并在容器刷新的时候自定义逻辑；

protected void onRefresh() throws BeansException {// For subclasses: do nothing by default.
}

10.registerListeners

注册监听器分为两部分:

向事件分发器注册硬编码设置的applicationListener
向事件分发器注册一个IOC中的事件监听器（并不实例化）

protected void registerListeners() {// 查出所有通过addApplicationListener方法添加的ApplicationListener，然后注册到事件广播器上for (ApplicationListener<?> listener : getApplicationListeners()) {getApplicationEventMulticaster().addApplicationListener(listener);}// 查出ioc容器中的所有ApplicationListener，只把他们注册到事件分发器的ApplicationListenerBean上，// 待使用时再进行实例化String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);for (String listenerBeanName : listenerBeanNames) {getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);}
}

11.finishBeanFactoryInitialization

finishBeanFactoryInitialization主要是负责初始化单实例的bean；该方法是重点方法，bean的生命周期基本调用getBean()方法完成。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {//如果IOC中有conversionService的话，就实例化并设置到IOC中//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));}// 如果有LoadTimeWeaverAware，就实例化String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);for (String weaverAwareName : weaverAwareNames) {getBean(weaverAwareName);}// 清理临时的classLoaderbeanFactory.setTempClassLoader(null);// 缓存所有beanDefinition的name，以备不时之需beanFactory.freezeConfiguration();// 实例化所有非non-lazy-init的单例beanFactory.preInstantiateSingletons();
}

12.finishRefresh

完成bean创建和初始化过程，通知生命周期处理器 lifecycleProcessor 刷新过程，同时发出 ContextRefreshEvent 通知。

protected void finishRefresh() {// 实例化或初始化lifecycleProcessorinitLifecycleProcessor();// 调用lifecycleProcessor的刷新方法getLifecycleProcessor().onRefresh();//发布一个ContextRefreshedEvent事件publishEvent(new ContextRefreshedEvent(this));// 注册MBean，用于JMX管理LiveBeansView.registerApplicationContext(this);
}

参考资料：

解读Spring容器的refresh()
Spring 源码深度解析
Spring IoC之ApplicationContext中refresh过程

Spring学习之浅析refresh()执行逻辑相关推荐

Spring容器初始化完成后执行业务逻辑的三种方式
一业务背景监听应用容器启动完毕并扫描容器类特定的Dubbo服务,并把相关元数据注册到网关. 二思路 1 在容器启动构造元数据上报到网关,影响应用启动性能: 2 监听容器启动完毕后构造元数据 ...
spring学习12 -Spring 框架模块以及面试常见问题注解等
以下为spring常见面试问题: 1.Spring 框架中都用到了哪些设计模式? Spring框架中使用到了大量的设计模式,下面列举了比较有代表性的: 代理模式-在AOP和remoting中被用的比较 ...
Spring——Spring学习教程（详细）（上篇）——IOC、AOP
本文是Spring的学习上篇,主要讲IOC和AOP. Spring的JDBCTemplete以及事务的知识,请见下篇. Spring--Spring学习教程(详细)(下篇)--JDBCTemplete ...
Spring Aop 常见注解和执行顺序
欢迎关注方志朋的博客,回复"666"获面试宝典来源:juejin.cn/post/7062506923194581029 Spring 一开始最强大的就是 IOC / AOP 两 ...
Spring学习笔记(三) AOP_annotation，AOP_XML
在学习课程以前,听说AOP有种很神秘的感觉,好像很好深的技术.其实原理很简单,使用动态代理的方式给程序增加逻辑.与此相似的有struts2中的filter拦截器. 再讲AOP之前先把需求说一下: 同S ...
Spring学习总结三
Spring框架JdbcTemplate与事务 Spring学习总结三 0.需要的jar包 1.JdbcTemplate模板 1.1.JdbcTemplateAPI的操作 1.1.1.User类 1. ...
Spring学习总结二
Spring框架的代理与AOP.AspectJ Spring学习总结二 0.在理解什么是AOP之前的一些话 1.什么是AOP 2.AOP的重要概念 3.代理模式 3.1.静态代理 3.2.动态代理 3 ...
Spring学习总结一
Spring框架IoC与DI思想及应用 Spring学习总结一 1.Spring是什么 2.Spring的优点 2.1.关键概念 2.2.Spring的优点 3.Spring的架构图 3.1.核心容器 ...
Spring学习（三）Spring AOP 简介
本文借鉴:Spring学习(特此感谢!) 一.简介定义 aop就是面向切面编程,在数据库事务中切面编程被广泛使用. 在面向切面编程的思想里面,把功能分为核心业务功能,和周边功能. 核心业务:比如登陆 ...
Spring学习（一）初识Spring
本文借鉴:Spring学习(特此感谢!) 一.简介什么是Spring 定义:Spring 是一个轻量级的 DI / IoC 和 AOP 容器的开源框架,目的为了简化java开发. DI:注入 IOC ...

Spring学习之浅析refresh()执行逻辑

目录

概览