Spring Bean的生命周期源码解析

---

前言

这一篇文章主要旨在让大家明白整体的bean生命周期从头到尾都干了些什么，所以不会对每个细节源码进行特别详细的描述，一篇文章也无法说完，后续文章会对每个环节进行单独解析

Spring最重要的功能就是帮助程序员创建对象（也就是IOC），而启动Spring就是为创建Bean对象做准备，所以我们先明白Spring到底是怎么去创建Bean的，也就是先弄明白Bean的生命周期。

Bean的生命周期就是指：在Spring中，一个Bean是如何生成的，如何销毁的

从createBean开始解析

refresh->finishBeanFactoryInitialization->AbstractBeanFactory#doGetBean->createBean
1

---

零、Bean生命周期流程图

先看个图有个大概印象，然后在看每个步骤具体干了啥

---

一、加载类

BeanDefinition合并之后，就可以去创建Bean对象了，而创建Bean就必须实例化对象，而实例化就必须先加载当前BeanDefinition所对应的class，在AbstractAutowireCapableBeanFactory类的createBean()方法中，一开始就会调用：

Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
1

这行代码就是去加载类，该方法是这么实现的：

if (mbd.hasBeanClass()) {
 return mbd.getBeanClass();
}
if (System.getSecurityManager() != null) {
 return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->
  doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
 }
else {
 return doResolveBeanClass(mbd, typesToMatch);
}
1
2
3
4
5
6
7
8
9
10

1、如果beanClass属性的类型是Class，那么就直接返回。

2、如果不是，则会根据类名进行加载（doResolveBeanClass方法所做的事情）会利用BeanFactory所设置的类加载器来加载类。

3、如果没有设置，则默认使用**ClassUtils.getDefaultClassLoader()**所返回的类加载器来加载。

ClassUtils.getDefaultClassLoader()
1、优先返回当前线程中的ClassLoader

2、线程中类加载器为null的情况下，返回ClassUtils类的类加载器

3、如果ClassUtils类的类加载器为空，那么则表示是Bootstrap类加载器加载的ClassUtils类，那么则返回系统类加载器

---

二、实例化前

当前BeanDefinition对应的类成功加载后，就可以实例化对象了，但是…
​

在Spring中，实例化对象之前，Spring提供了一个扩展点，允许用户来控制是否在某个或某些Bean实例化之前做一些启动动作。

---

2.1、使用案例

@Component
public class LjcBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {

        if ("userService".equals(beanName)) {
            System.out.println("实例化前");
            return new UserService();
        }
        return null;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

userService这个Bean，在实例化前会直接返回一个由我们所定义的UserService对象。

如果是这样，表示不需要Spring来实例化了，并且后续的Spring依赖注入也不会进行了，会跳过一些步骤，直接执行初始化后这一步。

---

2.2、源码—InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()

			// 让BeanPostProcessors有机会返回一个代理，而不是目标bean实例。
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) {
				return bean;
			}
1
2
3
4
5

这个扩展点叫InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()。

protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				// 如果实现了这个接口则在实例化之前，进行回调
				Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
				if (result != null) {
					return result;
				}
			}
		}
		return null;
	}
1
2
3
4
5
6
7
8
9
10
11
12
13

---

三、实例化

在这个步骤中就会根据BeanDefinition去创建一个对象了。

---

3.1、Supplier创建对象

首先判断BeanDefinition中是否设置了Supplier，如果设置了则调用Supplier的get()得到对象。
​
得直接使用BeanDefinition对象来设置Supplier，比如：

AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setInstanceSupplier(new Supplier<Object>() {
 @Override
 public Object get() {
  return new UserService();
 }
});
context.registerBeanDefinition("userService", beanDefinition);
1
2
3
4
5
6
7
8

---

3.2、工厂方法创建对象

如果没有设置Supplier，则检查BeanDefinition中是否设置了factoryMethod，也就是工厂方法，有两种方式可以设置factoryMethod，比如：
​

方式一：

<bean id="userService" class="com.zhouyu.service.UserService" factory-method="createUserService" />
1

对应的UserService类为：

public class UserService {

 public static UserService createUserService() {
  System.out.println("执行createUserService()");
  UserService userService = new UserService();
  return userService;
 }

