## 生命周期流程
Spring 中的一个 Bean 从被创建到被销毁，需要经历很多个阶段的生命周期，下图是一个 Bean 从创建到销毁的生命周期流程：
在 Bean 的各个生命周期流程点，Spring 都提供了对应的接口或者注解，以便开发者在各个生命周期的流程点能够做一些自己的操作。
## 案例解析
### 定义 Spring 上下文工具类
Spring 中生命周期最常见的应用可能是定义一个 Spring 上下文的工具类。这个工具类也使用 `@Component` 注解修饰，表明**它也是一个 Bean** ，其次它实现了 `ApplicationContextAware` 接口，则说明它作为一个 Bean 被创建以及初始化的过程中需要调用 `setApplicationContext()` 方法，设置它所在的 Spring 上下文。代码如下：
```java
@Component
public class SpringContextUtils implements ApplicationContextAware {
private static ApplicationContext applicationContext;
/**
* Spring会自动调用这个方法，注入ApplicationContext
*/
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringContextUtils.applicationContext = applicationContext;
}
/**
* 获取ApplicationContext
* @return ApplicationContext
*/
public static ApplicationContext getApplicationContext() {
if (applicationContext == null) {
throw new IllegalStateException("ApplicationContext is not set. Make sure SpringContextUtils is properly initialized.");
}
return applicationContext;
}
/**
* 通过名称获取Bean
* @param name Bean的名称
* @return Bean实例
*/
public static Object getBean(String name) {
return getApplicationContext().getBean(name);
}
/**
* 通过名称和类型获取Bean
* @param name Bean的名称
* @param requiredType Bean的类型
* @param <T> Bean的类型
* @return Bean实例
*/
public static <T> T getBean(String name, Class<T> requiredType) {
return getApplicationContext().getBean(name, requiredType);
}
/**
* 通过类型获取Bean
* @param requiredType Bean的类型
* @param <T> Bean的类型
* @return Bean实例
*/
public static <T> T getBean(Class<T> requiredType) {
return getApplicationContext().getBean(requiredType);
}
}
```
### 在 Bean 的依赖注入之后执行初始化操作
比如下面的案例中，`MyService` 这个 Bean 需要在它的依赖 `MyRepository` 这个 Bean 注入完成之后，调用依赖的 `loadInitialData()` 方法加载初始数据。代码如下：
```java
@Service
public class MyService {
private MyRepository myRepository;
private List<String> initialData;
@Autowired
public void setMyRepository(MyRepository myRepository) {
this.myRepository = myRepository;
}
// 依赖注入完成后执行的初始化方法
@PostConstruct
public void init() {
this.initialData = myRepository.loadInitialData();
}
public void doBusinessLogic() {
}
}
@Service
class MyRepository {
public List<String> loadInitialData() {
}
}
```
`@PostConstruct` 注解是 JSR-250 标准定义的注解，它与 Spring 框架的耦合度比较低。除此之外还可以实现 `InitializingBean` 接口，在它的 `afterPropertiesSet()` 方法中来完成初始化；通过 XML 配置 `init-method` 或者 `@Bean` 注解的 `initMethod` 属性来指定任意的方法作为初始化方法来完成初始化。
## Bean 创建源码解析
在 Spring 源码实现中实际上分为了三个大的步骤：**实例化 -> 填充属性 -> 初始化**。填充属性可以看前面的文章[Spring 中@Autowired，@Resource，@Inject 注解实现原理](https://mp.weixin.qq.com/s/WVpWDU2JXFbpl-hgsywUXQ)。在上面生命周期图片中的从 `XXXAware` 的 `setXXXAware()` 方法到 `postProcessAfterInitialization()` 都属于初始化的这个步骤中。
在 `AbstractAutowireCapableBeanFactory` 中提供的 `doCreateBean()` 方法中提现了这三个大的步骤，其中的 `createBeanInstance()` 方法完成 Bean 的实例化；`populateBean()` 方法完成 Bean的属性填充；`initializeBean()` 方法完成 Bean 的初始化。代码如下：
```java
protected Object doCreateBean(String beanName, RootBeanDefinition mbd,
@Nullable Object[] args) throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (instanceWrapper == null) {
//实例化Bean
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton()
&& this.allowCircularReferences
&& isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
addSingletonFactory(beanName,
() -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//填充Bean的属性，比如处理@Autowired，@Resource，@Inject注解
populateBean(beanName, mbd, instanceWrapper);
//初始化Bean
exposedObject = initializeBean(beanName, exposedObject, mbd);
} catch {
}
}
```
### initializeBean()方法流程
在 `initializeBean()` 方法中又分为：**调用 invokeAwareMethods() 方法 -> 调用 applyBeanPostProcessorsBeforeInitialization() 方法 -> 调用 invokeInitMethods() 方法 -> 调用 applyBeanPostProcessorsAfterInitialization() 方法**，代码如下：
```java
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
//调用Aware()方法
invokeAwareMethods(beanName, bean);
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//调用BeanPostProcessor的postProcessBeforeInitialization()方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//调用初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null), beanName, ex.getMessage(), ex);
}
if (mbd == null || !mbd.isSynthetic()) {
//调用BeanPostProcessor的postProcessAfterInitialization()方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
```
### invokeAwareMethods()方法流程
需要注意的是 `invokeAwareMethods()` 方法中仅仅只调用实现了 `BeanNameAware`，`BeanClassLoaderAware`，`BeanFactoryAware` 接口的方法。而常见的 `ApplicationContextAware` 接口的 `setApplicationContext()` 方法则是在 `ApplicationContextAwareProcessor` 的 `postProcessBeforeInitialization()` 方法中调用的。代码如下：
```java
public abstract class AbstractAutowireCapableBeanFactory {
private void invokeAwareMethods(String beanName, Object bean) {
if (bean instanceof Aware) {
if (bean instanceof BeanNameAware beanNameAware) {
//调用setBeanName()方法
beanNameAware.setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware beanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
//调用setBeanClassLoader()方法
beanClassLoaderAware.setBeanClassLoader(bcl);
}
}
if (bean instanceof BeanFactoryAware beanFactoryAware) {
//调用setBeanFactory()方法
beanFactoryAware.setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
}
class ApplicationContextAwareProcessor {
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof Aware) {
this.invokeAwareInterfaces(bean);
}
return bean;
}
private void invokeAwareInterfaces(Object bean) {
if (bean instanceof EnvironmentAware environmentAware) {
environmentAware.setEnvironment(this.applicationContext.getEnvironment());
}
if (bean instanceof EmbeddedValueResolverAware embeddedValueResolverAware) {
embeddedValueResolverAware.setEmbeddedValueResolver(this.embeddedValueResolver);
}
if (bean instanceof ResourceLoaderAware resourceLoaderAware) {
resourceLoaderAware.setResourceLoader(this.applicationContext);
}
if (bean instanceof ApplicationEventPublisherAware applicationEventPublisherAware) {
applicationEventPublisherAware.setApplicationEventPublisher(this.applicationContext);
}
if (bean instanceof MessageSourceAware messageSourceAware) {
messageSourceAware.setMessageSource(this.applicationContext);
}
if (bean instanceof ApplicationStartupAware applicationStartupAware) {
applicationStartupAware.setApplicationStartup(this.applicationContext.getApplicationStartup());
}
if (bean instanceof ApplicationContextAware applicationContextAware) {
//这里调用的setApplicationContext()方法
applicationContextAware.setApplicationContext(this.applicationContext);
}
}
}
```
### applyBeanPostProcessorsBeforeInitialization() 方法流程
在该方法中主要就是查找所有实现了 `BeanPostProcessor` 接口的对象，然后循环调用其 `postProcessBeforeInitialization()` 方法。代码如下：
```java
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessBeforeInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
```
在 Spring 中提供了 `CommonAnnotationBeanPostProcessor`（`@Resource` 注解也是它处理的） 实现了 `BeanPostProcessor` 接口，在它的构造函数里面初始化了要处理 `@PostConstruct` 注解。代码如下：
```java
public CommonAnnotationBeanPostProcessor() {
setOrder(Ordered.LOWEST_PRECEDENCE - 3);
// Jakarta EE 9 set of annotations in jakarta.annotation package
addInitAnnotationType(loadAnnotationType("jakarta.annotation.PostConstruct"));
addDestroyAnnotationType(loadAnnotationType("jakarta.annotation.PreDestroy"));
// Tolerate legacy JSR-250 annotations in javax.annotation package
addInitAnnotationType(loadAnnotationType("javax.annotation.PostConstruct"));
addDestroyAnnotationType(loadAnnotationType("javax.annotation.PreDestroy"));
}
```
然后在它的子类 `InitDestroyAnnotationBeanPostProcessor` 的 `postProcessBeforeInitialization()` 实现了查找 `@PostConstruct` 注解修饰的方法，然后调用的逻辑。代码如下：
```java
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
try {
metadata.invokeInitMethods(bean, beanName);
}
catch (InvocationTargetException ex) {
throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
}
return bean;
}
```
### invokeInitMethods() 方法流程
在该方法中会先判断 Bean 是否实现了 `InitializingBean` 接口，如果实现了则调用其 `afterPropertiesSet()` 方法，然后查看 Bean 定义中是否有自定义的初始化方法，如果有的话，则调用自定义的初始化方法。代码如下：
```java
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.hasAnyExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
//调用afterPropertiesSet()方法
((InitializingBean) bean).afterPropertiesSet();
}
if (mbd != null && bean.getClass() != NullBean.class) {
String[] initMethodNames = mbd.getInitMethodNames();
if (initMethodNames != null) {
for (String initMethodName : initMethodNames) {
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.hasAnyExternallyManagedInitMethod(initMethodName)) {
//调用自定义初始化方法
invokeCustomInitMethod(beanName, bean, mbd, initMethodName);
}
}
}
}
}
protected void invokeCustomInitMethod(String beanName, Object bean, RootBeanDefinition mbd, String initMethodName)
throws Throwable {
Class<?> beanClass = bean.getClass();
MethodDescriptor descriptor = MethodDescriptor.create(beanName, beanClass, initMethodName);
String methodName = descriptor.methodName();
Method initMethod = (mbd.isNonPublicAccessAllowed() ?
BeanUtils.findMethod(descriptor.declaringClass(), methodName) :
ClassUtils.getMethodIfAvailable(beanClass, methodName));
//省略代码
Method methodToInvoke = ClassUtils.getPubliclyAccessibleMethodIfPossible(initMethod, beanClass);
try {
ReflectionUtils.makeAccessible(methodToInvoke);
//这里通过反射的方式调用初始化方法
methodToInvoke.invoke(bean);
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
```
### applyBeanPostProcessorsBeforeInitialization() 方法流程
在该方法中主要就是查找所有实现了 `BeanPostProcessor` 接口的对象，然后循环调用其 `postProcessAfterInitialization()` 方法。代码如下：
```java
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
try {
metadata.invokeInitMethods(bean, beanName);
}
catch (InvocationTargetException ex) {
throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
}
return bean;
}
```
