544 lines
21 KiB
Markdown
544 lines
21 KiB
Markdown
# 一、IOC
|
||
  Spring框架的核心是IOC（控制反转）容器，它负责管理应用程序中的对象（称为Bean）的创建、配置和组装。
|
||
|
||
# 二、Bean
|
||
## 2.1 定义
|
||
  在Spring中，Bean是指由Spring IOC容器管理的对象实例。这些对象不再由应用程序直接创建，而是由容器负责实例化、配置和组装。
|
||
  例如@Service、@Controller就是特殊的Bean。
|
||
|
||
## 2.2 特点
|
||
- 由容器管理：生命周期由Spring容器控制
|
||
- 可配置性：通过配置元数据定义Bean的行为
|
||
- 依赖注入：容器自动处理Bean之间的依赖关系
|
||
- 作用域支持：支持singleton、prototype等不同作用域
|
||
|
||
## 2.3 创建方式
|
||
```java
|
||
// 1. 通过@Component注解
|
||
@Component
|
||
public class UserService {
|
||
// ...
|
||
}
|
||
|
||
// 2. 通过@Bean注解（配置类中）
|
||
@Configuration
|
||
public class AppConfig {
|
||
@Bean
|
||
public DataSource dataSource() {
|
||
return new DataSource();
|
||
}
|
||
}
|
||
|
||
// 3. 通过XML配置
|
||
<bean id="userService" class="com.example.UserService"/>
|
||
```
|
||
|
||
## 2.4 作用域
|
||
  控制 Bean 在容器中的实例数量和生命周期。Spring 提供多种作用域，默认是 singleton。通过 @Scope 注解指定，如 @Scope("prototype")。
|
||
- singleton（单例）：容器中只有一个实例，所有请求共享该实例（默认值）。
|
||
- prototype（多例）：每次请求（如 getBean()）都会创建新实例，容器不管理其销毁。
|
||
- request（Web）：每个 HTTP 请求创建一个实例，仅在当前请求有效。
|
||
- session（Web）：每个会话创建一个实例，在会话有效期内有效。
|
||
|
||
## 2.5 生命周期
|
||
1. 实例化（Instantiation）：容器通过构造器创建 Bean 实例（分配内存）。
|
||
2. 属性注入（Population）：容器将依赖的 Bean 注入到当前 Bean 的字段或方法（如 @Autowired 标注的依赖）。
|
||
3. 初始化前（Post-processing before initialization）：
|
||
执行 BeanPostProcessor 的 postProcessBeforeInitialization 方法（AOP 代理生成在此阶段）。
|
||
4. 初始化（Initialization）：
|
||
调用 @PostConstruct 注解的方法（JSR-250 标准，推荐）。
|
||
若实现 InitializingBean 接口，调用 afterPropertiesSet() 方法。
|
||
执行自定义初始化方法（如 @Bean(initMethod = "init") 中指定的 init 方法）。
|
||
5. 初始化后（Post-processing after initialization）：
|
||
执行 BeanPostProcessor 的 postProcessAfterInitialization 方法。
|
||
6. 使用（In Use）：Bean 被应用程序调用。
|
||
7. 销毁（Destruction）：
|
||
调用 @PreDestroy 注解的方法（JSR-250 标准，推荐）。
|
||
若实现 DisposableBean 接口，调用 destroy() 方法。
|
||
执行自定义销毁方法（如 @Bean(destroyMethod = "destroy") 中指定的 destroy 方法）。
|
||
|
||
|
||
|
||
|
||
# 三、BeanDefinition
|
||
## 3.1 定义
|
||
  BeanDefinition是Spring框架中描述Bean的元数据对象，它包含了创建Bean实例所需的所有信息。
