您好，登录后才能下订单哦！
密码登录
登录注册
点击 登录注册 即表示同意《亿速云用户服务条款》
Spring框架是Java开发中最流行的框架之一，它提供了强大的依赖注入和面向切面编程的能力。Spring容器的核心是ApplicationContext，它负责管理Bean的生命周期、依赖注入、AOP等。ApplicationContext的初始化过程是通过refresh()方法来完成的。本文将深入分析refresh()方法的源码，帮助读者理解Spring容器的初始化过程。
BeanFactory是Spring框架中最基本的容器接口，它定义了获取Bean、判断Bean是否存在、获取Bean的类型等基本操作。BeanFactory是Spring容器的核心接口，所有的Spring容器都实现了这个接口。
ApplicationContext是BeanFactory的子接口，它在BeanFactory的基础上增加了更多的功能，如国际化、事件传播、资源加载等。ApplicationContext是Spring框架中最常用的容器接口。
refresh()方法是ApplicationContext接口中的一个核心方法，它负责初始化Spring容器。refresh()方法的调用会触发Spring容器的初始化过程，包括BeanFactory的创建、Bean的加载、Bean的初始化等。
refresh()方法的源码如下：
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 1. 准备刷新上下文
prepareRefresh();
// 2. 获取新的BeanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 3. 准备BeanFactory
prepareBeanFactory(beanFactory);
try {
// 4. 允许子类对BeanFactory进行后处理
postProcessBeanFactory(beanFactory);
// 5. 调用BeanFactoryPostProcessors
invokeBeanFactoryPostProcessors(beanFactory);
// 6. 注册BeanPostProcessors
registerBeanPostProcessors(beanFactory);
// 7. 初始化MessageSource
initMessageSource();
// 8. 初始化ApplicationEventMulticaster
initApplicationEventMulticaster();
// 9. 初始化其他特殊的Bean
onRefresh();
// 10. 注册监听器
registerListeners();
// 11. 初始化所有单例Bean
finishBeanFactoryInitialization(beanFactory);
// 12. 完成刷新
finishRefresh();
} catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// 销毁已经创建的单例Bean
destroyBeans();
// 重置'active'标志
cancelRefresh(ex);
throw ex;
} finally {
// 重置公共的缓存
resetCommonCaches();
}
}
}
prepareRefresh()方法负责准备刷新上下文，主要包括以下几个步骤：
active标志为true。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();
}
obtainFreshBeanFactory()方法负责获取一个新的BeanFactory。这个方法的主要作用是创建一个新的BeanFactory，并加载Bean定义。
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// 刷新BeanFactory
refreshBeanFactory();
return getBeanFactory();
}
prepareBeanFactory()方法负责准备BeanFactory，主要包括以下几个步骤：
BeanFactory的类加载器。BeanFactory的表达式解析器。BeanPostProcessor，用于在Bean初始化前后进行处理。protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 设置类加载器
beanFactory.setBeanClassLoader(getClassLoader());
// 设置表达式解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 注册属性编辑器
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 添加BeanPostProcessor
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
if (!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进行后处理。这个方法是一个空方法，子类可以重写这个方法来实现自定义的逻辑。
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}
invokeBeanFactoryPostProcessors()方法负责调用BeanFactoryPostProcessor。BeanFactoryPostProcessor是Spring框架中的一个扩展点，它允许在BeanFactory初始化之后、Bean实例化之前对BeanFactory进行修改。
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// 如果BeanFactory是AnnotationConfigApplicationContext，则处理@Configuration类
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
registerBeanPostProcessors()方法负责注册BeanPostProcessor。BeanPostProcessor是Spring框架中的一个扩展点，它允许在Bean初始化前后进行处理。
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
initMessageSource()方法负责初始化MessageSource。MessageSource是Spring框架中用于国际化的接口，它可以根据不同的Locale获取不同的消息。
protected void initMessageSource() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
if (hms.getParentMessageSource() == null) {
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
if (logger.isTraceEnabled()) {
logger.trace("Using MessageSource [" + this.messageSource + "]");
}
} else {
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isTraceEnabled()) {
logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
}
}
}
initApplicationEventMulticaster()方法负责初始化ApplicationEventMulticaster。ApplicationEventMulticaster是Spring框架中用于事件传播的接口，它可以将事件广播给所有注册的监听器。
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
if (logger.isTraceEnabled()) {
logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
}
} else {
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
if (logger.isTraceEnabled()) {
logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
}
}
}
onRefresh()方法是一个空方法，子类可以重写这个方法来实现自定义的逻辑。这个方法在BeanFactory初始化之后、Bean实例化之前调用。
protected void onRefresh() throws BeansException {
// 空方法，子类可以重写
}
registerListeners()方法负责注册监听器。监听器是Spring框架中用于监听事件的组件，它可以在事件发生时执行相应的逻辑。
protected void registerListeners() {
// 注册静态指定的监听器
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// 注册Bean定义的监听器
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// 发布早期事件
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
finishBeanFactoryInitialization()方法负责初始化所有单例Bean。这个方法会触发所有非懒加载的单例Bean的初始化。
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));
}
// 注册默认的嵌入值解析器
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// 初始化LoadTimeWeaverAware Bean
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// 停止使用临时类加载器
beanFactory.setTempClassLoader(null);
// 冻结所有Bean定义
beanFactory.freezeConfiguration();
// 初始化所有非懒加载的单例Bean
beanFactory.preInstantiateSingletons();
}
finishRefresh()方法负责完成刷新过程，主要包括以下几个步骤：
LifecycleProcessor，用于管理Bean的生命周期。ContextRefreshedEvent事件，通知所有监听器容器已经刷新完成。Lifecycle接口的Bean。protected void finishRefresh() {
// 初始化LifecycleProcessor
initLifecycleProcessor();
// 启动所有实现了Lifecycle接口的Bean
getLifecycleProcessor().onRefresh();
// 发布ContextRefreshedEvent事件
publishEvent(new ContextRefreshedEvent(this));
// 注册ApplicationContext到LiveBeansView
LiveBeansView.registerApplicationContext(this);
}
refresh()方法是Spring容器初始化的核心方法，它负责完成BeanFactory的创建、Bean的加载、Bean的初始化等过程。通过深入分析refresh()方法的源码，我们可以更好地理解Spring容器的工作原理，从而在实际开发中更好地使用Spring框架。
本文详细分析了refresh()方法的每一个步骤，包括prepareRefresh()、obtainFreshBeanFactory()、prepareBeanFactory()、postProcessBeanFactory()、invokeBeanFactoryPostProcessors()、registerBeanPostProcessors()、initMessageSource()、initApplicationEventMulticaster()、onRefresh()、registerListeners()、finishBeanFactoryInitialization()和finishRefresh()。希望本文能够帮助读者更好地理解Spring容器的初始化过程。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。