Spring源码分析（Bean的创建）

Spring源码 之 bean的创建

一、源码分析 - 大体方向

1、finishBeanFactoryInitialization

bean的创建是在refresh 的finishBeanFactoryInitialization 方法进行的

// org.springframework.context.support.AbstractApplicationContext

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // ...

    // Instantiate all remaining (non-lazy-init) singletons.
    beanFactory.preInstantiateSingletons();
}

// org.springframework.beans.factory.support.DefaultListableBeanFactory

/** List of bean definition names, in registration order. */
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

@Override
public void preInstantiateSingletons() throws BeansException {
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    // 循环get所有bean
    for (String beanName : beanNames) {
        // getBean中，如果没有，会创建bean
        getBean(beanName);
        // ...
    }
}

2、getBean –> doGetBean

// org.springframework.beans.factory.support.AbstractBeanFactory

@Override
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

protected <T> T doGetBean(
    String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    throws BeansException {

    String beanName = transformedBeanName(name);
    Object bean;

    // 先根据beanName尝试获取bean
    Object sharedInstance = getSingleton(beanName);

    // 如果已存在，就直接获取bean（getObjectForBeanInstance主要是为了处理FactoryBean）
    if (sharedInstance != null && args == null) {
        // ...
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    // 如果不存在，就创建并返回Bean
    else {
        // ...

        // 先检查parentBeanFactory是否存在指定bean
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // 存在，从parentBeanFactory获取bean....
        }

        try {
            // 获取BeanDefinition
            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // 先获取当前bean依赖的bean
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    // 注册并获取bean
                    registerDependentBean(dep, beanName);
                    try {
                        getBean(dep);
                    } // ...
                }
            }

            // 前面都没获取到，就开始创建bean了........

            // 单例bean
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        return createBean(beanName, mbd, args);
                    } catch (BeansException ex) {
                        destroySingleton(beanName);
                        throw ex;
                    }
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }

            // 多例bean
            else if (mbd.isPrototype()) {
                // It's a prototype -> create a new instance.
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                } finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }

            // 其他scope的bean
            else {
                // 先获取scope
                String scopeName = mbd.getScope();
                Scope scope = this.scopes.get(scopeName);

                try {
                    // 根据scope获取bean
                    // Request、Session 等作用域，都是通过 Attribute 实现类似单例池的作用
                    Object scopedInstance = scope.get(beanName, () -> {
                        beforePrototypeCreation(beanName);
                        try {
                            return createBean(beanName, mbd, args);
                        } finally {
                            afterPrototypeCreation(beanName);
                        }
                    });
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                } catch (IllegalStateException ex) {
                    // ...
                }
            }
        } catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }

    // 检查所需的类型是否与实际bean实例的类型匹配。
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            // 
            T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
            return convertedBean;
        } catch (TypeMismatchException ex) {
            // ...
        }
    }
    return (T) bean;
}

3、小结

先明确 获取bean 和 创建bean 的关系：如果获取不到bean，会创建bean。

getBean方法的主体流程：

1. 获取bean
   • 先获取bean，如果bean不存在，会创建bean。
2. 类型转换
   • 获取到bean之后，判断与requiredType是否一致，如果一致，直接返回；如果不一致，通过 TypeConverter 转换再返回。
3. 返回bean

获取bean的流程：

1. 先通过 getSingleton(beanName) 从缓存中获取bean（缓存指的是Spring的三级缓存，即三个map）
   • 这里获取到了，进行类型转换，然后返回bean
2. 没获取到，再到 parentBeanFactory 看有没有指定bean，如果有，则获取 parentBeanFactory 里的bean
   • 这里获取到了，直接返回bean，不进行类型转换
3. 前面都没获取到，就开始创建bean了（这里简单描述一下，细节在后面展开说明）
   • 单例：通过 getSingleton(beanName, singletonFactory) 方法创建bean
   • 多例：通过 createBean(beanName, mbd, args) 方法创建bean
   • 其他scope：通过 实现 Scope 接口的 get 方法创建bean
4. 创建完各scope的Instance，通过 getObjectForBeanInstance 处理 FactoryBean，返回真正的bean

二、源码分析 - bean的获取