|
||
|
||
## 3.2 作用
|
||
- 定义Bean的类名
|
||
- 设置Bean的作用域
|
||
- 配置Bean的属性值
|
||
- 定义依赖关系
|
||
- 配置初始化/销毁方法
|
||
|
||
## 3.3 结构
|
||
```xml
|
||
BeanDefinition (接口)
|
||
↑
|
||
AbstractBeanDefinition (抽象类)
|
||
↑
|
||
RootBeanDefinition, GenericBeanDefinition, ChildBeanDefinition
|
||
```
|
||
|
||
## 3.4 关键属性
|
||
```java
|
||
public interface BeanDefinition {
|
||
// Bean的类名
|
||
void setBeanClassName(String beanClassName);
|
||
String getBeanClassName();
|
||
|
||
// 作用域（singleton、prototype等）
|
||
void setScope(String scope);
|
||
String getScope();
|
||
|
||
// 是否延迟初始化
|
||
void setLazyInit(boolean lazyInit);
|
||
boolean isLazyInit();
|
||
|
||
// 依赖的Bean名称
|
||
void setDependsOn(String... dependsOn);
|
||
String[] getDependsOn();
|
||
|
||
// 初始化方法
|
||
void setInitMethodName(String initMethodName);
|
||
String getInitMethodName();
|
||
|
||
// 销毁方法
|
||
void setDestroyMethodName(String destroyMethodName);
|
||
String getDestroyMethodName();
|
||
|
||
// 工厂方法名
|
||
void setFactoryMethodName(String factoryMethodName);
|
||
String getFactoryMethodName();
|
||
}
|
||
```
|
||
|
||
## 3.5 创建过程
|
||
```java
|
||
// 编程方式创建BeanDefinition
|
||
GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
|
||
beanDefinition.setBeanClassName("com.example.UserService");
|
||
beanDefinition.setScope(BeanDefinition.SCOPE_SINGLETON);
|
||
beanDefinition.setLazyInit(false);
|
||
|
||
// 注册到BeanFactory
|
||
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
|
||
beanFactory.registerBeanDefinition("userService", beanDefinition);
|
||
```
|
||
|
||
# 四、BeanFactory
|
||
## 4.1 定义
|
||
  BeanFactory是Spring IOC容器的根接口，提供了最基本的IOC功能。它是访问Spring容器的基本客户端视图。
|
||
|
||
## 4.2 结构
|
||
```xml
|
||
BeanFactory (根接口)
|
||
↑
|
||
ListableBeanFactory, HierarchicalBeanFactory, AutowireCapableBeanFactory
|
||
↑
|
||
ConfigurableBeanFactory, ConfigurableListableBeanFactory
|
||
↑
|
||
DefaultListableBeanFactory (主要实现类)
|
||
```
|
||
|
||
## 4.3 核心方法
|
||
```java
|
||
public interface BeanFactory {
|
||
// 根据名称获取Bean实例
|
||
Object getBean(String name) throws BeansException;
|
||
|
||
// 根据名称和类型获取Bean实例
|
||
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
|
||
|
||
// 根据类型获取Bean实例
|
||
<T> T getBean(Class<T> requiredType) throws BeansException;
|
||
|
||
// 判断是否包含指定名称的Bean
|
||
boolean containsBean(String name);
|
||
|
||
// 判断Bean是否是单例
|
||
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
|
||
|
||
// 判断Bean是否是原型
|
||
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
|
||
|
||
// 获取Bean的类型
|
||
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
|
||
}
|
||
```
|
||
|
||
## 4.4 实现示例
|
||
```java
|
||
// 创建BeanFactory实例
|
||
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
|
||
|
||
// 创建BeanDefinition
|
||
GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
|
||
beanDefinition.setBeanClassName("com.example.UserService");
|
||
|
||
// 注册BeanDefinition
|
||
beanFactory.registerBeanDefinition("userService", beanDefinition);
|
||
|
||
// 获取Bean实例
|
||
UserService userService = beanFactory.getBean("userService", UserService.class);
|
||
```
|
||
|
||
## 4.5 特点
|
||
- 轻量级：功能相对简单，资源消耗少
|
||
- 延迟加载：默认在第一次请求时才创建Bean实例
|
||
- 基础功能：提供最基本的IOC功能
|
||
|
||
# 五、ApplicationContext
|
||
## 5.1 定义
|
||
  ApplicationContext是BeanFactory的子接口，在BeanFactory的基础上提供了更多企业级功能，是Spring容器的完整实现。
