AbstractApplicationContext#refresh

于 2024-06-26 18:47:17 发布
阅读量1k 收藏 15
点赞数 24
分类专栏： spring系列 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/htydowd/article/details/139991463
版权

spring 关键方法

org.springframework.context.support.AbstractApplicationContext#refresh

这个方法 是 线程安全的

synchronized (this.startupShutdownMonitor) { }

第一步，资源相关，初始化 属性资源 并验证

org.springframework.context.support.AbstractApplicationContext#prepareRefresh

initPropertySources(); 该方法提供给子类实现，实现该方法的子类有：

// org.springframework.web.context.support.AbstractRefreshableWebApplicationContext#initPropertySources
protected void initPropertySources() {
		ConfigurableEnvironment env = getEnvironment();
		if (env instanceof ConfigurableWebEnvironment) {
			((ConfigurableWebEnvironment) env).initPropertySources(this.servletContext, this.servletConfig);
		}
	}

public static void initServletPropertySources(MutablePropertySources sources,
			@Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig) {

		Assert.notNull(sources, "'propertySources' must not be null");
		String name = StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME;
		if (servletContext != null && sources.get(name) instanceof StubPropertySource) {
			sources.replace(name, new ServletContextPropertySource(name, servletContext));
		}
		name = StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME;
		if (servletConfig != null && sources.get(name) instanceof StubPropertySource) {
			sources.replace(name, new ServletConfigPropertySource(name, servletConfig));
		}
	}

// org.springframework.web.context.support.GenericWebApplicationContext#initPropertySources
protected void initPropertySources() {
		ConfigurableEnvironment env = getEnvironment();
		if (env instanceof ConfigurableWebEnvironment) {
			((ConfigurableWebEnvironment) env).initPropertySources(this.servletContext, null);
		}
	}


public static void initServletPropertySources(MutablePropertySources sources,
			@Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig) {

		Assert.notNull(sources, "'propertySources' must not be null");
		String name = StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME;
		if (servletContext != null && sources.get(name) instanceof StubPropertySource) {
			sources.replace(name, new ServletContextPropertySource(name, servletContext));
		}
		name = StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME;
		if (servletConfig != null && sources.get(name) instanceof StubPropertySource) {
			sources.replace(name, new ServletConfigPropertySource(name, servletConfig));
		}
	}
// org.springframework.web.context.support.StaticWebApplicationContext#initPropertySources
protected void initPropertySources() {
		WebApplicationContextUtils.initServletPropertySources(getEnvironment().getPropertySources(),
				this.servletContext, this.servletConfig);
	}

public static void initServletPropertySources(MutablePropertySources sources,
			@Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig) {

		Assert.notNull(sources, "'propertySources' must not be null");
		String name = StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME;
		if (servletContext != null && sources.get(name) instanceof StubPropertySource) {
			sources.replace(name, new ServletContextPropertySource(name, servletContext));
		}
		name = StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME;
		if (servletConfig != null && sources.get(name) instanceof StubPropertySource) {
			sources.replace(name, new ServletConfigPropertySource(name, servletConfig));
		}
	}

getEnvironment().validateRequiredProperties(); 验证属性值

// 获取 applicationListeners

// Store pre-refresh ApplicationListeners...
		if (this.earlyApplicationListeners == null) {
			this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
		}
		else {
			// Reset local application listeners to pre-refresh state.
			this.applicationListeners.clear();
			this.applicationListeners.addAll(this.earlyApplicationListeners);
		}

第二步：

// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

org.springframework.context.support.AbstractApplicationContext#refreshBeanFactory 是一个抽象方法，有两个实现：

第一个实现：

org.springframework.context.support.AbstractRefreshableApplicationContext#refreshBeanFactory

首先 DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory(getInternalParentBeanFactory());

配置 是否可以 覆盖bean 和 循环依赖

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
		if (this.allowBeanDefinitionOverriding != null) {
			beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
		}
		if (this.allowCircularReferences != null) {
			beanFactory.setAllowCircularReferences(this.allowCircularReferences);
		}
	}

org.springframework.context.support.AbstractRefreshableApplicationContext#loadBeanDefinitions 调用 该方法加载bean信息，该方法由子类实现：

org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory)

org.springframework.web.context.support.AnnotationConfigWebApplicationContext#loadBeanDefinitions

org.springframework.web.context.support.GroovyWebApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory)

org.springframework.web.context.support.XmlWebApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory)

第二个实现：

org.springframework.context.support.GenericApplicationContext#refreshBeanFactory

