简单说说 Bean的生命周期源码

在spring中核心进行bean的初始化的方法是AbstractAutowireCapableBeanFactory 类的 doCreateBean 方法，生命周期的全部大致流程都在这里进行了描述

分别是：1 创建实例 ；2 填充属性 3 初始化

//AbstractAutowireCapableBeanFactory 类
//创建bean的过程
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);
    }
    //如果缓存中没有，则创建bean实例
    if (instanceWrapper == null) {
        //【核心】创建实例
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    //获取bean实例
    Object bean = instanceWrapper.getWrappedInstance();
    //获取bean的类型
    Class<?> beanType = instanceWrapper.getWrappedClass();
    //设置一下BeanDefinition中bean最终的目标类型
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }

    // Allow post-processors to modify the merged bean definition.
    //允许后置处理器修改合并后的bean定义
    //在spring中的bean定义可以通过多种方法，比如说xml、注解，java配置
    //这些配置最终需要进行合并，通过MergedBeanDefinitionPostProcessor对这些合并后的bean进行一步修改增强
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                //执行后置处理器
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Post-processing of merged bean definition failed", ex);
            }
            //标记为后置处理已完成
            mbd.postProcessed = true;
        }
    }

    // Eagerly cache singletons to be able to resolve circular references
    // even when triggered by lifecycle interfaces like BeanFactoryAware.
    //判断是否支持循环依赖（是单例 && 允许循环引用 && 当前bean正在创建中）
    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");
        }
        //这个方法会将当前的实例化完成，初始化未完的对象，存储到 singletonFactories 缓存中去
        //之所以存到的是三级缓存，是因为对象可能是经过aop的，在singletonFactories中存储的是ObjectFactory
        // ObjectFactory是一个函数式接口，如果对象有经过aop会返回aop对象，否则返回原对象
        //singletonFactories 就是我们所说的三级缓存
        //同时，会将beanName 存入 registeredSingletons 列表中，作用是提前曝光，是解决循环袭来的关键
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        //【核心】填充bean的属性
        //1 完成属性的注入，根据bean定义的时候，设置的属性值。
        //2 解析依赖 如果bean依赖其他的bean，则其会递归的去创建其他的bean
        //3 调用BeanPostProcessor，这里主要是执行 InstantiationAwareBeanPostProcessor
        populateBean(beanName, mbd, instanceWrapper);
        //【核心】初始化bean
        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);
        }
    }
    //如果提前暴露了单例bean，进行最终处理
    if (earlySingletonExposure) {
        ...
    }

    // Register bean as disposable.
    //注册bean为可销毁的
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }

    return exposedObject;
}

initializeBean 是spring中，对bean进行初始化的核心方法，在该方法中，主要完成的是

1 调用aware接口提供的方法

2 调用BeanPostProcessor的前置方法（比如ApplicationContextAwareProcessor，将ApplicationContext赋值给bean）

3 初始化，执行顺序为，如果继承了InitializingBean，则会去执行afterPropertiesSet方法，然后如果配置了init-method，则会去执行。

4 调用BeanPostProcessor的后置方法（一般aop的增强在这里进行，可以确保bean已经完成初始化）

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            //调用aware接口的方法，这里调用了三个aware 
            // BeanNameAware、BeanClassLoaderAware和 BeanFactoryAware
            invokeAwareMethods(beanName, bean);
            return null;
        }, getAccessControlContext());
    }
    else {
        //调用aware接口的方法，这里调用了三个aware 
        // BeanNameAware、BeanClassLoaderAware和 BeanFactoryAware
        invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        //调用BeanPosterProcessor的前置方法
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        //调用初始化方法
        //1 init-method 属性指定的方法
        //2 实现了InitializingBean接口的 afterPropertiesSet方法
        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()) {
        调用BeanPosterProcessor的后置方法
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

传送阵

简单谈谈Spring 中Aware是什么-CSDN博客

简单说说 Spring 中BeanPostProcessor是什么-CSDN博客

简单说说 spring 是如何处理循环依赖问题的（源码解析）-CSDN博客

简单说说 spring构造器循环依赖 为什么无法解决（源码解析）-CSDN博客

简单说说 spring是如何实现AOP的（源码分析）-CSDN博客