|
||
|
||
## 5.2 结构
|
||
```xml
|
||
BeanFactory
|
||
↑
|
||
ApplicationContext (扩展接口)
|
||
↑
|
||
ConfigurableApplicationContext
|
||
↑
|
||
AbstractApplicationContext
|
||
↑
|
||
ClassPathXmlApplicationContext, FileSystemXmlApplicationContext,
|
||
AnnotationConfigApplicationContext, WebApplicationContext
|
||
```
|
||
|
||
## 5.3 特点
|
||
- 完整的IOC功能：包含BeanFactory的所有功能
|
||
- 预实例化单例Bean：默认在启动时创建单例Bean
|
||
- 企业级功能：支持AOP、事务管理、国际化等
|
||
- 资源访问：统一的资源访问接口
|
||
- 事件机制：支持应用内事件发布/订阅
|
||
|
||
## 5.4 refresh方法
|
||
```java
|
||
// AbstractApplicationContext.java
|
||
/**
|
||
* Spring ApplicationContext 的核心启动方法
|
||
* 定义了容器初始化的完整生命周期
|
||
*/
|
||
public void refresh() throws BeansException, IllegalStateException {
|
||
// 使用同步锁确保容器启动的线程安全性，防止并发刷新
|
||
synchronized (this.startupShutdownMonitor) {
|
||
|
||
// [1] 准备刷新容器 - 设置启动状态，验证环境配置
|
||
prepareRefresh();
|
||
|
||
// [2] 获取或创建BeanFactory - 创建DefaultListableBeanFactory实例
|
||
// 如果是XML配置，会在这里加载和解析XML文件
|
||
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
|
||
|
||
// [3] 配置BeanFactory - 设置类加载器、注册核心BeanPostProcessor等
|
||
prepareBeanFactory(beanFactory);
|
||
|
||
try {
|
||
// [4] 后处理BeanFactory - 模板方法，允许子类进行特殊配置
|
||
// Web应用会在这里注册Servlet相关的Scope
|
||
postProcessBeanFactory(beanFactory);
|
||
|
||
// [5] 🚀 关键步骤：调用BeanFactory后置处理器
|
||
// 执行BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor
|
||
// ConfigurationClassPostProcessor在这里扫描@Component、@Configuration等注解
|
||
invokeBeanFactoryPostProcessors(beanFactory);
|
||
|
||
// [6] 注册Bean后置处理器 - 注册所有BeanPostProcessor
|
||
// 包括AOP、事务、自定义的BeanPostProcessor，此时只是注册，还未执行
|
||
registerBeanPostProcessors(beanFactory);
|
||
|
||
// [7] 初始化消息源 - 设置国际化消息资源
|
||
// 用于支持多语言消息解析
|
||
initMessageSource();
|
||
|
||
// [8] 初始化应用事件广播器 - 创建事件发布机制的核心组件
|
||
// 用于发布ApplicationEvent事件
|
||
initApplicationEventMulticaster();
|
||
|
||
// [9] 模板方法：子类可以在这里执行特殊的刷新逻辑
|
||
// SpringBoot在这里启动内嵌的Tomcat服务器
|
||
onRefresh();
|
||
|
||
// [10] 注册监听器 - 将所有ApplicationListener注册到事件广播器
|
||
// 包括静态指定的监听器和从BeanFactory中获取的监听器
|
||
registerListeners();
|
||
|
||
// [11] 🏭 核心步骤：完成BeanFactory的初始化
|
||
// 实例化所有非懒加载的单例Bean，执行依赖注入、AOP代理等
|
||
finishBeanFactoryInitialization(beanFactory);
|
||
|
||
// [12] 完成刷新过程 - 发布ContextRefreshedEvent事件
|
||
// 标记容器启动完成，可以正常工作了
|
||
finishRefresh();
|
||
|
||
} catch (BeansException ex) {
|
||
// 如果刷新过程中出现异常，需要销毁已经创建的单例Bean，防止资源泄漏
|
||
if (logger.isWarnEnabled()) {
|
||
logger.warn("Exception encountered during context initialization - " +
|
||
"cancelling refresh attempt: " + ex);
|
||
}
|
||
|
||
// 销毁已经创建的单例Bean
|
||
destroyBeans();
|
||
|
||
// 重置容器状态为未激活
|
||
cancelRefresh(ex);
|
||
|
||
// 重新抛出异常
|
||
throw ex;
|
||
} finally {
|
||
// 最后重置一些公共的缓存，比如反射缓存
|
||
resetCommonCaches();
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
### 5.4.1 prepareRefresh()
|
||
```java
|
||
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();
|
||
this.earlyApplicationEvents = new LinkedHashSet<>();
|
||
}
|
||
```
|
||
|
||
- 这是容器启动的第一步，主要做初始化准备工作
|
||
- 设置容器的启动时间戳和活跃状态
|
||
- 验证必要的环境属性是否配置正确（比如通过@Value注解标记为必须的属性）
|
||
- 初始化早期事件集合，用于存储在事件多播器创建前发布的事件
|
||
- 为整个刷新过程奠定基础状态
|
||
|
||
### 5.4.2 obtainFreshBeanFactory()
|
||
```java
|
||
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
|
||
refreshBeanFactory();
|
||
return getBeanFactory();
|
||
}
|
||
|
||
// 子类实现示例
|
||
protected final void refreshBeanFactory() throws IllegalStateException {
|
||
if (hasBeanFactory()) {
|
||
destroyBeans();
|
||
closeBeanFactory();
|
||
}
|
||
try {
|
||
DefaultListableBeanFactory beanFactory = createBeanFactory();
|
||
customizeBeanFactory(beanFactory);
|
||
loadBeanDefinitions(beanFactory);
|
||
this.beanFactory = beanFactory;
|
||
}
|
||
catch (IOException ex) {
|
||
throw new ApplicationContextException("I/O error", ex);
|
||
}
|
||
}
|
||
```
|
||
|
||
- 创建或刷新底层的BeanFactory（Spring容器的核心工厂）
|
||
- 如果是刷新操作，会先销毁旧的BeanFactory和所有Bean实例
|
||
- 创建新的DefaultListableBeanFactory实例
|
||
- 加载Bean定义（从XML文件或注解配置中解析Bean的元数据）
|
||
- 这个步骤完成后，容器就知道了有哪些Bean需要管理，但还没有创建Bean实例
|
||
|
||
### 5.4.3 prepareBeanFactory()
|
||
```java
|
||
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
|
||
beanFactory.setBeanClassLoader(getClassLoader());
|
||
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver());
|
||
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
|
||
|
||
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
|
||
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
|
||
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
|
||
|
||
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
|
||
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
|
||
}
|
||
```
|
||
|
||
- 配置BeanFactory的基本设置和功能组件
|
||
- 设置类加载器、SPEL表达式解析器、属性编辑器
|
||
- 注册ApplicationContextAwareProcessor，这是实现各种Aware接口的关键
|
||
- 忽略某些接口的依赖注入（这些接口由容器特殊处理）
|
||
- 注册可解析的依赖关系，当Bean需要这些类型时直接返回容器实例
|
||
- 为BeanFactory添加基本的功能支持
|
||
|
||
### 5.4.4 postProcessBeanFactory()
|
||
```java
|
||
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
|
||
// 空方法 - 模板方法模式
|
||
// 子类可以覆盖此方法添加特定逻辑
|
||
}
|
||
```
|
||
|
||
- 模板方法，允许子类在标准初始化后对BeanFactory进行自定义配置
|
||
- 在Web环境中，会在这里注册Servlet相关的Scope（request、session等）
|
||
- 可以添加特定环境的BeanPostProcessor或进行其他特殊配置
|
||
- 这是框架扩展的重要切入点
|
||
|
||
### 5.4.5 invokeBeanFactoryPostProcessors()
|
||
```java
|
||
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
|
||
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
|
||
}
|
||
```
|
||
|
||
- 🚀 这是最关键的一步，负责扫描和注册所有的Bean定义
|
||
- 执行所有BeanFactoryPostProcessor，它们可以修改Bean的定义信息
|
||
- 特别是ConfigurationClassPostProcessor，它负责：
|
||
扫描@Component、@Service、@Repository等注解
|
||
处理@Configuration配置类
|
||
解析@Bean方法定义
|
||
处理@Import、@ComponentScan等注解
|
||
- 这一步完成后，所有的Bean定义都已经被解析和注册
|
||
|
||
### 5.4.6 registerBeanPostProcessors()
|
||
```java
|
||
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
|
||
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
|
||
}
|
||
```
|
||
|
||
- 注册所有的BeanPostProcessor到BeanFactory中
|
||
- 包括AOP、事务管理、自定义的Bean后置处理器等
|
||
- 注意：此时只是注册，真正的调用要等到Bean实例化时
|
||
- 这些处理器按照优先级顺序注册，确保执行顺序正确
|
||
- 这是Spring AOP和事务管理等高级功能的基础
|
||
|
||
### 5.4.7 initMessageSource()
|
||
```java
|
||
protected void initMessageSource() {
|
||
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
|
||
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
|
||
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
|
||
}
|
||
else {
|
||
DelegatingMessageSource dms = new DelegatingMessageSource();
|
||
this.messageSource = dms;
|
||
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
|
||
}
|
||
}
|
||
```
|
||
|
||
- 初始化国际化消息支持
|
||
- 如果用户配置了自定义的MessageSource，就使用用户的配置
|
||
- 否则创建默认的DelegatingMessageSource
|
||
- 支持从属性文件读取多语言消息，实现国际化功能
|
||
- 用于解析${}占位符和国际化消息
|
||
|
||
### 5.4.8 initApplicationEventMulticaster()
|
||
```java
|
||
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);
|
||
}
|
||
else {
|
||
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
|
||
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
|
||
}
|
||
}
|
||
```
|
||
|
||
- 初始化应用事件发布机制的核心组件
|
||
- 如果用户配置了自定义的事件广播器，就使用用户的配置
|
||
- 否则创建默认的SimpleApplicationEventMulticaster
|
||
- 这个组件负责将应用事件广播给所有监听器
|
||
- 支持观察者模式，实现应用内组件间的解耦通信
|
||
|
||
### 5.4.9 onRefresh() - 刷新时扩展点
|
||
```java
|
||
protected void onRefresh() throws BeansException {
|
||
// 空方法 - 模板方法
|
||
}
|
||
```
|
||
|
||
- 模板方法，允许子类在特定时机执行自定义逻辑
|
||
- 在Spring Boot中，这里会启动内嵌的Web服务器（Tomcat、Jetty等）
|
||
- 在Spring MVC中，这里会初始化HandlerMapping、HandlerAdapter等组件
|
||
- 这是框架扩展的重要切入点，不同的ApplicationContext实现有不同的行为
|
||
|
||
### 5.4.10 registerListeners()
|
||
```java
|
||
protected void registerListeners() {
|
||
for (ApplicationListener<?> listener : getApplicationListeners()) {
|
||
getApplicationEventMulticaster().addApplicationListener(listener);
|
||
}
|
||
|
||
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
|
||
for (String listenerBeanName : listenerBeanNames) {
|
||
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
|
||
}
|
||
|
||
// 发布早期事件
|
||
if (this.earlyApplicationEvents != null) {
|
||
for (ApplicationEvent earlyEvent : this.earlyApplicationEvents) {
|
||
getApplicationEventMulticaster().multicastEvent(earlyEvent);
|
||
}
|
||
}
|
||
}
|
||
```
|
||
|
||
- 注册所有的事件监听器到事件广播器
|
||
- 包括静态注册的监听器和从BeanFactory中获取的监听器Bean
|
||
- 发布在监听器注册前收集的早期事件
|
||
- 确保事件发布机制完整可用，应用事件能够正确分发
|
||
|
||
### 5.4.11 finishBeanFactoryInitialization()
|
||
```java
|
||
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
|
||
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME)) {
|
||
beanFactory.setConversionService(beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
|
||
}
|
||
|
||
if (!beanFactory.hasEmbeddedValueResolver()) {
|
||
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
|
||
}
|
||
|
||
beanFactory.freezeConfiguration();
|
||
beanFactory.preInstantiateSingletons();
|
||
}
|
||
```
|
||
|
||
- 🏭 这是最核心的步骤，真正创建Bean实例
|
||
- 初始化类型转换服务（ConversionService）
|
||
- 注册嵌入式值解析器（用于解析${}占位符）
|
||
- 冻结Bean定义，防止后续修改
|
||
- 实例化所有非懒加载的单例Bean，这个过程中会：
|
||
创建Bean实例
|
||
执行依赖注入（@Autowired、@Resource等）
|
||
执行BeanPostProcessor（AOP代理在这里发生）
|
||
调用初始化方法（@PostConstruct、InitializingBean）
|
||
- 这是容器启动过程中最耗时的步骤
|
||
|
||
### 5.4.12 finishRefresh()
|
||
```java
|
||
protected void finishRefresh() {
|
||
clearResourceCaches();
|
||
initLifecycleProcessor();
|
||
getLifecycleProcessor().onRefresh();
|
||
publishEvent(new ContextRefreshedEvent(this));
|
||
LiveBeansView.registerApplicationContext(this);
|
||
}
|
||
```
|
||
|
||
- 完成容器的启动过程，进行最后的清理和通知工作
|
||
- 清除资源缓存，释放临时资源
|
||
- 初始化生命周期处理器，管理Bean的生命周期
|
||
- 发布ContextRefreshedEvent事件，通知所有监听器容器已启动完成
|
||
- 注册LiveBeansView（用于监控和调试）
|
||
- 标记整个容器启动流程结束，容器进入就绪状态
|
||
|
||
### 5.4.13 总结
|
||
  refresh()方法按固定顺序执行12个步骤，核心可归纳为：准备容器环境 → 解析并注册Bean定义→ 初始化事件、消息等基础设施 → 实例化所有非懒加载的单例Bean→ 完成启动并发布事件。整个过程通过模板方法模式定义，确保了扩展性和一致性。
|
||
  核心在于两个关键扩展机制：BeanFactoryPostProcessor在Bean定义阶段介入，负责修改和注册Bean的定义信息；BeanPostProcessor在Bean实例化阶段介入，负责对创建好的Bean实例进行增强和包装。
|