 public void test() {
  System.out.println("test");
 }

}
1
2
3
4
5
6
7
8
9
10
11
12
13

方式二：

<bean id="commonService" class="com.zhouyu.service.CommonService"/>
<bean id="userService1" factory-bean="commonService" factory-method="createUserService" />
1
2

对应的CommonService的类为：

public class CommonService {

 public UserService createUserService() {
  return new UserService();
 }
}
1
2
3
4
5
6

Spring发现当前BeanDefinition方法设置了工厂方法后，就会区分这两种方式，然后调用工厂方法得到对象。
​

值得注意的是，我们通过@Bean所定义的BeanDefinition，是存在factoryMethod和factoryBean的，也就是和上面的方式二非常类似，@Bean所注解的方法就是factoryMethod，AppConfig对象就是factoryBean。如果@Bean所所注解的方法是static的，那么对应的就是方式一。

---

3.3、推断构造方法

推断完构造方法后，就会使用构造方法来进行实例化了。
​
在推断构造方法逻辑中除开会去选择构造方法以及查找入参对象以外，会还判断是否在对应的类中是否存在使用**@Lookup注解**了方法。

如果存在则把该方法封装为LookupOverride对象并添加到BeanDefinition中。
​
在实例化时，如果判断出来当前BeanDefinition中没有LookupOverride，那就直接用构造方法反射得到一个实例对象。

如果存在LookupOverride对象，也就是类中存在@Lookup注解了的方法，那就会生成一个代理对象。
​

​

@Lookup注解就是方法注入，使用demo如下：

@Component
public class UserService {

 private OrderService orderService;

 public void test() {
  OrderService orderService = createOrderService();
  System.out.println(orderService);
 }

 @Lookup("orderService")
 public OrderService createOrderService() {
  return null;
 }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

---

3.4、源码

调用AbstractAutowireCapableBeanFactory–》doCreateBean --》createBeanInstance

BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			// 真正实例化的地方
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
1
2
3
4
5
6
7
8

---

四、BeanDefinition的后置处理

Bean对象实例化出来之后，接下来就应该给对象的属性赋值了。在真正给属性赋值之前，Spring又提供了一个扩展点

MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()，可以对此时的BeanDefinition进行加工，比如

4.1、使用案例

@Component
public class LjcMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {

 @Override
 public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
  if ("userService".equals(beanName)) {
   beanDefinition.getPropertyValues().add("orderService", new OrderService());
  }
 }
}
1
2
3
4
5
6
7
8
9
10

在Spring源码中，AutowiredAnnotationBeanPostProcessor就是一个MergedBeanDefinitionPostProcessor，它的postProcessMergedBeanDefinition()中会去查找注入点，并缓存在AutowiredAnnotationBeanPostProcessor对象的一个Map中（injectionMetadataCache）。

---

4.2、源码

synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					// BeanDefinition的后置处理
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}
1
2
3
4
5
6
7
8
9
10
11
12
13

遍历BeanPostProcessors集合、如果有实现MergedBeanDefinitionPostProcessor,则调用postProcessMergedBeanDefinition

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof MergedBeanDefinitionPostProcessor) {
				MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
				bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
			}
		}
	}
1
2
3
4
5
6
7
8

---

五、实例化后

在处理完BeanDefinition后，Spring又设计了一个扩展点：InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()，比如：

5.1、使用案例

@Component
public class LjcInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

 @Override
 public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {

  if ("userService".equals(beanName)) {
   UserService userService = (UserService) bean;
   userService.test();
  }

  return true;
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

上述代码就是对userService所实例化出来的对象进行处理。

---

5.2、源码

调用地址：AbstractAutowireCapableBeanFactory#populateBean

if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						return;
					}
				}
			}
		}
1
2
3
4
5
6
7
8
9
10

​
这个扩展点，在Spring源码中基本没有怎么使用。

---

六、自动注入（spring自带）

这里的自动注入指的是Spring的自动注入，后续依赖注入文章中单独讲

主要是指Bytype和byname，只是现在基本大家都不怎么用了，都是用@autowried了，所以就不展示案例了 。

---

6.1、源码

调用地址：AbstractAutowireCapableBeanFactory#populateBean

PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			// Add property values based on autowire by name if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// Add property values based on autowire by type if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

