spring bean 生命周期

bean生命周期前置条件是扫描加载完beanDefinition，在spring 容器刷新的最后倒数第二步（即准备实例化单例bean时）会将非懒加载的单例bean创建好放入单例池中，后续获取直接从单例池中拿。

代码调用流程

一、preInstantiateSingletons 流程

1. FactoryBean 类型bean 判断处理

// 遍历beanNames
for (String beanName : beanNames) {
    // 获取合并后的BeanDefinition
    RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    // 判断bean定义是否不是抽象bean定义 && 是单例bean && 非懒加载
    if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
        // 判断是否是FactoryBean 类型bean
        if (isFactoryBean(beanName)) {
            // 获取FactoryBean对象
            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 {
                    //判断是否是SmartFactoryBean 类型的工厂bean && 是饥饿模式
                    isEagerInit = (factory instanceof SmartFactoryBean &&
                            ((SmartFactoryBean<?>) factory).isEagerInit());
                }
                if (isEagerInit) {
                    // 创建真正的Bean对象(getObject()返回的对象)
                    getBean(beanName);
                }
            }
        }
        else {
            // 创建Bean对象
            getBean(beanName);
        }
    }
}

2. 调用getBean方法

3. 所有非懒加载bean创建完成后，执行SmartInitializingSingleton 接口拓展点方法

所有非懒加载单例bean都创建完成后会会再次遍历beanNames,判断是否实现了SmartInitializingSingleton 接口，如果实现了则调用接口的afterSingletonsInstantiated 方法，执行所有单例bean都创建完成后的拓展点。

// 所有的非懒加载单例Bean都创建完了后
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
    Object singletonInstance = getSingleton(beanName);
    if (singletonInstance instanceof SmartInitializingSingleton) {
        StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
                .tag("beanName", beanName);
        SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                smartSingleton.afterSingletonsInstantiated();
                return null;
            }, getAccessControlContext());
        }
        else {
            //执行所有单例bean都创建完成后的拓展点
            smartSingleton.afterSingletonsInstantiated();
        }
        smartInitialize.end();
    }
}

二、doGetBean 流程

1. 转换别名

name有可能是 &xxx 或者 xxx，如果name是&xxx，那么beanName就是xxx
name有可能传入进来的是别名，那么beanName就是id

String beanName = transformedBeanName(name);

2. 从单例池获取bean

Object sharedInstance = getSingleton(beanName);
// 如果sharedInstance是FactoryBean，那么就调用getObject()返回对象
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);

3. 从父工厂中获取bean，获取到则返回

BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    // Not found -> check parent.
    // &&&&xxx---->&xxx
    String nameToLookup = originalBeanName(name);
    if (parentBeanFactory instanceof AbstractBeanFactory) {
        return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                nameToLookup, requiredType, args, typeCheckOnly);
    }
    else if (args != null) {
        // Delegation to parent with explicit args.
        return (T) parentBeanFactory.getBean(nameToLookup, args);
    }
    else if (requiredType != null) {
        // No args -> delegate to standard getBean method.
        return parentBeanFactory.getBean(nameToLookup, requiredType);
    }
    else {
        return (T) parentBeanFactory.getBean(nameToLookup);
    }
}

4.检查是不是抽象bean definition

checkMergedBeanDefinition(mbd, beanName, args);

5. 创建当前bean所依赖的bean

// Guarantee initialization of beans that the current bean depends on.
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
    // dependsOn表示当前beanName所依赖的，当前Bean创建之前dependsOn所依赖的Bean必须已经创建好了
    for (String dep : dependsOn) {
        // beanName是不是被dep依赖了，如果是则出现了循环依赖
        if (isDependent(beanName, dep)) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
        }
        // dep被beanName依赖了，存入dependentBeanMap中，dep为key，beanName为value
        registerDependentBean(dep, beanName);

        // 创建所依赖的bean
        try {
            getBean(dep);
        }
        catch (NoSuchBeanDefinitionException ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
        }
    }
}

6. 调用createBean 创建bean

不同作用域的bean判断逻辑不同，但最终都是通过调用createBean 完成bean 的创建。

三、createBean 流程

1. 加载beanClass

protected Class<?> resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>... typesToMatch)
        throws CannotLoadBeanClassException {

    try {
        // 如果beanClass被加载了,返回Class
        if (mbd.hasBeanClass()) {
            return mbd.getBeanClass();
        }

        // 如果beanClass没有被加载
        if (System.getSecurityManager() != null) {
            return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>)
                    () -> doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
        }
        else {
            // 加载beanClass
            return doResolveBeanClass(mbd, typesToMatch);
        }
    }
   .......
}

2. 实例化前，调用InstantiationAwareBeanPostProcessor 类型的后置处理器

@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        // Make sure bean class is actually resolved at this point.
        // synthetic表示合成，如果某些Bean式合成的，那么则不会经过BeanPostProcessor的处理
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            Class<?> targetType = determineTargetType(beanName, mbd);
            if (targetType != null) {
                // 调用实例化前后置处理器方法
                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }
        mbd.beforeInstantiationResolved = (bean != null);
    }
    return bean;
}

3. 调用doCreateBean 方法

四、doCreateBean 流程

1. 实例化bean，其中涉及到推断构造方法过程

// 创建Bean实例
instanceWrapper = createBeanInstance(beanName, mbd, args);

2. 后置处理合并后的BeanDefinition，可以再次修改BeanDefinition 的一些属性

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;
    }
}

3. 解决循环依赖添加到三级缓存

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
            isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        if (logger.isTraceEnabled()) {
            logger.trace("Eagerly caching bean '" + beanName +
                    "' to allow for resolving potential circular references");
        }
    // 循环依赖-添加到三级缓存
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

4. 属性填充，依赖注入populateBean

populateBean(beanName, mbd, instanceWrapper);

1. 实例化之后，属性设置之前后置处理

if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
    for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
        if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
            return;
        }
    }
}

2. 原生byType,byName 方式注入

int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
    // MutablePropertyValues是PropertyValues具体的实现类
    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;
}

3. @Autowired/@Resource 依赖注入

for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
    // 这里会调用AutowiredAnnotationBeanPostProcessor的postProcessProperties()方法，会直接给对象中的属性赋值
    // AutowiredAnnotationBeanPostProcessor内部并不会处理pvs，直接返回了
    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;
}

4. 如果beanDefiniton 指定了PropertyValues，则覆盖依赖注入属性

if (pvs != null) {
    applyPropertyValues(beanName, mbd, bw, pvs);
}

5. 初始化 initializeBean

1. Aware 方法调用

	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);
			}
		}
	}

2. 初始化前后置处理器调用

@Override
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;
}

3. 调用初始化方法

1. 调用InitializingBean的afterPropertiesSet() 方法

	((InitializingBean) bean).afterPropertiesSet();

2. 调用用户自定义的初始化方法

if (mbd != null && bean.getClass() != NullBean.class) {
    String initMethodName = mbd.getInitMethodName();
    if (StringUtils.hasLength(initMethodName) &&
            !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
            !mbd.isExternallyManagedInitMethod(initMethodName)) {
        // 用户自定义的初始化方法
        invokeCustomInitMethod(beanName, bean, mbd);
    }
}

6. 注册销毁bean 逻辑

registerDisposableBeanIfNecessary(beanName, bean, mbd);