1、getSingleton(beanName)

getSingleton(beanName)根据beanName从缓存中获取bean（缓存指的是Spring的三级缓存，即三个map）

// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

// 一级缓存：存储单例对象，Bean已经实例化，初始化完成，可以直接使用
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 二级缓存：存储早期单例对象，Bean已经实例化，但还没填充属性和初始化
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
// 三级缓存：存储bean工厂对象，用于创建bean实例并放入二级缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

@Override
@Nullable
public Object getSingleton(String beanName) {
    return getSingleton(beanName, true);
}

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 1. 先从一级缓存中获取
    Object singletonObject = this.singletonObjects.get(beanName);
    // 一级缓存中没有 && 正在创建
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            // 2. 从二级缓存中获取
            singletonObject = this.earlySingletonObjects.get(beanName);
            // 二级缓存中也没有 && 是否允许循环依赖（默认为true）
            if (singletonObject == null && allowEarlyReference) {
                // 3. 从三级缓存获取Factory（注意：三级缓存存放的是ObjectFactory，不是bean）
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    // 4. 调用 ObjectFactory 的 getObject 获取bean
                    // 这里其实调用的是匿名内部类的 getEarlyBeanReference() 方法
                    singletonObject = singletonFactory.getObject();
                    // 从三级缓存放入二级缓存
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    // 返回单例bean实例
    return singletonObject;
}

2、getObjectForBeanInstance

doGetBean方法中可以看到，获取不同scope的Instance之后，都会通过getObjectForBeanInstance来获取bean

• getObjectForBeanInstance其实主要就是对FactoryBean做一个处理。

因此在看这个方法之前，先了解一下 FactoryBean

/**
 * 实现FactoryBean后，会生成2个bean对象
 * 1、beanName = factoryBeanImpl   ------  getObject()返回的类 FactoryBeanObject
 * 2、beanName = &factoryBeanImpl  ------  FactoryBean的实现类 FactoryBeanImpl
 */
@Component
public class FactoryBeanImpl implements FactoryBean<FactoryBeanObject> {
    @Override
    public FactoryBeanObject getObject() {
        return new FactoryBeanObject();
    }

    @Override
    public Class<?> getObjectType() {
        return FactoryBeanObject.class;
    }
}

这样再看getObjectForBeanInstance方法就很容易理解了。

// org.springframework.beans.factory.support.AbstractBeanFactory

protected Object getObjectForBeanInstance(
    Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

    // 以&开头的bean
    if (BeanFactoryUtils.isFactoryDereference(name)) {
        if (beanInstance instanceof NullBean) {
            return beanInstance;
        }
        if (!(beanInstance instanceof FactoryBean)) {
            throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
        }
        if (mbd != null) {
            mbd.isFactoryBean = true;
        }
        return beanInstance;
    }
    
    // 不是以&开头的bean，可以是 普通Bean 或 FactoryBean

    // 普通Bean -> 直接返回Bean实例
    if (!(beanInstance instanceof FactoryBean)) {
        return beanInstance;
    }

    // FactoryBean -> 返回getObject方法得到的实例
    Object object = null;
    if (mbd != null) {
        mbd.isFactoryBean = true;
    } else {
        object = getCachedObjectForFactoryBean(beanName);
    }
    if (object == null) {
        // Return bean instance from factory.
        FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
        // Caches object obtained from FactoryBean if it is a singleton.
        if (mbd == null && containsBeanDefinition(beanName)) {
            mbd = getMergedLocalBeanDefinition(beanName);
        }
        boolean synthetic = (mbd != null && mbd.isSynthetic());
        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    }
    return object;
}

三、源码分析 - 不同scope的处理

1、单例bean的处理

// org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean

if (mbd.isSingleton()) {
    // 通过 ObjectFactory的匿名内部类 调用 createBean 创建bean
    sharedInstance = getSingleton(beanName, () -> {
        try {
            return createBean(beanName, mbd, args);
        } catch (BeansException ex) {
            destroySingleton(beanName);
            throw ex;
        }
    });
}

1）getSingleton(beanName,factory)

我们看一下 getSingleton(beanName,factory)方法

// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

