随笔分类
初始化事件传播器 initApplicationEventMulticaster
initApplicationEventMulticaster
protected void initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
/** 条件成立, 说明用户自定义了事件传播器, 用户可以来实现 ApplicationEventMulticaster接口, 写一款自己的时间传播器, 通过 bean的方式提供给 Spring **/
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 {
/** SimpleApplicationEventMulticaster 这是 Spring框架默认提供的事件传播器, 关注点在这 **/
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
/** 将 Spring提供的事件传播器注册到 一级缓存中去 **/
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() + "]");
}
}
}
publishEvent
/**
* 通过 IOC容器来发布事件
*/
@Override
public void publishEvent(ApplicationEvent event) {
publishEvent(event, null);
}
注册事件监听器 registerListeners
registerListeners
/**
* Add beans that implement ApplicationListener as listeners.
* Doesn't affect other listeners, which can be added without being beans.
* 往事件传播器中注册事件监听器
*/
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!
/** 获取以 bean的方式注册的事件监听器的 name **/
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 (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
/** 由此可见, 事件传播器接收到事件后, 会去调用 multicastEvent来处理事件, 然后在该方法中会通过 invokeListener来调用指定的事件监听器 **/
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
addApplicationListeners
/**
* 这里便是 硬编码提供监听器调用的 api, 将硬编码提供的监听器注册到 applicationListeners中去
*/
@Override
public void addApplicationListener(ApplicationListener<?> listener) {
Assert.notNull(listener, "ApplicationListener must not be null");
if (this.applicationEventMulticaster != null) {
this.applicationEventMulticaster.addApplicationListener(listener);
}
this.applicationListeners.add(listener);
}
getApplicationListeners
/**
* 返回硬编码提供的监听器
*/
public Collection<ApplicationListener<?>> getApplicationListeners() {
return this.applicationListeners;
}
getApplicationEventMulticaster
/**
* 获取事件传播器
*/
ApplicationEventMulticaster getApplicationEventMulticaster() throws IllegalStateException {
if (this.applicationEventMulticaster == null) {
throw new IllegalStateException("ApplicationEventMulticaster not initialized - " +
"call 'refresh' before multicasting events via the context: " + this);
}
return this.applicationEventMulticaster;
}
multicastEvent
事件传播器接收到事件后会去调用 multocastEvent, 然后再去调用 invokeListener来执行指定的事件监听器
@Override
public void multicastEvent(ApplicationEvent event) {
multicastEvent(event, resolveDefaultEventType(event));
}
@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
Executor executor = getTaskExecutor();
for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
/** 这里会来判断是不是异步执行的场景 --> 有无线程池 **/
if (executor != null) {
executor.execute(() -> invokeListener(listener, event));
}
else {
/** 这里便是同步执行的场景 **/
invokeListener(listener, event);
}
}
}
实例化非懒加载的单实例 finishBeanFactoryInitialization
对应 ApplicationContext,在容器启动时便会去加载 bean了,并非到 getBean时才显式去加载 bean
finishBeanFactoryInitialization
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 BeanFactoryPostProcessor
// (such as a PropertySourcesPlaceholderConfigurer 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. 冻结配置,再去修改就会抛异常.
/** 冻结配置信息, 冻结 bd信息; 冻结之后, 就无法再向 bf内注册 bd **/
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons. 预初始化非懒加载的单实例
/** 预初始化非懒加载的单实例 **/
beanFactory.preInstantiateSingletons();
}
freezeConfiguration
@Override
public void freezeConfiguration() {
/** 设置下当前为 冻结状态 **/
this.configurationFrozen = true;
this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);
}
preInstantiateSingletons
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 BeanFactoryPostProcessor
// (such as a PropertySourcesPlaceholderConfigurer 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. 冻结配置,再去修改就会抛异常.
/** 冻结配置信息, 冻结 bd信息; 冻结之后, 就无法再向 bf内注册 bd **/
beanFactory.freezeConfiguration();
// Instantiate all remaining (non-lazy-init) singletons. 预初始化非懒加载的单实例
/** 预初始化非懒加载的单实例 **/
beanFactory.preInstantiateSingletons();
}
结束刷新 finishRefresh
finishRefresh
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
clearResourceCaches();
// Initialize lifecycle processor for this context.
/** 初始化生命周期处理器 **/
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
/** 这里来刷新生命周期处理器 **/
getLifecycleProcessor().onRefresh();
// Publish the final event.
/** 这里来发布事件 "容器已经启动完成" **/
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
if (!NativeDetector.inNativeImage()) {
LiveBeansView.registerApplicationContext(this);
}
}
initLifeCycleProcessor
protected void initLifecycleProcessor() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
/** true -> 用户自定义了生命周期处理器 **/
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语句 **/
else {
/** Spring默认提供的生命周期处理器 DefaultLifecycleProcessor **/
DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
defaultProcessor.setBeanFactory(beanFactory);
this.lifecycleProcessor = defaultProcessor;
/** 将创建的生命周期处理器注册到 bf一级缓存中去 **/
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
@Override
public void onRefresh() {
startBeans(true);
this.running = true;
}
startBeans
/**
* autoStartupOnly ?
* true -> 表示只启动 SmartLifeCycle 生命周期对象, 并且启动 SmartLifeCycle对象它的 autoStartup是 true
* false -> 全部启动
*/
private void startBeans(boolean autoStartupOnly) {
/** 获取到所有实现了 LifeCycle接口的对象, 包装到 map内, key -> beanName, value -> LifeCycle对象 **/
Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
/** 由于生命周期对象可能依赖其它生命周期对象的执行结果, 因此需要顺序执行, 着考什么来实现呢 ? **/
/** 依靠 phase值, phase越低的 lifeCycle越先执行 start 方法 **/
/** phase值一样的 lifeCycle对象会被存储到 同一个 LifecycleGroup中去 **/
Map<Integer, LifecycleGroup> phases = new TreeMap<>();
lifecycleBeans.forEach((beanName, bean) -> {
/**
* true -> 表示只启动 SmartLifeCycle 生命周期对象, 并且启动 SmartLifeCycle对象它的 autoStartup是 true
* false -> 全部启动
*/
if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
// 获取当前生命周期对象的 phase值
int phase = getPhase(bean);
/** 这里 **/
phases.computeIfAbsent(
phase,
p -> new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly)
).add(beanName, bean);
}
});
/** 这里就是去调用 lifeCycle对象的 start方法了 **/
if (!phases.isEmpty()) {
phases.values().forEach(LifecycleGroup::start);
}
}
LifecycleGroup::start
public void start() {
if (this.members.isEmpty()) {
return;
}
if (logger.isDebugEnabled()) {
logger.debug("Starting beans in phase " + this.phase);
}
// 排序
Collections.sort(this.members);
/** 对每个分组进行遍历 **/
for (LifecycleGroupMember member : this.members) {
doStart(this.lifecycleBeans, member.name, this.autoStartupOnly);
}
}
doStart
private void doStart(Map<String, ? extends Lifecycle> lifecycleBeans, String beanName, boolean autoStartupOnly) {
/** 确保 LifeCycle对象只会被执行一次, 在一个分组内被启动了, 其它分组内 就看不到 LifeCycle了 **/
Lifecycle bean = lifecycleBeans.remove(beanName);
if (bean != null && bean != this) {
/** 获取当前 即将要被启动的 LifeCycle所依赖的 其它 beanName **/
String[] dependenciesForBean = getBeanFactory().getDependenciesForBean(beanName);
/** 先启动当前 LifeCycle所依赖的其它 LifeCycle **/
for (String dependency : dependenciesForBean) {
doStart(lifecycleBeans, dependency, autoStartupOnly);
}
/** 这里就是来判断当前 LifeCycle对象是否满足要启动的 条件 **/
if (!bean.isRunning() &&
(!autoStartupOnly || !(bean instanceof SmartLifecycle) || ((SmartLifecycle) bean).isAutoStartup())) {
if (logger.isTraceEnabled()) {
logger.trace("Starting bean '" + beanName + "' of type [" + bean.getClass().getName() + "]");
}
try {
/** 这里就调用了 当前 LifeCycle的 start方法了 **/
bean.start();
}
catch (Throwable ex) {
throw new ApplicationContextException("Failed to start bean '" + beanName + "'", ex);
}
if (logger.isDebugEnabled()) {
logger.debug("Successfully started bean '" + beanName + "'");
}
}
}
}
stop
上述讲了 start方法,这里来看下 stop方法
@Override
public void stop() {
stopBeans();
this.running = false;
}
stopBeans
private void stopBeans() {
/** 这里就不多说了, 这里的逻辑和 startBeans几乎一致 **/
Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
Map<Integer, LifecycleGroup> phases = new HashMap<>();
lifecycleBeans.forEach((beanName, bean) -> {
int shutdownPhase = getPhase(bean);
LifecycleGroup group = phases.get(shutdownPhase);
if (group == null) {
group = new LifecycleGroup(shutdownPhase, this.timeoutPerShutdownPhase, lifecycleBeans, false);
phases.put(shutdownPhase, group);
}
group.add(beanName, bean);
});
if (!phases.isEmpty()) {
List<Integer> keys = new ArrayList<>(phases.keySet());
// 降序排序, 由此可以看出越先启动的, 就越晚进行关闭
keys.sort(Collections.reverseOrder());
for (Integer key : keys) {
/** 迭代进行遍历 **/
phases.get(key).stop();
}
}
}
stop
public void stop() {
if (this.members.isEmpty()) {
return;
}
if (logger.isDebugEnabled()) {
logger.debug("Stopping beans in phase " + this.phase);
}
this.members.sort(Collections.reverseOrder());
/** 这里使用的同步阻塞工具, CountDownLatch, 计数器值初始值为 实现了 SmartLifeCycle的对象数目 **/
CountDownLatch latch = new CountDownLatch(this.smartMemberCount);
/** 记录当前正在处于 关闭状态的 smartLifeCycle的 beanName **/
Set<String> countDownBeanNames = Collections.synchronizedSet(new LinkedHashSet<>());
/** 记录 bf内 全部的 lifeCycle的 beanName **/
Set<String> lifecycleBeanNames = new HashSet<>(this.lifecycleBeans.keySet());
/** 迭代处理本分组内需要关闭的 LifeCycle对象 **/
for (LifecycleGroupMember member : this.members) {
if (lifecycleBeanNames.contains(member.name)) {
doStop(this.lifecycleBeans, member.name, latch, countDownBeanNames);
}
else if (member.bean instanceof SmartLifecycle) {
// Already removed: must have been a dependent bean from another phase
latch.countDown();
}
}
try {
/** 关闭 lifeCycle的主线程会在此等待, 等待 latch归零 或者 超时 **/
latch.await(this.timeout, TimeUnit.MILLISECONDS);
if (latch.getCount() > 0 && !countDownBeanNames.isEmpty() && logger.isInfoEnabled()) {
logger.info("Failed to shut down " + countDownBeanNames.size() + " bean" +
(countDownBeanNames.size() > 1 ? "s" : "") + " with phase value " +
this.phase + " within timeout of " + this.timeout + "ms: " + countDownBeanNames);
}
}
catch (InterruptedException ex) {
Thread.currentThread().interrupt();
}
}
} public void stop() {
if (this.members.isEmpty()) {
return;
}
if (logger.isDebugEnabled()) {
logger.debug("Stopping beans in phase " + this.phase);
}
this.members.sort(Collections.reverseOrder());
/** 这里使用的同步阻塞工具, CountDownLatch, 计数器值初始值为 实现了 SmartLifeCycle的对象数目 **/
CountDownLatch latch = new CountDownLatch(this.smartMemberCount);
/** 记录当前正在处于 关闭状态的 smartLifeCycle的 beanName **/
Set<String> countDownBeanNames = Collections.synchronizedSet(new LinkedHashSet<>());
/** 记录 bf内 全部的 lifeCycle的 beanName **/
Set<String> lifecycleBeanNames = new HashSet<>(this.lifecycleBeans.keySet());
/** 迭代处理本分组内需要关闭的 LifeCycle对象 **/
for (LifecycleGroupMember member : this.members) {
if (lifecycleBeanNames.contains(member.name)) {
doStop(this.lifecycleBeans, member.name, latch, countDownBeanNames);
}
else if (member.bean instanceof SmartLifecycle) {
// Already removed: must have been a dependent bean from another phase
latch.countDown();
}
}
try {
/** 关闭 lifeCycle的主线程会在此等待, 等待 latch归零 或者 超时 **/
latch.await(this.timeout, TimeUnit.MILLISECONDS);
if (latch.getCount() > 0 && !countDownBeanNames.isEmpty() && logger.isInfoEnabled()) {
logger.info("Failed to shut down " + countDownBeanNames.size() + " bean" +
(countDownBeanNames.size() > 1 ? "s" : "") + " with phase value " +
this.phase + " within timeout of " + this.timeout + "ms: " + countDownBeanNames);
}
}
catch (InterruptedException ex) {
Thread.currentThread().interrupt();
}
}
}
doStop
private void doStop(Map<String, ? extends Lifecycle> lifecycleBeans, final String beanName,
final CountDownLatch latch, final Set<String> countDownBeanNames) {
/** 同样是先进行移除 **/
Lifecycle bean = lifecycleBeans.remove(beanName);
if (bean != null) {
/** 获取依赖于当前 lifeCycle对象的其它 lifeCycle的 beanName **/
String[] dependentBeans = getBeanFactory().getDependentBeans(beanName);
for (String dependentBean : dependentBeans) {
/** 先去关闭依赖于当前 lifeCycle对象的其它 lifeCycle **/
doStop(lifecycleBeans, dependentBean, latch, countDownBeanNames);
}
try {
if (bean.isRunning()) {
/** SmartLifeCycle对象, 其 stop方法可以传递一个 "回调 callback" **/
if (bean instanceof SmartLifecycle) {
if (logger.isTraceEnabled()) {
logger.trace("Asking bean '" + beanName + "' of type [" +
bean.getClass().getName() + "] to stop");
}
/** 记录当前要关闭的 smartLifeCycle对象 **/
countDownBeanNames.add(beanName);
/** smartLifeCycle传递 callBack, 理论上支持 异步关闭生命周期对象 **/
((SmartLifecycle) bean).stop(() -> {
latch.countDown();
countDownBeanNames.remove(beanName);
if (logger.isDebugEnabled()) {
logger.debug("Bean '" + beanName + "' completed its stop procedure");
}
});
}
/** 普通的 lifeCycle对象, 直接来调用其 stop方法 **/
else {
if (logger.isTraceEnabled()) {
logger.trace("Stopping bean '" + beanName + "' of type [" +
bean.getClass().getName() + "]");
}
bean.stop();
if (logger.isDebugEnabled()) {
logger.debug("Successfully stopped bean '" + beanName + "'");
}
}
}
else if (bean instanceof SmartLifecycle) {
// Don't wait for beans that aren't running...
latch.countDown();
}
}
catch (Throwable ex) {
if (logger.isWarnEnabled()) {
logger.warn("Failed to stop bean '" + beanName + "'", ex);
}
}
}
}