相关源码注释
ApplicationContext
Spring 5 DefaultResourceLoader 源码注释
Spring 5 AbstractApplicationContext 源码注释
BeanFactory
Spring 5 SimpleAliasRegistry 源码注释
Spring 5 DefaultSingletonBeanRegistry 源码注释
Spring 5 FactoryBeanRegistrySupport 源码注释
Spring 5 AbstractBeanFactory 源码注释
Spring 5 AbstractAutowireCapableBeanFactory 源码注释
Spring 5 DefaultLisbaleBeanFactory 源码注释
finishRefresh()
/**
* <p>完成刷新
* Finish the refresh of this context, invoking the LifecycleProcessor's
* onRefresh() method and publishing the
* {@link org.springframework.context.event.ContextRefreshedEvent}.
* <p>调用 LifecycleProcessor 的 onRefresh() 方法并发布 ContextRefreshedEvent ,完成上下
* 问刷新</p>
*/
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
// 清楚上下文级别的资源缓存(如扫描的ASM元数据)
// 清空在资源加载器中的所有资源缓存
clearResourceCaches();
// Initialize lifecycle processor for this context.
// 为这个上下文初始化生命周期处理器
// 初始化 LifecycleProcessor.如果上下文中找到 'lifecycleProcessor' 的 LifecycleProcessor Bean对象,
// 则使用 DefaultLifecycleProcessor
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
// 首先将刷新传播到生命周期处理器
// 上下文刷新的通知,例如自动启动的组件
getLifecycleProcessor().onRefresh();
// Publish the final event.
// 发布最终事件
// 新建 ContextRefreshedEvent 事件对象,将其发布到所有监听器。
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
// 参与 LiveBeansView MBean,如果是活动的
// LiveBeansView:Sping 用于支持 JMX 服务的类,详情请参考:https://www.jianshu.com/p/fa4e88f95631
// 注册 当前上下文 到 LiveBeansView,以支持 JMX 服务
LiveBeansView.registerApplicationContext(this);
}
完成刷新:
- 清空在资源加载器中的所有资源缓存
- 初始化 LifecycleProcessor.如果上下文中找到 ‘lifecycleProcessor’ 的 LifecycleProcessor Bean对象, 则使用 DefaultLifecycleProcessor
- 将刷新传播到生命周期处理器
- 新建 ContextRefreshedEvent 事件对象,将其发布到所有监听器。
- 注册 当前上下文 到 LiveBeansView,以支持 JMX 服务
clearResourceCaches();
/**
* 资源映射缓存
*/
private final Map<Class<?>, Map<Resource, ?>> resourceCaches = new ConcurrentHashMap<>(4);
/**
* Clear all resource caches in this resource loader.
* <p>
* 清空在资源加载器中的所有资源缓存
* </p>
* @since 5.0
* @see #getResourceCache
*/
public void clearResourceCaches() {
//清空resourceCaches
this.resourceCaches.clear();
}
initLifecycleProcessor()
/**
* <p><p>初始化 LifecycleProcessor.如果上下文中找到 'lifecycleProcessor' 的 LifecycleProcessor Bean对象,则使用
* DefaultLifecycleProcessor </p></p>
* Initialize the LifecycleProcessor.
* Uses DefaultLifecycleProcessor if none defined in the context.
* <p>初始化 LifecycleProcessor.如果上下文中没有定义,则使用 DefaultLifecycleProcessor </p>
* @see org.springframework.context.support.DefaultLifecycleProcessor
*/
protected void initLifecycleProcessor() {
//获取当前上下文的BeanFactory对象
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
//如果 beanFactory 包含 'lifecycleProcessor' 的bean,忽略父工厂
if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
//让当前上下文 引用 从beanFactory中获取名为 'lifecycleProcessor' 的 LifecycleProcessor 类型的Bean对象
this.lifecycleProcessor =
beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
//如果当前日志级级别是跟踪
if (logger.isTraceEnabled()) {
//打印跟踪日志:使用 LifecycleProcessor [lifecycleProcessor]
logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
}
}
else {
//创建一个 DefaultLifecycleProcessor 实例
DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
//为Bean实例提供所属工厂的回调函数
defaultProcessor.setBeanFactory(beanFactory);
//让当前上下文 引用 defaultProcessor
this.lifecycleProcessor = defaultProcessor;
//将 'lifecycleProcessor' 与 lifecycleProcessor 注册到 beanFactory 中
beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
//如果当前日志级级别是跟踪
if (logger.isTraceEnabled()) {
// 没有 'lifecycleProcessor' 的Bean对象,使用 [lifecycleProcessor类名]
logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
"[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
}
}
}
publishEvent(new ContextRefreshedEvent(this));
/**
* Publish the given event to all listeners.
* <p>将给定事件发布到所有监听器。</p>
* <p>Note: Listeners get initialized after the MessageSource, to be able
* to access it within listener implementations. Thus, MessageSource
* implementations cannot publish events.
* <p>注意:侦听器在MessageSource之后被初始化,以便能够在侦听器实现中访问它。
* 因此,MessageSource实现不能发布事件</p>
* @param event the event to publish (may be application-specific or a
* standard framework event)
* -- 要发布的事件(可能是特定于应用程序的事件或标准框架事件)
*/
@Override
public void publishEvent(ApplicationEvent event) {
publishEvent(event, null);
}
/**
* Publish the given event to all listeners.
* <p>将给定事件发布到所有监听器。</p>
* <p>Note: Listeners get initialized after the MessageSource, to be able
* to access it within listener implementations. Thus, MessageSource
* implementations cannot publish events.
* <p>注意:侦听器在MessageSource之后被初始化,以便能够在侦听器实现中访问它。 因此,MessageSource实现不能发布事件</p>
* @param event the event to publish (may be an {@link ApplicationEvent}
* or a payload object to be turned into a {@link PayloadApplicationEvent})
* -- 要发布的事件(可能是特定于应用程序的事件或标准框架事件)
*/
@Override
public void publishEvent(Object event) {
publishEvent(event, null);
}
/**
* <p>将 event 多播到所有适合的监听器。如果 event 不是 ApplicationEvent 实例,会将其封装成 PayloadApplicationEvent 对象
* 再进行多播。</p>
* <p>当上下文的多播器没有初始化时,会将event暂时保存起来,待多播器初始化后才将缓存的event进行多播</p>
* Publish the given event to all listeners.
* <p>将给定事件发布到所有监听器</p>
* @param event the event to publish (may be an {@link ApplicationEvent}
* or a payload object to be turned into a {@link PayloadApplicationEvent})
* -- 要发布的事件(可能是特定于应用程序的事件或标准框架事件)
* @param eventType the resolved event type, if known -- 已解析的事件类型(如果已知)
* @since 4.2
*/
protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
//如果 event 为null,抛出异常
Assert.notNull(event, "Event must not be null");
// Decorate event as an ApplicationEvent if necessary
// 装饰事件作为一个应用事件,如果有必要
ApplicationEvent applicationEvent;
//如果 event 是 ApplicationEvent 的 实例
if (event instanceof ApplicationEvent) {
//将 event 强转为 ApplicationEvent 对象
applicationEvent = (ApplicationEvent) event;
}
else {
//PayloadApplicationEvent:携带任意有效负载的ApplicationEvent。
//创建一个新的 PayloadApplicationEvent
applicationEvent = new PayloadApplicationEvent<>(this, event);
//如果 eventType 为 null
if (eventType == null) {
//将 applicationEvent 转换为 PayloadApplicationEvent 对象,引用其 ResolvableType 对象
eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
}
}
// Multicast right now if possible - or lazily once the multicaster is initialized
// 如果可能的话,现在就进行组播——或者在组播初始化后延迟
// earlyApplicationEvents:在多播程序设置之前发布的ApplicationEvent
// 如果 earlyApplicationEvents 不为 null,这种情况只在上下文的多播器还没有初始化的情况下才会成立, 会将 applicationEvent
// 添加到 earlyApplicationEvents 保存起来,待多博器初始化后才继续进行多播到适当的监听器
if (this.earlyApplicationEvents != null) {
//将applicationEvent添加到 earlyApplicationEvents
this.earlyApplicationEvents.add(applicationEvent);
}
else {
//多播applicationEvent到适当的监听器
getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
}
// Publish event via parent context as well...
// 通过父上下文发布事件
// 如果 parent 不为 null
if (this.parent != null) {
//如果 parent 是 AbstractApplicationContext 的实例
if (this.parent instanceof AbstractApplicationContext) {
//将 event 多播到所有适合的监听器。如果 event 不是 ApplicationEvent 实例,会将其封装成 PayloadApplicationEvent 对象再进行多播
((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
}
else {
//通知与event事件应用程序注册的所有匹配的监听器
this.parent.publishEvent(event);
}
}
}
LiveBeansView.registerApplicationContext(this);
/**
* The "MBean Domain" property name.
* <p>'MBean Domain' 属性名</p>
*/
public static final String MBEAN_DOMAIN_PROPERTY_NAME = "spring.liveBeansView.mbeanDomain";
/**
* The MBean application key.
* <p> MBean 应用 Key</p>
*/
public static final String MBEAN_APPLICATION_KEY = "application";
/**
* applicationContext 集
*/
private static final Set<ConfigurableApplicationContext> applicationContexts = new LinkedHashSet<>();
/**
* 此上下文所属的已部署应用程序的名称
*/
@Nullable
private static String applicationName;
/**
* 注册 applicationContext
* @param applicationContext 应用程序上下文
*/
static void registerApplicationContext(ConfigurableApplicationContext applicationContext) {
//从 applicationContext 中环境对象中获取 'spring.liveBeansView.mbeanDomain' 的属性值
String mbeanDomain = applicationContext.getEnvironment().getProperty(MBEAN_DOMAIN_PROPERTY_NAME);
//如果 mbeanDomain 不为 null
if (mbeanDomain != null) {
//使用 applicationContexts 进行同步加锁,保证线程安全
synchronized (applicationContexts) {
//如果 applicationContexts 是空集合
if (applicationContexts.isEmpty()) {
try {
//ManagementFactory.getPlatformMBeanServer()返回对JVM中现有MBean服务器的引用
//MBean 即 managed beans【被管理的Beans】:一个MBean是一个被管理的Java对象,有点类似于JavaBean,
// 一个设备、一个应用或者任何资源都可以被表示为MBean,MBean会暴露一个接口对外,这个接口可以读取
// 或者写入一些对象中的属性,通常一个MBean需要定义一个接口,以MBean结尾, 例如: EchoMBean,
// 格式为XXXMBean,这个是规范,必须得遵守。
MBeanServer server = ManagementFactory.getPlatformMBeanServer();
//获取此上下文所属的已部署应用程序的名称
applicationName = applicationContext.getApplicationName();
//在MBeanServer里注册MBean, 标识为 mbeanDomain:application=applicationName
server.registerMBean(new LiveBeansView(),
new ObjectName(mbeanDomain, MBEAN_APPLICATION_KEY, applicationName));
}
catch (Throwable ex) {
//捕捉注册时抛出的异常
//抛出应用程序上下文异常:注册 LiveBeansView MBean 失败
throw new ApplicationContextException("Failed to register LiveBeansView MBean", ex);
}
}
//将 applicationContext 添加到 applicationContexts中
applicationContexts.add(applicationContext);
}
}
}