protected final void refreshBeanFactory() throws IllegalStateException {
		if (!this.refreshed.compareAndSet(false, true)) {
			throw new IllegalStateException(
					"GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
		}
		this.beanFactory.setSerializationId(getId());
	}

因为 spring boot 启动 servlet模式使用的是 org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext 继承自 org.springframework.web.context.support.GenericWebApplicationContext，因此 这里实际基本等于啥都没做。而 beanfactory 在实例化 时构造。

public GenericApplicationContext() {
		this.beanFactory = new DefaultListableBeanFactory();
	}

第三步：

prepareBeanFactory(beanFactory);

设置 类加载器

beanFactory.setBeanClassLoader(getClassLoader());

设置Bean表达式解析器，以便解析Bean定义中的SpEL表达式

beanFactory.setBeanExpressionResolver(newStandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

 注册资源编辑器注册器，用于自定义属性编辑器支持

beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

// 添加ApplicationContextAwareProcessor，使得Bean能感知到ApplicationContext，加入private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();

beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

// 配置BeanFactory忽略特定接口的依赖注入，这些接口的实现通常由框架直接提供服务,加入private final Set<Class<?>> ignoredDependencyInterfaces = new HashSet<>();

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、ResourceLoader、ApplicationEventPublisher和ApplicationContext本身

beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    // 添加早期后处理器，用于检测内部Bean作为ApplicationListener

beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // 如果存在LoadTimeWeaver，准备进行类加载期织入的配置

if (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()));
}

    // 注册默认的环境相关Bean，如Environment、系统属性和系统环境变量

f (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}

第四步：

postProcessBeanFactory(beanFactory);

这个方法的实现比较多，有8个

// 	org.springframework.web.context.support.AbstractRefreshableWebApplicationContext#postProcessBeanFactory
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
		beanFactory.ignoreDependencyInterface(ServletContextAware.class);
		beanFactory.ignoreDependencyInterface(ServletConfigAware.class);

		WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
		WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
	}


// org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext#postProcessBeanFactory
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		super.postProcessBeanFactory(beanFactory);
		if (!ObjectUtils.isEmpty(this.basePackages)) {
			this.scanner.scan(this.basePackages);
		}
		if (!this.annotatedClasses.isEmpty()) {
			this.reader.register(ClassUtils.toClassArray(this.annotatedClasses));
		}
	}

// org.springframework.boot.web.servlet.context.AnnotationConfigServletWebApplicationContext#postProcessBeanFactory
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		super.postProcessBeanFactory(beanFactory);
		if (!ObjectUtils.isEmpty(this.basePackages)) {
			this.scanner.scan(this.basePackages);
		}
		if (!this.annotatedClasses.isEmpty()) {
			this.reader.register(ClassUtils.toClassArray(this.annotatedClasses));
		}
	}
// org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext#postProcessBeanFactory
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		super.postProcessBeanFactory(beanFactory);
		if (this.basePackages != null && this.basePackages.length > 0) {
			this.scanner.scan(this.basePackages);
		}
		if (!this.annotatedClasses.isEmpty()) {
			this.reader.register(ClassUtils.toClassArray(this.annotatedClasses));
		}
	}

// org.springframework.web.context.support.GenericWebApplicationContext#postProcessBeanFactory
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		if (this.servletContext != null) {
			beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext));
			beanFactory.ignoreDependencyInterface(ServletContextAware.class);
		}
		WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
		WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext);
	}
// org.springframework.jca.context.ResourceAdapterApplicationContext#postProcessBeanFactory
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        beanFactory.addBeanPostProcessor(new BootstrapContextAwareProcessor(this.bootstrapContext));
        beanFactory.ignoreDependencyInterface(BootstrapContextAware.class);
        beanFactory.registerResolvableDependency(BootstrapContext.class, this.bootstrapContext);
        BootstrapContext var10002 = this.bootstrapContext;
        beanFactory.registerResolvableDependency(WorkManager.class, var10002::getWorkManager);
    }
}
//org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext#postProcessBeanFactory
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this));
		beanFactory.ignoreDependencyInterface(ServletContextAware.class);
		registerWebApplicationScopes();
	}
//org.springframework.web.context.support.StaticWebApplicationContext#postProcessBeanFactory
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
		beanFactory.ignoreDependencyInterface(ServletContextAware.class);
		beanFactory.ignoreDependencyInterface(ServletConfigAware.class);

		WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
		WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
	}

第五步：

invokeBeanFactoryPostProcessors(beanFactory);

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
		// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

.获取所有的BeanFactoryPostProcessor

public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
		return this.beanFactoryPostProcessors;
	}

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

这里也比较复杂，该函数用于在Spring应用程序上下文中调用BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor的实例。这些处理器可以在Spring容器实例化任何bean之前修改bean的定义或bean工厂的配置。

第一部分：调用 BeanDefinitionRegistryPostProcessor

行 org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry

从bean工厂中读取所有的 BeanDefinitionRegistryPostProcessor

