Spring-容器refresh
从源码分析了Spring容器的refresh过程，并通过图文的方式记录了整个流程的核心步骤
核心步骤总结
- 准备 BeanFactory（包括类加载器、SPEL解析器等基础设施）
- 执行 BeanDefinitionRegistryPostProcessor：优先处理配置类等，动态注册更多 BeanDefinition
- 执行 BeanFactoryPostProcessor：可用来修改 BeanDefinition 信息
- 注册 BeanPostProcessor：用于后续 Bean 创建生命周期中的扩展
- 初始化 MessageSource：国际化消息解析支持
- 初始化事件广播器（ApplicationEventMulticaster）并注册为 Bean
- 调用 onRefresh()：留给子类扩展（如创建 Web Server）
- 注册 ApplicationListener：用于监听容器事件
- 实例化非懒加载的单例 Bean
- 完成刷新：启动 SmartLifecycle Bean，发布 ContextRefreshedEvent
AbstractApplicationContext#refresh-源码分析
整体的refresh
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 1. 准备上下文环境（包括设置启动时间、状态标志位、初始化环境属性等）
prepareRefresh();
// 2. 创建并刷新 BeanFactory（默认 DefaultListableBeanFactory）
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 3. 对BeanFactory做各种填充
prepareBeanFactory(beanFactory);
try {
// 4. hook方法，供子类在 BeanFactory 初始化后、自定义修改它
postProcessBeanFactory(beanFactory);
// 5. 调用 BeanFactoryPostProcessor(BeanDefinitionRegistryPostProcessor >
// BeanFactoryPostProcessor)
// ConfigurationClassPostProcessor就是这阶段处理的
invokeBeanFactoryPostProcessors(beanFactory);
// 6. 注册 BeanPostProcessor（并非调用），用于后续Bean实例化的hook
registerBeanPostProcessors(beanFactory);
// 7. 为上下文初始化Message源，国际化处理
initMessageSource();
// 8. 初始化事件广播器（默认实现为SimpleApplicationEventMulticaster，专门用来查找对应ApplicationEvent应该使用哪个ApplicationListener（按类型匹配））
initApplicationEventMulticaster();
// 9. 留给子类初始化其他bean（spring boot中子类会初始化web服务器）
onRefresh();
// 10. 注册所有实现了 ApplicationListener 的 Bean 到广播器中
registerListeners();
// 11. 初始化剩下Bean（非lazy 且 singleton）
finishBeanFactoryInitialization(beanFactory);
// 12. SmartLifecycle的Bean可以start了，并且发布ContextRefreshedEvent事件
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// 异常处理1：销毁已创建的单例 bean，避免资源泄漏
destroyBeans();
// 异常处理2：重置 context 状态标志，保证下次调用 refresh 可以重新开始
cancelRefresh(ex);
throw ex;
}
finally {
// 最终清除 Spring 内部使用的一些缓存（如反射、泛型元信息等）
resetCommonCaches();
}
}
}
关键步骤分析
prepareBeanFactory
目的是对内部 BeanFactory 进行增强配置，注入 ApplicationContext 级别的基础能力，主要包括如下
- 设置类加载器、SpEL 表达式解析器与资源编辑器
- 注册常见 Aware 接口的处理器与特殊依赖的自动解析
- 注册内置基础 Bean（如 Spring Environment、系统属性、系统环境变量）
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 设置类加载器（用于加载 bean 类、AOP 等）
beanFactory.setBeanClassLoader(getClassLoader());
// 设置beanFactory的表达式语言（SpEL）处理器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 设置各种PropertyEditor（用于解析 Resource 等）
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 注册 ApplicationContextAwareProcessor，处理以下几个 Aware 接口注入
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 设置一些忽略自动装配的接口,上面的ApplicationContextAwareProcessor就已经搞定了
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.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 添加ApplicationListener的监听器，当单例bean初始化后，且实现了ApplicationListener接口，就将其缓存起来以便使用
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 如果容器中有 LoadTimeWeaver，注册对应的 Aware 处理器，并设置临时 ClassLoader
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// Spring Environment Bean 注册（当前环境信息）
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
// 系统属性（System.getProperties()）Bean注册
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
// 系统环境变量（System.getenv()）Bean注册
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
invokeBeanFactoryPostProcessors
- 先处理
BeanDefinitionRegistryPostProcessor：
- 手动传入的优先执行
- 容器中的按
PriorityOrdered>Ordered> 剩下的- 若执行过程中有动态注册的后处理器，继续迭代
- 再处理
BeanFactoryPostProcessor：
- 优先级一样，
PriorityOrdered>Ordered> 剩下的- 最后清除合并后的
BeanDefinition缓存，确保后处理器修改生效
ConfigurationClassPostProcessor 就是最早执行的 BeanDefinitionRegistryPostProcessor之一，其负责解析 @Configuration 等注解并动态注册大量 BeanDefinition。因此，我们可以通过自定义 BeanDefinitionRegistryPostProcessor 在它之后介入，统一处理或修改所有后续注册的 BeanDefinition，实现排除、添加或调整。
// PostProcessorRegistrationDelegate类
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// 已经处理过了的BeanDefinitionRegistryPostProcessors集和，避免重复处理bean
Set<String> processedBeans = new HashSet<>();
/// 判断 beanFactory 是否支持注册
/// BeanDefinition，以优先处理BeanDefinitionRegistryPostProcessor
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
} else {
regularPostProcessors.add(postProcessor);
}
}
// 当前阶段要执行的 BeanDefinitionRegistryPostProcessor 处理器列表，处理的优先级：PriorityOrdered >
// Ordered > 剩下的
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// =================== 第一轮：处理 PriorityOrdered 的 BD 处理器 ===================
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true,
false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// =================== 第二轮：处理 Ordered 的 BD 处理器 ===================
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// =================== 最后：处理剩余的无序 BD 处理器（可能动态注册） ===================
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true,
false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors
.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
// =================== 执行所有已注册 BD 处理器的 postProcessBeanFactory 回调
// ===================
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
// =================== 执行用户提供的常规 BeanFactoryPostProcessor ===================
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// =================== 从配置中获取剩余的 BeanFactoryPostProcessor ===================
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// 分类收集 PriorityOrdered、Ordered、其他的 三类处理器
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
} else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
} else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 执行顺序类似上面的BD处理器
// PriorityOrdered
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Ordered
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// 其他的
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// 清理 BeanDefinition 的缓存，防止元信息过期（如占位符已被替换）
beanFactory.clearMetadataCache();
}
registerBeanPostProcessors
实例化并注册所有 BeanPostProcessor，按 PriorityOrdered > Ordered > 无序 的优先级添加到容器中，确保 Bean 生命周期中的处理器执行顺序符合预期；内部处理器（MergedBeanDefinitionPostProcessor）统一放在末尾，确保其在所有普通处理器之后执行。
// PostProcessorRegistrationDelegate类
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 获取所有实现了 BeanPostProcessor 接口的 beanName（不实例化）
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// 记录目标 BeanPostProcessor 总数：现有 + 新注册 + 最终数量
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
/*
* 专门用来检查普通bean是否走完所有的BeanPostProcessor的
*
* 一个普通的bean在实例化时，正常情况下应该走完所有的BeanPostProcessor，
* 但当只注册了部分的BeanPostProcessor(放到IOC容器中)时，
* 此时实例化一个bean可能就导致还未注册的BeanPostProcessor处理不了（看优先级），
* 就会由这个checker来日志提醒（仅打印info日志）
*/
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 准备分组存储不同优先级的 BeanPostProcessor
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 分类：根据是否实现 PriorityOrdered / Ordered / 无排序
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { // PriorityOrdered的直接实例化
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
} else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// PriorityOrdered以及实例化了，就可直接 排序 -> 注册
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Ordered，实例化 -> 排序 -> 注册
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// 无顺序，实例化 -> 注册
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// 四、最后统一注册 MergedBeanDefinitionPostProcessor（内部BPP），例如：
// - AutowiredAnnotationBeanPostProcessor
// - CommonAnnotationBeanPostProcessor
// - ApplicationListenerDetector 等
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// 五、重新注册 ApplicationListenerDetector，用来收集ApplicationListener Bean（确保在链末尾执行（避免过早代理））
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
initApplicationEventMulticaster
注册的默认事件广播器为SimpleApplicationEventMulticaster，其主要是对所有的ApplicationEvent事件进行分发匹配到对应的ApplicationListener中（支持异步，线程池为SimpleApplicationEventMulticaster.taskExecutor，默认同步分发）
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 {
// 实例化并注册默认的事件广播器Bean：SimpleApplicationEventMulticaster
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
一个模板方法（hook），由子类实现，用于在 refresh() 流程中 容器刷新完成、所有 BeanFactory 初始化完毕之后，进行特定上下文的扩展初始化工作。
比如在 Spring Boot 中，AnnotationConfigServletWebServerApplicationContext 会在该方法中创建和启动内嵌的 Web 服务器（默认是 Tomcat，可选 Jetty 或 Undertow），并完成 Web 环境相关的初始化。
finishBeanFactoryInitialization
是 Spring 容器刷新流程中的 核心收尾步骤之一，主要职责如下：
- 初始化所有非懒加载（non-lazy）、非抽象的单例 Bean
- 这一步会触发 Bean 的完整生命周期流程：依赖注入（populate）、初始化方法调用（如
@PostConstruct、InitializingBean#afterPropertiesSet）、AOP 代理包装等
- 这一步会触发 Bean 的完整生命周期流程：依赖注入（populate）、初始化方法调用（如
- 触发
SmartInitializingSingleton回调- 所有实现了
SmartInitializingSingleton接口的单例 Bean，会在 所有非懒加载的单例 Bean 完成初始化之后 统一回调其afterSingletonsInstantiated()方法。 - 这是容器中所有 Bean 都就绪之后的 “最后的hook”，用于执行依赖所有 Bean 的集中初始化逻辑
- 所有实现了
// AbstractApplicationContext
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 清空临时类加载器
beanFactory.setTempClassLoader(null);
// 冻结BeanDefinition的配置，代表需要的地方可以缓存了
// 走到这，BeanDefinition都已经处理完毕了，所以可以考虑缓存了
beanFactory.freezeConfiguration();
// 实例化所有非lazy加载的单例bean，并在加载完后调用SmartInitializingSingleton接口
// SmartInitializingSingleton这个接口就是在实例化所有非lazy且单例bean完成后需要调用的
beanFactory.preInstantiateSingletons();
}
真正初始化单例bean（DefaultListableBeanFactory#preInstantiateSingletons方法）
public void preInstantiateSingletons() throws BeansException {
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 非抽象 + 单例 + 非lazy加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 实例化工厂Bean
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
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 {
// 实例化非工厂Bean
getBean(beanName);
}
}
}
// apply所有SmartInitializingSingleton Bean逻辑
// 重要的拓展口，可以在这里最早感知到大部分Bean准备完毕，可以放心调用这些bean的各种方法了
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
finishRefresh
这一步结束，容器对外就完全可用了
protected void finishRefresh() {
// 清除上下文级别的缓存资源，例如类扫描过程中缓存的 ASM 元数据。
clearResourceCaches();
// 初始化生命周期处理器（LifecycleProcessor）。
// 默认实现为 DefaultLifecycleProcessor，用于统一管理实现了 Lifecycle 接口的 bean 的启动与停止
initLifecycleProcessor();
// 通知生命周期处理器，容器刷新完成
// 将启动所有实现了 SmartLifecycle 接口并设置了 autoStartup = true 的 Bean（通常用于自动启动的组件，如消息监听容器、调度器等）
getLifecycleProcessor().onRefresh();
// 广播容器刷新完成事件：ContextRefreshedEvent
// 所有实现了 ApplicationListener 接口，监听该事件的 Bean 都会收到通知，可用于执行基于“容器就绪”的后置逻辑。
publishEvent(new ContextRefreshedEvent(this));
// 将当前 ApplicationContext 注册到 JMX 的 LiveBeansView 中（如果启用）
// 这允许通过 JMX 客户端动态查看容器中所有 Bean 的状态（例如 VisualVM 插件）
LiveBeansView.registerApplicationContext(this);
}