/**
 * 这里传入的singletonFactory是ObjectFactory的匿名内部类
 */
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "Bean name must not be null");
    synchronized (this.singletonObjects) {
        // 1. 先从一级缓存中获取
        Object singletonObject = this.singletonObjects.get(beanName);

        // 一级缓存中没有
        if (singletonObject == null) {
            // 准备创建bean

            // 在 singletonsCurrentlyInCreation 集合中添加bean（表示bean正在创建）
            beforeSingletonCreation(beanName);

            // 是否是新创建的bean
            boolean newSingleton = false;

            // 2. 调用 ObjectFactory的匿名内部类 的 getObject方法
            try {
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
            }
            catch (IllegalStateException ex) {...}
            catch (BeanCreationException ex) {...}
            finally {
                // 在 singletonsCurrentlyInCreation 集合中移除bean（bean创建完了）
                afterSingletonCreation(beanName);
            }

            // 3. 是否是新创建的bean
            if (newSingleton) {
                // 是 --> 添加到一级缓存和已注册bean集合，从二级和三级缓存中删除
                addSingleton(beanName, singletonObject);
            }

        }
        return singletonObject;
    }
}

2）addSingleton

// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        // 添加到一级缓存
        this.singletonObjects.put(beanName, singletonObject);
        // 从二级缓存和三级缓存中移除
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        // 添加到已注册的单例集合中
        this.registeredSingletons.add(beanName);
    }
}

2、多例bean的处理

// org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean

else if (mbd.isPrototype()) {
    Object prototypeInstance = null;
    try {
        beforePrototypeCreation(beanName);
        // 直接调用 createBean 创建bean
        prototypeInstance = createBean(beanName, mbd, args);
    } finally {
        afterPrototypeCreation(beanName);
    }
    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}

3、其他bean的处理

// org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean

else {
    String scopeName = mbd.getScope();
    Scope scope = this.scopes.get(scopeName);
    try {
        // Scope接口的get方法，也是通过 ObjectFactory的匿名内部类 调用 createBean 创建bean
        Object scopedInstance = scope.get(beanName, () -> {
            beforePrototypeCreation(beanName);
            try {
                return createBean(beanName, mbd, args);
            }
            finally {
                afterPrototypeCreation(beanName);
            }
        });
        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
    } catch (IllegalStateException ex) {
        // ...
    }
}

这里我们关注一下 RequestScope 和 SessionScope，它们都继承于 AbstractRequestAttributesScope

public abstract class AbstractRequestAttributesScope implements Scope {
    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        // 通过 Attribute 实现类似单例池的作用
        RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
        // 先从 Attribute 中获取指定对象
        Object scopedObject = attributes.getAttribute(name, getScope());
        // Attribute没有，则创建bean，再放入Attribute
        if (scopedObject == null) {
            scopedObject = objectFactory.getObject();
            attributes.setAttribute(name, scopedObject, getScope());
            // ...
        }
        return scopedObject;
    }
}

4、小结

AbstractBeanFactory 中的 doGetBean()方法中，针对不同scope，处理的方式也有所不同

• 单例：通过 getSingleton(beanName,factory)方法创建bean，调用 addSingleton() 放入一级缓存。
  • 其中 getSingleton(beanName,factory)也是通过 createBean() 创建bean
• 多例：直接调用 createBean() 创建bean。
• 其他：扩展 Scope 接口中的 get() 方法，实现创建bean的逻辑（也是通过 createBean() 创建bean）
  • 其中 request 和 session 作用域都是通过 Attribute 实现类似单例池的作用

殊途同归，不同的scope，最后都会调用 createBean(beanName, mbd, args) 方法来创建bean

四、源码分析 - bean的创建

1、createBean

前面我们讲到，不同的scope，最后都会调用 createBean(beanName, mbd, args) 方法来创建bean

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    throws BeanCreationException {

    // clone the bean definition 
    RootBeanDefinition mbdToUse = mbd;
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }

    // Prepare method overrides.
    try {
        mbdToUse.prepareMethodOverrides();
    } catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, 
                                               "Validation of method overrides failed", ex);
    }

    // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
    try { 
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    } catch (Throwable ex) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                                        "BeanPostProcessor before instantiation of bean failed", ex);
    }

    try {
        // 创建bean
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isTraceEnabled()) {
            logger.trace("Finished creating instance of bean '" + beanName + "'");
        }
        return beanInstance;
    } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
        throw ex;
    } catch (Throwable ex) {
        throw new BeanCreationException( mbdToUse.getResourceDescription(), beanName, 
                                        "Unexpected exception during bean creation", ex);
    }
}