优先排序 并调用 实现了 org.springframework.core.PriorityOrdered 接口的。

然后排序 并调用 实现了 org.springframework.core.Ordered 接口的

最后调用剩下的

调用 所有的 org.springframework.beans.factory.config.BeanFactoryPostProcessor#postProcessBeanFactory

第二部分：调用 BeanFactoryPostProcessor

也是按照PriorityOrdered/Ordered 顺序调用

第六步：registerBeanPostProcessors(beanFactory);

这一步看着停复杂，实际就做一件事，读取所有的 BeanPostProcessor，按照优先级排序后

写入 org.springframework.beans.factory.support.AbstractBeanFactory#beanPostProcessors

第七/八步：

initMessageSource();

initApplicationEventMulticaster();

第九步：

onRefresh();

实现类也挺多

org.springframework.web.context.support.AbstractRefreshableWebApplicationContext#onRefresh

protected void onRefresh() {
this.themeSource = UiApplicationContextUtils.initThemeSource(this);
}

org.springframework.web.context.support.GenericWebApplicationContext#onRefresh

protected void onRefresh() {
this.themeSource = UiApplicationContextUtils.initThemeSource(this);
}

org.springframework.boot.web.reactive.context.ReactiveWebServerApplicationContext#onRefresh

protected void onRefresh() {
super.onRefresh();
try {
createWebServer();
}
catch (Throwable ex) {
throw new ApplicationContextException("Unable to start reactive web server", ex);
}
}

org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext#onRefresh

protected void onRefresh() {
super.onRefresh();
try {
createWebServer();
}
catch (Throwable ex) {
throw new ApplicationContextException("Unable to start web server", ex);
}
}

org.springframework.web.context.support.StaticWebApplicationContext#onRefresh

protected void onRefresh() {
this.themeSource = UiApplicationContextUtils.initThemeSource(this);
}

第十步：

registerListeners();

注册 ApplicationListener

第十一步：

finishBeanFactoryInitialization(beanFactory);

完成bean的实例化

第十二步：

/**
 * 完成此上下文的刷新操作，包括调用生命周期处理器的onRefresh()方法，
 * 发布ContextRefreshedEvent事件，以及参与LiveBeansView MBean（如激活）。
 */
protected void finishRefresh() {
    // 清除上下文级别的资源缓存（例如扫描期间获取的ASM元数据）。
    clearResourceCaches();

    // 初始化此上下文的生命周期处理器。
    initLifecycleProcessor();

    // 首先将刷新操作传播给生命周期处理器。
    getLifecycleProcessor().onRefresh();

    // 发布最终的刷新事件。
    publishEvent(new ContextRefreshedEvent(this));

    // 如LiveBeansView MBean处于活动状态，注册此应用上下文以参与其中。
    LiveBeansView.registerApplicationContext(this);
}

 

finally:

protected void resetCommonCaches() {
ReflectionUtils.clearCache();
AnnotationUtils.clearCache();
ResolvableType.clearCache();
CachedIntrospectionResults.clearClassLoader(getClassLoader());
}

