【Spring源码】 Spring ioc的创建之刷新容器(四)
相关文章
- 【Spring源码】Spring ioc创建的流程(一)
- 【Spring源码】 Spring ioc的创建之刷新容器(二)
- 【Spring源码】 Spring ioc的创建之刷新容器(三)
- 【Spring源码】 Spring ioc的创建之刷新容器(四)
文章目录
- 相关文章
- 一. 刷新容器的源码
- 8.initApplicationEventMulticaster()
- 9. onRefresh()
- 10.registerListeners()
- 11.finishBeanFactoryInitialization()实例化所有单例类（除懒加载）
- 12. finishRefresh
一. 刷新容器的源码
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
//1. 准备刷新容器
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
// 2. 通知子类刷新内部beanFactory 并返回DefaultListableBeanFactory
//Application 是BeanFactory的功能上的扩展，不但包含了BeanFactory的全部功能更在其基础上添加了大量的扩展应用。
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
//3. 给 DefaultListableFactoryBean 赋值 例如类加载器， post processors
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
//4. 空方法 交给子类实现
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
//5. 执行已经注册的factory processors
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
//6. 注册BeanPostProcessor,用于拦截bean创建过程
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
//7. 初始化访问国际化信息的MessageSource组件
initMessageSource();
// Initialize event multicaster for this context.
//8. 定义事件多点广播
// 如果用户自定义了事件广播器，那么使用用户自定义的事件广播器
//若没有，那么使用默认的ApplicationEventMulticaster
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
//9. 子类实现
onRefresh();
// Check for listener beans and register them.
//10. 注册实现 org.spring.context.ApplicationListener 的bean
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
//11. 实例化所有单例类（不是懒加载）
// 完成beanFactory的初始化工作，其中包括ConversionService的设置，配置冻结以及非延迟加载的Bean的初始化工作。
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
// 12. 返程创建
// Spring 中提供了Lifecycle接口，Lifecycle中包含了Start/Stop方法，实现此接口后Spring会保证启动时
//调用其的Start方法开始生命周期，Spring关闭的时候调用stop来结束生命周期。通常用来配置后台程序，启动
//后一直运行（如对MQ进行轮询等）
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
8.initApplicationEventMulticaster()
该方法的作用是定义事件广播器，它包含了以下逻辑：
- 如果用户定义了事件广播器，那么使用用户自定义的事件广播器
- 若没有自定义事件广播器，那么使用ApplicationEventMulticaster
initApplicationEventMulticaster();
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() + "]");
}
}
}
9. onRefresh()
该方法为空方法 ，交给子类实现
10.registerListeners()
注册监听器
protected void registerListeners() {
// 硬编码方式注册的监听器处理
// Register statically specified listeners first.
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
//配置文件注册的监听器处理
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// Publish early application events now that we finally have a multicaster...
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
11.finishBeanFactoryInitialization()实例化所有单例类（除懒加载）
完成BeanFactory的初始化工作，其中包含ConversionService的设置、配置冻结已经非延迟加载Bean的初始化.
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Initialize conversion service for this context.
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));
}
// Register a default embedded value resolver if no bean post-processor
// (such as a PropertyPlaceholderConfigurer bean) registered any before:
// at this point, primarily for resolution in annotation attribute values.
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// Stop using the temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(null);
// Allow for caching all bean definition metadata, not expecting further changes.
// 冻结所有的Bean定义，说明注册的Bean定义将不被修改或任何进一步的处理
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons.
//初始化剩下的实例
beanFactory.preInstantiateSingletons();
}
SpringContext 实现的默认行为就是在启动时将所有单例Bean提前进行实例化。提前实例化亦为之作为初始化过程的一部分。
@Override
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.
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(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 {
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
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();
}
}
}
}
12. finishRefresh
Spring 中提供了Lifecycle接口，Lifecycle中包含了Start/Stop方法，实现此接口后Spring会保证启动时调用其的Start方法开始生命周期，Spring关闭的时候调用stop来结束生命周期。通常用来配置后台程序，启动后一直运行（如对MQ进行轮询等）
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
clearResourceCaches();
// Initialize lifecycle processor for this context.
// 当Application启动或停止的时候，它通过LifecycleProcess来与所有声明的Bean的周期做状态更新，而在LifecycleProcessor的使用首先需要初始化
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
// 启动所有实现了Lifecycle接口的Bean
getLifecycleProcessor().onRefresh();
// Publish the final event.
// 当ApplicationContext初始化的时候，要通过Spring的事件发布机制来发出ContextRefreshedEvent事件 以保证对应的监听器可以做进一步的逻辑处理
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}
当Application启动或停止的时候，它通过LifecycleProcess来与所有声明的Bean的周期做状态更新，而在LifecycleProcessor的使用首先需要初始化
protected void initLifecycleProcessor() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
this.lifecycleProcessor =
beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
if (logger.isTraceEnabled()) {
logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
}
}
else {
DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
defaultProcessor.setBeanFactory(beanFactory);
this.lifecycleProcessor = defaultProcessor;
beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
if (logger.isTraceEnabled()) {
logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
"[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
}
}
}
onRefresh启动所有实现了Lifecycle接口的bean
@Override
public void onRefresh() {
startBeans(true);
this.running = true;
}
private void startBeans(boolean autoStartupOnly) {
Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
Map<Integer, LifecycleGroup> phases = new HashMap<>();
lifecycleBeans.forEach((beanName, bean) -> {
if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
int phase = getPhase(bean);
LifecycleGroup group = phases.get(phase);
if (group == null) {
group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
phases.put(phase, group);
}
group.add(beanName, bean);
}
});
if (!phases.isEmpty()) {
List<Integer> keys = new ArrayList<>(phases.keySet());
Collections.sort(keys);
for (Integer key : keys) {
phases.get(key).start();
}
}
}
publishEvent :当ApplicationContext初始化的时候，要通过Spring的事件发布机制来发出ContextRefreshedEvent事件 以保证对应的监听器可以做进一步的逻辑处理
protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
Assert.notNull(event, "Event must not be null");
// Decorate event as an ApplicationEvent if necessary
ApplicationEvent applicationEvent;
if (event instanceof ApplicationEvent) {
applicationEvent = (ApplicationEvent) event;
}
else {
applicationEvent = new PayloadApplicationEvent<>(this, event);
if (eventType == null) {
eventType = ((PayloadApplicationEvent) applicationEvent).getResolvableType();
}
}
// Multicast right now if possible - or lazily once the multicaster is initialized
if (this.earlyApplicationEvents != null) {
this.earlyApplicationEvents.add(applicationEvent);
}
else {
getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
}
// Publish event via parent context as well...
if (this.parent != null) {
if (this.parent instanceof AbstractApplicationContext) {
((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
}
else {
this.parent.publishEvent(event);
}
}
}