2、doCreateBean

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory

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) {
        // 1. 创建Bean实例（推断构造方法/工厂方法创建bean实例）
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }

    // bean的实例（还未填充属性）
    Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }

    // Allow post-processors to modify the merged bean definition.
    // ......

    // 单例 && 允许循环依赖 && 正在创建中
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                      isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        // 2. 将 ObjectFactory的匿名实现类 放入三级缓存
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        // 3. 填充属性
        populateBean(beanName, mbd, instanceWrapper);
        // 4. 初始化bean（这里返回的可能是代理对象）
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    } catch (Throwable ex) {
        // ....
    }

    // 单例 && 允许循环依赖 && 正在创建中
    if (earlySingletonExposure) {
        // 从一级缓存获取bean
        Object earlySingletonReference = getSingleton(beanName, false);
        if (earlySingletonReference != null) {
            if (exposedObject == bean) {
                // exposedObject不是代理对象
                exposedObject = earlySingletonReference;
            }
            // exposedObject是代理对象
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                for (String dependentBean : dependentBeans) {
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                if (!actualDependentBeans.isEmpty()) {
                    // throw new BeanCurrentlyInCreationException 
                }
            }
        }
    }

    // Register bean as disposable.
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    } catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }

    // 返回bean
    return exposedObject;
}

1）createBeanInstance

推断构造方法/工厂方法，构建单例bean的Instance实例，封装到BeanWrapper中返回。

• 进行到这里还未进行属性的填充（也就是还没有进行依赖注入）

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // ...

    Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    if (instanceSupplier != null) {
        return obtainFromSupplier(instanceSupplier, beanName);
    }

    // 调用FactoryMethod创建bean
    if (mbd.getFactoryMethodName() != null) {
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }

    // ...

    if (resolved) {
        if (autowireNecessary) {
            // 使用@Autowire标注的构造方法
            return autowireConstructor(beanName, mbd, null, null);
        } else {
            return instantiateBean(beanName, mbd);
        }
    }

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

2）addSingletonFactory

将 ObjectFactory 放入三级缓存（匿名实现类），用于解决循环依赖。（Bean实例化之后，填充成员属性之前）

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean

// 单例 && 允许循环依赖 && 正在创建中
if (earlySingletonExposure) {
    // 将 ObjectFactory的匿名实现类 放入三级缓存
    addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

// org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        // 一级缓存不存在
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);	// ObjectFactory 放入三级缓存
            this.earlySingletonObjects.remove(beanName);				// 移除二级缓存
            this.registeredSingletons.add(beanName);					// 加入已注册的单例bean
        }
    }
}

【1】getEarlyBeanReference

放入三级缓存的ObjectFactory的匿名实现类的getObject方法，其实就是调用getEarlyBeanReference方法。

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = 
                    (SmartInstantiationAwareBeanPostProcessor) bp;
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}

【2】AbstractAutoProxyCreator

AbstractAutoProxyCreator 实现了SmartInstantiationAwareBeanPostProcessor 接口

• 调用三级缓存中ObjectFactory的getObject方法时，会调用到这个方法。

// org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator

public Object getEarlyBeanReference(Object bean, String beanName) {
    Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
    // 记录已被代理的对象
    this.earlyProxyReferences.put(cacheKey, bean);
    // 返回的是代理对象
    return this.wrapIfNecessary(bean, beanName, cacheKey);
}

3）populateBean

填充bean的成员属性（属性注入）

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean

// Initialize the bean instance.
Object exposedObject = bean;
try {
    // 填充属性
    populateBean(beanName, mbd, instanceWrapper);
    exposedObject = initializeBean(beanName, exposedObject, mbd);
} // ...

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    // ...

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

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

4）initializeBean