七、属性填充（依赖注入）

这个步骤中，就会处理@Autowired、@Resource、@Value等注解，也是通过
InstantiationAwareBeanPostProcessor.postProcessProperties()扩展点来实现的。

7.1、使用案例

实现一个自己的自动注入功能

@Component
public class LjcInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

 @Override
 public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
  if ("userService".equals(beanName)) {
   for (Field field : bean.getClass().getFields()) {
    if (field.isAnnotationPresent(LjcInject.class)) {
     field.setAccessible(true);
     try {
      field.set(bean, "123");
     } catch (IllegalAccessException e) {
      e.printStackTrace();
     }
    }
   }
  }

  return pvs;
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

关于@Autowired、@Resource、@Value的底层源码，会在后续的依赖注入文章中单独说明

---

7.2、源码

源码位置：AbstractAutowireCapableBeanFactory#populateBean

PropertyDescriptor[] filteredPds = null;
		if (hasInstAwareBpps) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			// 遍历调用
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
					if (pvsToUse == null) {
						if (filteredPds == null) {
							filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
						}
						pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvsToUse == null) {
							return;
						}
					}
					pvs = pvsToUse;
				}
			}
		}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

---

八、执行Aware

完成了属性赋值之后，Spring会执行一些回调，包括：

BeanNameAware：回传beanName给bean对象。

BeanClassLoaderAware：回传classLoader给bean对象。

BeanFactoryAware：回传beanFactory给对象。

---

8.1、源码

private void invokeAwareMethods(String beanName, Object bean) {
		if (bean instanceof Aware) {
			if (bean instanceof BeanNameAware) {
				((BeanNameAware) bean).setBeanName(beanName);
			}
			if (bean instanceof BeanClassLoaderAware) {
				ClassLoader bcl = getBeanClassLoader();
				if (bcl != null) {
					((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
				}
			}
			if (bean instanceof BeanFactoryAware) {
				((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
			}
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

---

九、初始化前

初始化前，也是Spring提供的一个扩展点：BeanPostProcessor.postProcessBeforeInitialization()

9.1、使用案例

@Component
public class LjcBeanPostProcessor implements BeanPostProcessor {

 @Override
 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  if ("userService".equals(beanName)) {
   System.out.println("初始化前");
  }

  return bean;
 }
}
1
2
3
4
5
6
7
8
9
10
11
12

利用初始化前，可以对进行了依赖注入的Bean进行处理。

---

9.2、源码

调用地方

Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}
1
2
3
4

在Spring源码中：

1、InitDestroyAnnotationBeanPostProcessor会在初始化前这个步骤中执行@PostConstruct的方法；

2、ApplicationContextAwareProcessor会在初始化前这个步骤中进行其他Aware的回调：

2.1、EnvironmentAware：回传环境变量

2.2、EmbeddedValueResolverAware：回传占位符解析器

2.3、ResourceLoaderAware：回传资源加载器

2.4、ApplicationEventPublisherAware：回传事件发布器

2.5、MessageSourceAware：回传国际化资源

2.6、ApplicationStartupAware：回传应用其他监听对象，可忽略

2.7、ApplicationContextAware：回传Spring容器ApplicationContext
1
2
3
4
5
6
7
8
9
10
11
12
13

---

十、初始化

查看当前Bean对象是否实现了InitializingBean接口，如果实现了就调用其afterPropertiesSet()方法
执行BeanDefinition中指定的初始化方法

invokeInitMethods(beanName, wrappedBean, mbd);
1

---

十一、初始化后

这是Bean创建生命周期中的最后一个步骤，也是Spring提供的一个扩展点：BeanPostProcessor.postProcessAfterInitialization()，比如：

11.1、使用案例

@Component
public class LjcBeanPostProcessor implements BeanPostProcessor {

 @Override
 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  if ("userService".equals(beanName)) {
   System.out.println("初始化后");
  }

  return bean;
 }
}
1
2
3
4
5
6
7
8
9
10
11
12

可以在这个步骤中，对Bean最终进行处理，Spring中的AOP就是基于初始化后实现的，初始化后返回的对象才是最终的Bean对象。

---

11.2、源码

if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}
1
2
3

在初始化之前还会调用InitializingBean#afterPropertiesSet