spring中bean的生命周期分为四各阶段:实例化、属性赋值(注入)、初始化、销毁。前三个阶段的核心方法位于AbstractAutowireCapableBeanFactory#doCreateBean
方法中:
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//createBeanInstance方法对应实例化阶段
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
//...
// Initialize the bean instance.
Object exposedObject = bean;
try {
//populateBean方法对应属性赋值阶段
populateBean(beanName, mbd, instanceWrapper);
//initializeBean方法对应初始化阶段
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
//...
return exposedObject;
}
这个方法中的createBeanInstance()
、populateBean()
、initializeBean()
分别对应实例化、属性赋值、初始化三个阶段
createBeanInstance()
这个方法中,spring容器会根据工厂方法、依据构造方法装配(构造注入)、简单实例化(无参构造) 三种方式中的一种实例化对象
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
//...
//根据自定义的instanceSupplier实例化对象
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
//根据工厂方法实例化对象
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
//...
//选择构造注入的构造方法并实例化对象
// Candidate constructors for autowiring?
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction?
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
//简单实例化(调用无参构造方法)
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);
}
populateBean()
在属性赋值的过程中,会根据xml中property标签配置的内容进行赋值,如果xml注入bean时配置了autowire属性,也会根据配置的注入模式(名称、类型)进行依赖注入,此外,过程中也会根据@AutoWired和@Value注解对对应属性进行赋值
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
//获取xml中property标签中配置的属性
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
//获取xml中配置的autowire信息,根据名称或类型为当前实例化的bean注入其依赖的bean
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;
}
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
//根据bean的postProcessor对属性进行处理,包括根据@AutoWired和@Value注解进行注入、赋值
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
checkDependencies(beanName, mbd, filteredPds, pvs);
}
if (pvs != null) {
//将xml中配置的property标签中的值赋值给对应属性
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
initializeBean()
在初始化的过程中,依次调用了当前bean实现的Aware接口下的方法、在初始化前执行的postProcessor、自定义的init-method方法、在初始化后执行的postProcessor
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
//调用当前bean实现的Aware接口下的方法
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
//调用初始化前执行的postProcessor
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//调用设置的init-method方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
//调用初始化后执行的postProcessor
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
最后一个销毁阶段对于单例的bean来说,在spring容器关闭时由容器销毁;对于多例的bean来说,spring容器关闭时容器不会自动销毁,由java的GC机制回收。可以通过实现DisposableBean
接口、定义destroy-method方法、使用@PreDestroy注解等方式来干预bean的销毁
以上是对bean生命周期的四个阶段的简单介绍,每个阶段还有很多细节的处理。此外,spring还提供了很多扩展点,允许开发人员干预bean的生命周期的不同阶段。