初始化bean：这里会调用各接口实现类实现的方法（返回的可能是代理对象）

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean

// Initialize the bean instance.
Object exposedObject = bean;
try {
    populateBean(beanName, mbd, instanceWrapper);
    // 初始化bean（这里返回的可能是代理对象）
    exposedObject = initializeBean(beanName, exposedObject, mbd);
} // ...

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory

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 {
        // 1. 调用 BeanNameAware 实现的 setBeanName 方法
        // 2. 调用 BeanClassLoaderAware 实现的 setBeanClassLoader 方法
        // 3. 调用 BeanFactoryAware 实现的 setBeanFactory 方法
        invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        // 调用 BeanPostProcessor接口实现 的 postProcessBeforeInitialization 方法
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        // 1. 调用 InitializingBean接口实现 的 afterPropertiesSet 方法
        // 2. 调用 自定义的 InitMethod 方法
        invokeInitMethods(beanName, wrappedBean, mbd);
    } catch (Throwable ex) {
        // throw new BeanCreationException
    }

    if (mbd == null || !mbd.isSynthetic()) {
        // 调用 BeanPostProcessor接口实现 的 postProcessAfterInitialization 方法
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

【1】AbstractAutoProxyCreator

AbstractAutoProxyCreator 实现了 BeanPostProcessor 接口，实现了下面两个方法。

public Object postProcessBeforeInitialization(Object bean, String beanName) {
    return bean;
}

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        // 这里获取到的，是代理对象
        Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
        // 代理对象 != 当前对象
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            // 判断是否需要代理，需要，返回代理对象；不需要，返回当前对象
            return this.wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

3、bean的生命周期

1）概述

Bean 在 Spring容器 中从 创建 到 销毁 经历了若干个阶段：

# 实例化

1. Spring对bean进行实例化
		推断构造方法/工厂方法，基于 BeanDefinition 对bean进行实例化，
		实例化的Instance封装在 BeanWrapper 对象中。

# 属性填充

2. Spring将值和依赖的bean填充到bean对应的属性中
		根据 BeanDefinition 获取 PropertyValues，填充属性到 BeanWrapper 中的 Instance。

# 初始化

3. 如果bean实现了 BeanNameAware 接口
		-> Spring会调用 setBeanName(String beanName) 方法

4. 如果bean实现了 BeanClassLoaderAware 接口
		-> Spring会调用 setBeanClassLoader(ClassLoader classLoader) 方法

4. 如果bean实现了 BeanFactoryAware 接口
		-> Spring会调用 setBeanFactory(BeanFactory beanFactory) 方法

5. 如果bean实现了 ApplicationContextAware 接口
		-> Spring会调用 setApplicationContext(ApplicationContext applicationContext) 方法

6. 如果bean实现了 BeanPostProcessor 接口
		-> Spring会调用 postProcessBeforeInitialization(Object bean, String beanName) 方法
	
7. 如果bean实现了 InitializingBean 接口
		-> Spring会调用 afterPropertiesSet() 方法

8. 如果bean定义时声明了初始化方法 initMethod()
		-> Spring会执行 自定义的初始化方法 initMethod()

9. 如果bean实现了 BeanPostProcessor 接口
		-> Spring会调用 postProcessAfterInitialization(Object bean, String beanName) 方法


# 销毁

10. 如果bean实现了DisposableBean接口
		-> Spring会调用 destroy() 方法，进行bean的销毁。
		
11. 如果bean定义时声明了销毁方法 destroyMethod()
		-> Spring会执行 自定义的销毁方法 destroyMethod()

2）案例演示

@Configuration
public class CycleConfig {

    /**
     * 指定 自定义初始化 & 自定义销毁 方法
     */
    @Bean(initMethod = "customInit", destroyMethod = "customDestroy")
    public BeanCycle beanCycle() {
        return new BeanCycle();
    }

}

/**
 * Bean的生命周期
 */
public class BeanLifecycle implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware,
		ApplicationContextAware, BeanPostProcessor, InitializingBean, DisposableBean  {

    public BeanLifecycle() {
        System.out.println("执行 构造方法");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("执行 BeanNameAware 的 setBeanName 方法");
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("执行 BeanClassLoaderAware 的 setBeanClassLoader 方法");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("执行 BeanFactoryAware 的 setBeanFactory 方法");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("执行 ApplicationContextAware 的 setApplicationContext 方法");
    }

    @PostConstruct
    void postConstruct() {
        System.out.println("执行 @PostConstruct 标记的方法");
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // System.out.println("执行 BeanPostProcessor 的 postProcessBeforeInitialization 方法");
        return bean;
    }

    @Override
    public void afterPropertiesSet() {
        System.out.println("执行 InitializingBean 的 afterPropertiesSet 方法");
    }

    public void customInit() {
        System.out.println("执行 自定义的初始化方法 customInit");
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // System.out.println("执行 BeanPostProcessor 的 postProcessAfterInitialization 方法");
        return bean;
    }

    @PreDestroy
    void preDestroy() {
        System.out.println("执行 @PreDestroy 标记的方法");
    }

    @Override
    public void destroy() {
        System.out.println("执行 DisposableBean 的 destroy 方法");
    }

    public void customDestroy() {
        System.out.println("执行 自定义的销毁方法 customDestroy");
    }

}

执行结果

// 启动服务

执行 构造方法
执行 BeanNameAware 的 setBeanName 方法
执行 BeanClassLoaderAware 的 setBeanClassLoader 方法
执行 BeanFactoryAware 的 setBeanFactory 方法
执行 ApplicationContextAware 的 setApplicationContext 方法
执行 @PostConstruct 标记的方法
执行 InitializingBean 的 afterPropertiesSet 方法
执行 自定义的初始化方法 customInit
    
// 关闭服务

执行 @PreDestroy 标记的方法
执行 DisposableBean 的 destroy 方法
执行 自定义的销毁方法 customDestroy

五、小结

0、三级缓存

Spring通过三级缓存解决了单例bean的循环依赖问题。

三级缓存其实就是三个Map（注意：三级缓存的 value 是 ObjectFactory 类型的，即bean工厂）

/** Cache of singleton factories: bean name to ObjectFactory. */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

/** Cache of early singleton objects: bean name to bean instance. */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

缓存字段	级别	描述
singletonFactories	三级缓存	存储ObjectFactory对象，用于创建bean实例并放入二级缓存
earlySingletonObjects	二级缓存	存储早期单例对象，Bean已经实例化，但还没填充属性和初始化
singletonObjects	一级缓存	存储单例对象，Bean已经实例化，初始化完成，可以直接使用

1、只有 A

@Service
public class CircularServiceA {
    private String fieldA = "字段 A";
}

2、A 依赖 B

@Service
public class CircularServiceA {
    @Autowired
    private CircularServiceB circularServiceB;
}

@Service
public class CircularServiceB {

}

3、A 和 B 循环依赖

@Service
public class CircularServiceA {
    @Autowired
    private CircularServiceB circularServiceB;
}

@Service
public class CircularServiceB {
    @Autowired
    private CircularServiceA circularServiceA;
}

4、只有 代理A

@Service
public class CircularServiceA {
    
    private String fieldA = "字段 A";

    public void methodA() {
        System.out.println("方法 A 执行");
    }
}

@Aspect
@Component
public class AspectA {
    @Before("execution(public void com.example.demo.test.CircularServiceA.methodA())")
    public void beforeA() {
        System.out.println("beforeA 执行");
    }
}

5、代理A 和 代理B 循环依赖

@Service
public class CircularServiceA {

    private String fieldA = "字段 A";

    @Autowired
    private CircularServiceB circularServiceB;

    public void methodA() {
        System.out.println("方法 A 执行");
    }
}

@Aspect
@Component
public class AspectA {
    @Before("execution(public void com.example.demo.test.CircularServiceA.methodA())")
    public void beforeA() {
        System.out.println("beforeA 执行");
    }
}

@Service
public class CircularServiceB {

    @Autowired
    private CircularServiceA circularServiceA;

    public void methodB() {}
}

@Aspect
@Component
public class AspectB {
    @Before("execution(public void com.example.demo.test.CircularServiceB.methodB())")
    public void beforeB() {
        System.out.println("beforeB 执行");
    }
}