LSZXZNJ
关注
专栏目录
spring源码解析之AbstractApplicationContext#refresh()方法刷新上下文过程
蛐蛐的博客
10-12 827
1.简介 方法的定义 /** * 加载或刷新配置的持久性表示形式，它可能来自基于Java的配置，XML文件，属性文件，关系数据库模式或其他格式。 * 由于这是一种启动方法，因此，如果失败，则应销毁已创建的单例，以避免资源悬空。 * 换句话说，在调用此方法之后，应实例化所有单例或根本不实例化。 * @throws BeansException 如果无法初始化bean工厂 * @throws IllegalStateException 如果已经初始化并且多次刷新.不支持尝.
spring源码解析之从AbstractApplicationContext#refresh()初始化单例过程看Bean的创建过程
蛐蛐的博客
10-16 1311
1.简介 AbstractApplicationContext#refresh()方法的最后一步是初始化所有单例 /** * 完成此上下文的bean工厂的初始化，初始化所有剩余的单例bean。 * @param beanFactory */ protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { /** 为此上下文初始化转换服务{@link.
org.springframework.context.support.AbstractApplicationContext refresh
weixin_43280591的博客
04-03 1588
org.springframework.context.support.AbstractApplicationContext refresh spring 项目启动报错： 4月 03, 2021 12:48:48 下午 org.springframework.context.support.AbstractApplicationContext refresh 警告: Exception encountered during context initialization - cancelling refres
spring中org.springframework.context.support.AbstractApplicationContext refresh报错处理
XXLYCS的博客
04-07 9590
报错场景:使用name属性实现构造注入或者使用index属性时出现ref和value使用不恰当引起的报错（报错如下，只显示最主要的报错）
org.springframework.context.support.AbstractApplicationContext refresh错误
热门推荐
m0_47074226的博客
03-03 1万+
org.springframework.context.support.AbstractApplicationContext refresh错误 大家在学Spring的时候， Aop在Spring中的作用这一节点中，把所有文件都弄好以后，测试的时候会发现如下的错误 三月 03, 2021 6:27:04 下午 org.springframework.context.support.AbstractApplicationContext refresh 警告: Exception encountered dur
org.springframework.context.support.abstractapplicationcontext refresh
03-16
org.springframework.context.support.AbstractApplicationContext 的 refresh() 方法用于刷新 Spring 应用程序上下文。它会触发上下文的初始化过程，包括执行所有已注册的 BeanFactoryPostProcessor 和 Application...
Spring源码私家笔记—— ApplicationContext.refresh()方法浅析
mytream的专栏
05-04 851
从本章开始我们将开始进入Spring容器真正的刷新启动过程，直接点击或者debugger进入AbstractApplicationContext的refresh()方法。这里再次提示一下大家，在先前的提到过的“胸有大纲，心中不慌”，大家务必要克制自己挨个debugger进refresh的每个方法进行查看的冲动。 大家想啊，Spring的作者把一个个的对象和方法封装出来，就是想要屏蔽底层实现的复杂性，那我们就按照这一个个方法名先理解个大概。建议大家直接把springframework的官方源码clone下来，
Spring Boot-10-run方法之AbstractApplicationContext#refresh()
诗人不写诗
07-13 662
本文源码基于Spring 5.2.7 Spring中，容器的填充全靠org.springframework.context.support.AbstractApplicationContext#refresh()方法，这个方法的每一步都是值得分析的，这每一步都会分为一篇或多篇文章来解析，这里对这些步骤作一个整体说明。 Spring的核心能力就是作为控制反转容器使用，通过名称可以看出，这个方法是用来刷新容器的，可想而知这个方法包含了Spring核心能力，包括AOP的处理过程都在这里。作为一个服务框架，Spri
spring中AbstractApplicationContext的refresh()
zlpzlpzyd的专栏
09-23 260
这个部分的源码看的次数不计其数了，每次看不同开源组件的调用过程中走到这里都有不同的收获。spring 中 AbstractApplicationContext 的 refresh() 是 spring 的核心，几乎所有的逻辑都在是这里间接被调用。如下源码为 spring boot 2.7.15 自带的 spring 5.3.29通过 WebApplicationType 判断是哪个环境判断逻辑如下。
Spring AbstractApplicationContext#refresh初始化过程
weixin_34353714的博客
05-16 160
public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { // Prepare this context for refreshing. // 准备更新上下文，设置开始时间，标记活动标志，初始化配置文件中的占位符 p...
spring源码AbstractApplicationContext的refresh()方法
最新发布
qq_42297616的博客
05-12 320
主要是为了说明，如果之前存在bean工厂，销毁之前的bean工厂。
Spring iOC主流程初始化方法org.springframework.context.support.AbstractApplicationContext#refresh方法
小城我家
06-28 9031
Spring iOC主流程初始化方法org.springframework.context.support.AbstractApplicationContext#refresh方法 #####　启动测试类 @Test public void beanTest(){ ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
spring基本使用(7)-Spring应用上下文刷新核心AbstractApplicationContext.Refresh()
qq_34978129的博客
05-20 370
1、容器技术内幕-AbstractApplicationContext.Refresh() AbstractApplicationContext : 是ApplicationContext的抽象类，里面的refresh()方法是容器加载的入口。 Refresh()方法的主要流程如下： 第1步：初始化BeanFactory。 ConfigurableListableBeanFactory beanFactory = obtainFre...
【spring】AbstractApplicationContext 的refresh() 方法学习
一个写了10年bug的程序员日常笔记。
03-29 915
的refresh()方法仍然是整个Spring应用程序上下文初始化的核心流程入口。大体上的刷新生命周期依然保持一致。refresh()方法的执行流程是一个复杂的过程，它涉及到多个方法的调用和多个步骤的执行。在实际开发中，我们通常不需要直接调用refresh()方法，而是通过调用类的子类的refresh()方法来刷新应用上下文。
AbstractApplicationContext#refresh()
如来#俏,米勒#笑 的博客
04-30 143
AbstractApplicationContext#refresh() @Override public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { // Prepare this context for refreshing. //准备刷新 ...
spring启动之AbstractApplicationContext#refresh
gamezjl的博客
08-25 395
调用本类AbstractApplicationContext#obtainFreshBeanFactory获取bean工厂,初始化过程中会获取parentApplicationContext，不为空将父级ApplicationContext#beanFactory通过DefaultListableBeanFactory.DefaultListableBeanFactory(BeanFactory)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值