Spring Bean 的生命周期(创建过程)与Bean的循环依赖

一、spring bean 创建的入口

在ioc初始化的时候会经过这几个方法:
AbstractApplicationContext#refresh() =>
AbstractApplicationContext#finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) =>
DefaultListableBeanFactory#preInstantiateSingletons()

可以看到最终会调用到preInstantiateSingletons 方法

二、实例化预处理

@Override
    public void preInstantiateSingletons() throws BeansException {
        if (logger.isTraceEnabled()) {
            logger.trace("Pre-instantiating singletons in " + this);
        }
        List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
        for (String beanName : beanNames) {
            //初始化RootBeanDefinition,如果有继承关系先初始化父BeanDefinition,然后将子BeanDefinition的内容覆盖父BeanDefinition
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            // 不是抽象不是单例不是懒加载的bean进行初始化
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                //是否工厂类
                if (isFactoryBean(beanName)) {
                
                   //在beanName前面加上一‘&’符号调用。
                    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 {
                            // 如果isEagerInit方法返回true,这个subBean是需要提前初始化
                            isEagerInit = (factory instanceof SmartFactoryBean &&
                                    ((SmartFactoryBean<?>) factory).isEagerInit());
                        }
                        if (isEagerInit) {
                            //如果subBean需要提前初始化,就使用原始的beanName再调用一次getBean
                            getBean(beanName);
                        }
                    }
                }
                else {
                    getBean(beanName);
                }
            }
        }

• 重点方法getMergedLocalBeanDefinition
Bean定义公共的抽象类是AbstractBeanDefinition,普通的Bean在Spring加载Bean定义的时候,实例化出来的是GenericBeanDefinition,而Spring上下文包括实例化所有Bean用的AbstractBeanDefinition是RootBeanDefinition,这时候就使用getMergedLocalBeanDefinition方法做了一次转化,将非RootBeanDefinition转换为RootBeanDefinition以供后续操作。

三、Bean的创建

预处理结束后会进行Bean的创建流程:
AbstractBeanFactory#getBean(String name) ==>
AbstractBeanFactory#doGetBean(String name)

3.1、不同scope的Bean的创建过程

protected <T> T doGetBean(
            String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
            throws BeansException {
        String beanName = transformedBeanName(name);
        Object beanInstance;
        //先从缓存singletonFactories中取是否有对应的单例Bean,每个单例创建好后都会存入singletonFactories中
        //spring的循环依赖就是在这里处理的,后面会进行分析
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            if (logger.isTraceEnabled()) {
                if (isSingletonCurrentlyInCreation(beanName)) {
                    logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                            "' that is not fully initialized yet - a consequence of a circular reference");
                }
                else {
                    logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
            //获取给定Bean的实例对象,主要是完成FactoryBean的相关处理
            //返回对应的实例,有时候存在诸如BeanFactory的情况并不是直接返回实例本身而是返回指定方法返回的实例
            beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }
        else {
            //是原型模式则抛出异常,原型与单例的创建过程不一样
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
            //对IOC容器中是否存在指定名称的BeanDefinition进行检查,首先检查是否能在当前的BeanFactory中获取的所需要的Bean,
            //如果不能则委托当前容器的父级容器去查找,如果还是找不到则沿着容器的继承体系向父级容器查找
            BeanFactory parentBeanFactory = getParentBeanFactory();
            //当前容器的父级容器存在,且当前容器中不存在指定名称的Bean
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                String nameToLookup = originalBeanName(name);
                
                //parentBeanFactory中招对应的bean
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                            nameToLookup, requiredType, args, typeCheckOnly);
                }
                else if (args != null) {
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }
                else if (requiredType != null) {
                    委派父级容器根据指定名称和显式的参数查找
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
                else {
                    //委派父级容器根据指定名称和类型查找
                    return (T) parentBeanFactory.getBean(nameToLookup);
                }
            }
            if (!typeCheckOnly) {
                //向容器标记指定的Bean已经被创建,将beanName放到alreadyCreated缓存中
                markBeanAsCreated(beanName);
            }
            StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
                    .tag("beanName", name);
            try {
                if (requiredType != null) {
                    beanCreation.tag("beanType", requiredType::toString);
                }
                
                //又是getMergedLocalBeanDefinition,根据上文的分时是合并parent bean与当前bean的 definition
                RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                checkMergedBeanDefinition(mbd, beanName, args);
                //从BeanDefinition中获取有依赖Bean的名称(@DependsOn)
                String[] dependsOn = mbd.getDependsOn();
                //如果当前Bean有依赖Bean,则需要先递归实例化依赖的bean
                if (dependsOn != null) {
                    for (String dep : dependsOn) {
                        if (isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
                        registerDependentBean(dep, beanName);
                        try {
                            getBean(dep);
                        }
                        catch (NoSuchBeanDefinitionException ex) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
                        }
                    }
                }
                //正式开始实例化单例模式Bean
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            //创建一个指定Bean实例对象,如果有父级继承,则合并子类和父类的定义
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                            //有异常则从容器单例模式Bean的缓存中清除当前实例
                            destroySingleton(beanName);
                            throw ex;
                        }
                    });
                    beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }
                //IOC容器创建原型模式Bean实例对象
                else if (mbd.isPrototype()) {
                    
                    //原型模式(Prototype)和单例不一样,每次都会创建一个新的对象
                    Object prototypeInstance = null;
                    try {
                        beforePrototypeCreation(beanName);
                        prototypeInstance = createBean(beanName, mbd, args);
                    }
                    finally {
                        afterPrototypeCreation(beanName);
                    }
                    beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }
                //要创建的Bean既不是单例模式,也不是原型模式
                //根据scope去判断:request、session、application等生命周期
                else {
                    String scopeName = mbd.getScope();
                    if (!StringUtils.hasLength(scopeName)) {
                        throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
                    }
                    Scope scope = this.scopes.get(scopeName);
                    if (scope == null) {
                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                    }
                    try {
                        Object scopedInstance = scope.get(beanName, () -> {
                            beforePrototypeCreation(beanName);
                            try {
                                return createBean(beanName, mbd, args);
                            }
                            finally {
                                afterPrototypeCreation(beanName);
                            }
                        });
                        beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    }
                    catch (IllegalStateException ex) {
                        throw new ScopeNotActiveException(beanName, scopeName, ex);
                    }
                }
            }
            catch (BeansException ex) {
                beanCreation.tag("exception", ex.getClass().toString());
                beanCreation.tag("message", String.valueOf(ex.getMessage()));
                cleanupAfterBeanCreationFailure(beanName);
                throw ex;
            }
            finally {
                beanCreation.end();
            }
        }
        return adaptBeanInstance(name, beanInstance, requiredType);
    }

3.2单例模式的实例化过程

可以看到单例模式的创建会调用以下方法:

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

该方法是个空方法,用于子类实现(spring中有很多这样的设计,可以方便后续的扩展)
AbstractAutowireCapableBeanFactory#createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

// bean的生成策略,默认CGLIB
private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();
// 解析策略的方法参数
private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();
// 尝试解析循环引用
private boolean allowCircularReferences = true;
// 在循环引用的情况下,是否需要注入一个原始的bean实例
private boolean allowRawInjectionDespiteWrapping = false;
// 依赖项检查和自动装配时忽略的依赖项类型
private final Set<Class<?>> ignoredDependencyTypes = new HashSet<>();
// 依赖项检查和自动装配时忽略的依赖项接口
private final Set<Class<?>> ignoredDependencyInterfaces = new HashSet<>();
// 当前正在创建的bean
private final NamedThreadLocal<String> currentlyCreatedBean = new NamedThreadLocal<>("Currently created bean");
// beanName和FactoryBean的映射
private final ConcurrentMap<String, BeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<>();
// 类和候选方法映射
private final ConcurrentMap<Class<?>, Method[]> factoryMethodCandidateCache = new ConcurrentHashMap<>();
// 类和PropertyDescriptor的映射
private final ConcurrentMap<Class<?>, PropertyDescriptor[]> filteredPropertyDescriptorsCache = new ConcurrentHashMap<>();
@Override
    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {
        if (logger.isTraceEnabled()) {
            logger.trace("Creating instance of bean '" + beanName + "'");
        }
        RootBeanDefinition mbdToUse = mbd;
        
        //获取RootBeanDefinition中对应的class类,并将已经解析的Class存储在RootBeanDefinition中
        Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }
        
        try {
            // 准备overrides方法,如果有重写方法会修改beanDefination中的MethodOverrides.overrides.overloaded属性为false
            mbdToUse.prepareMethodOverrides();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                    beanName, "Validation of method overrides failed", ex);
        }
        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);
        }
    }
3.2.1、实例化前的操作:InstantiationAwareBeanPostProcessor

首先明确下InstantiationInitialization 的概念:

  • Instantiation :实例化,创建Bean 的过程(比如调用构造函数)

  • Initialization :初始化,对Bean 进行赋值(比如调用setter 方法),配置属性的过程.

很明显 这里是代表着Bean要准备实例化了,如果Bean实现了InstantiationAwareBeanPostProcessor,那么在这个方法也就是实例化前会执行对应的后置处理。

@Nullable
    protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
        Object bean = null;
        if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
            //如果Bean实现了InstantiationAwareBeanPostProcessor
            if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
                Class<?> targetType = determineTargetType(beanName, mbd);
                if (targetType != null) {
                     //执行InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation回调方法  
                    bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    if (bean != null) {
                        //执行InstantiationAwareBeanPostProcessor的postProcessAfterInitialization回调方法
                        bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
                }
            }
            mbd.beforeInstantiationResolved = (bean != null)    ;
        }
        return bean;
    }
    
    @Nullable
    protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
        for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
            Object result = bp.postProcessBeforeInstantiation(beanClass, beanName);
            if (result != null) {
                return result;
            }
        }
        return null;
    }
3.2.2、实例化Bean

AbstractAutowireCapableBeanFactory#doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {
        // 实例化开始
        // BeanWrapper 是对 Bean 的包装,其接口中所定义的功能很简单包括设置获取被包装的对象,获取被包装 bean 的属性描述器
        BeanWrapper instanceWrapper = null;
        // 如果是单例模型,先从factoryBeanInstanceCache缓存中删除要创建的bean
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        // 使用合适的实例化策略来创建新的实例:工厂方法、构造函数自动注入、简单初始
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }
        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    //如果实现MergedBeanDefinitionPostProcessor,则可以使用该后置处理器修改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;
            }
        }
        // 如果允许循环依赖而且当前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");
            }
            // 提前将创建的 bean实例加入到singletonFactories中(循环依赖第一步)
            //getEarlyBeanReference会创建aop代理
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }
    
        Object exposedObject = bean;
        try {
            //对bean进行属性填充
            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);
            }
        }
        
        //  循环依赖处理
        if (earlySingletonExposure) {
            // 获取 earlySingletonReference
            Object earlySingletonReference = getSingleton(beanName, false);
            
            // 只有在存在循环依赖的情况下,earlySingletonReference 才不会为空
            if (earlySingletonReference != null) {
                // 如果 exposedObject 没有在初始化方法中被改变,也就是没有被增强
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                }
                // 处理依赖
                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(beanName,
                                "Bean with name '" + beanName + "' has been injected into other beans [" +
                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                                "] in its raw version as part of a circular reference, but has eventually been " +
                                "wrapped. This means that said other beans do not use the final version of the " +
                                "bean. This is often the result of over-eager type matching - consider using " +
                                "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }
        try {
            // 注册Disposablebean
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }
        return exposedObject;
    }
/**
 * 这个方法很关键啊
*/
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);
                this.earlySingletonObjects.remove(beanName);
                this.registeredSingletons.add(beanName);
            }
        }
    }
3.2.2.1、实例化bean的主要方法createBeanInstance
  • createBeanInstance() 方法中,如果 Supplier 不为空,则调用 obtainFromSupplier() 实例化
    bean
  • 如果 factory 不为空,则调用 #instantiateUsingFactoryMethod() 方法来实例化 Bean
  • 如果都不是,则调用 #instantiateBean() 方法来实例化 Bean
/**
     * Create a new instance for the specified bean, using an appropriate instantiation strategy:
     * factory method, constructor autowiring, or simple instantiation.
     * @param beanName the name of the bean
     * @param mbd the bean definition for the bean
     * @param args explicit arguments to use for constructor or factory method invocation
     * @return a BeanWrapper for the new instance
     * @see #obtainFromSupplier
     * @see #instantiateUsingFactoryMethod
     * @see #autowireConstructor
     * @see #instantiateBean
     */
    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        // Make sure bean class is actually resolved at this point.
        Class<?> beanClass = resolveBeanClass(mbd, beanName);
        if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
        }
        // 如果存在Supplier回调,则使用给定的回调方法初始化策略
        Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
        if (instanceSupplier != null) {
            return obtainFromSupplier(instanceSupplier, beanName);
        }
        // 使用FactoryBean 的factory-method 来创建,支持静态工厂和实例工厂
        if (mbd.getFactoryMethodName() != null) {
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }
        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) {
            synchronized (mbd.constructorArgumentLock) {
                // 如果已缓存的解析的构造函数或者工厂方法不为空,则可以利用构造函数解析
                // 因为需要根据参数确认到底使用哪个构造函数,该过程比较消耗性能,所以采用缓存机制
                if (mbd.resolvedConstructorOrFactoryMethod != null) {
                    resolved = true;
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
        if (resolved) {
            // autowire 自动注入,调用构造函数自动注入
            if (autowireNecessary) {
                return autowireConstructor(beanName, mbd, null, null);
            }
            else {
                // 使用默认构造函数构造
                return instantiateBean(beanName, mbd);
            }
        }
        // 确定解析的构造函数
        // 主要是检查已经注册的 SmartInstantiationAwareBeanPostProcessor
        Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
            return autowireConstructor(beanName, mbd, ctors, args);
        }
        
        // 默认构造的首选构造函数
        ctors = mbd.getPreferredConstructors();
        if (ctors != null) {
            return autowireConstructor(beanName, mbd, ctors, null);
        }
        // 啥都没有就只能调用无参构造方法来创建实例
        return instantiateBean(beanName, mbd);
    }

根据代码可以看出实例化bean的主要用来了以下几个方法

  • obtainFromSupplier(instanceSupplier, beanName):使用给定的回调方法初始化策略

  • instantiateUsingFactoryMethod(beanName, mbd, args):使用 FactoryBean 的
    factory-method 来创建

  • autowireConstructor(beanName, mbd, null, null):autowire
    自动注入,调用构造函数自动注入

  • instantiateBean(beanName, mbd) :使用默认构造函数构造

3.2.2.2、obtainFromSupplier
protected BeanWrapper obtainFromSupplier(Supplier<?> instanceSupplier, String beanName) {
        Object instance;
        // 获得bean的实例对象
        String outerBean = this.currentlyCreatedBean.get();
        // 设置新的 Bean 的对象名,到currentlyCreatedBean 中
        this.currentlyCreatedBean.set(beanName);
        try {
            // 调用 Supplier 的 get(),返回一个 Bean 对象
            instance = instanceSupplier.get();
        }
        finally {
            // 创建bean的名字到currentlyCreatedBean中
            if (outerBean != null) {
                this.currentlyCreatedBean.set(outerBean);
            }
            else {
                this.currentlyCreatedBean.remove();
            }
        }
        // 未创建 Bean 对象,则创建 NullBean 对象
        if (instance == null) {
            instance = new NullBean();
        }
        // 创建bean的包装类
        BeanWrapper bw = new BeanWrapperImpl(instance);
        // 初始化bean的包装
        initBeanWrapper(bw);
        return bw;
    }
3.2.2.3、instantiateUsingFactoryMethod
protected BeanWrapper instantiateUsingFactoryMethod(
            String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
 
        return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
    }
    public BeanWrapper instantiateUsingFactoryMethod(
            String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
 
        //构造bean的包装类
        BeanWrapperImpl bw = new BeanWrapperImpl();
        //初始化包装类
        this.beanFactory.initBeanWrapper(bw);
 
        Object factoryBean;
        Class<?> factoryClass;
        boolean isStatic;
 
        //获得bean的工厂名字
        String factoryBeanName = mbd.getFactoryBeanName();
        if (factoryBeanName != null) {
            //如果bean的工厂名和bean名字相同
            if (factoryBeanName.equals(beanName)) {
                throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
                        "factory-bean reference points back to the same bean definition");
            }
            factoryBean = this.beanFactory.getBean(factoryBeanName);
            
            //如果是单例bean且缓存中存在
            if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
                throw new ImplicitlyAppearedSingletonException();
            }
            // 获得工厂字节码
            factoryClass = factoryBean.getClass();
            isStatic = false;
        }
        else {
            if (!mbd.hasBeanClass()) {
                throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
                        "bean definition declares neither a bean class nor a factory-bean reference");
            }
            factoryBean = null;
            factoryClass = mbd.getBeanClass();
            isStatic = true;
        }
        Method factoryMethodToUse = null;
        ArgumentsHolder argsHolderToUse = null;
        Object[] argsToUse = null;
 
        // 如果指定了构造方法的参数,则构造bean 的时候使用此构造方法
        if (explicitArgs != null) {
            argsToUse = explicitArgs;
        }
        else { 
            // 没有指定,则从配置文件中解析
            Object[] argsToResolve = null;
            synchronized (mbd.constructorArgumentLock) {
                // 用构造工厂中获取
                factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
                if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
                    
                    // 查询缓存
                    argsToUse = mbd.resolvedConstructorArguments;
                    if (argsToUse == null) {
                        // 获取缓存中的构造函数参数的包可见字段
                        argsToResolve = mbd.preparedConstructorArguments;
                    }
                }
            }
            // 缓存中存在,则解析存储在 BeanDefinition 中的参数
            if (argsToResolve != null) {
                argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);
            }
        }
 
        if (factoryMethodToUse == null || argsToUse == null) {
            // 获取工厂方法的全名称
            factoryClass = ClassUtils.getUserClass(factoryClass);
            // 获取所有的候选方法
            Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
            List<Method> candidateList = new ArrayList<>();
            // 检索所有方法,这里是对方法进行过滤
            for (Method candidate : rawCandidates) {
                // 如果有方法为静态方法,且为工厂方法则添加到candidateList中
                if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
                    candidateList.add(candidate);
                }
            }
            // 如果静态的工厂存在
            if (candidateList.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
                Method uniqueCandidate = candidateList.get(0);
                // 使用静态的工厂方法创建bean
                if (uniqueCandidate.getParameterCount() == 0) {
                    mbd.factoryMethodToIntrospect = uniqueCandidate;
                    synchronized (mbd.constructorArgumentLock) {
                        mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
                        mbd.constructorArgumentsResolved = true;
                        mbd.resolvedConstructorArguments = EMPTY_ARGS;
                    }
                    bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
                    return bw;
                }
            }
            // 排序
            Method[] candidates = candidateList.toArray(new Method[0]);
            AutowireUtils.sortFactoryMethods(candidates);
            ConstructorArgumentValues resolvedValues = null;
            boolean autowiring = (mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
            int minTypeDiffWeight = Integer.MAX_VALUE;
            Set<Method> ambiguousFactoryMethods = null;
 
            int minNrOfArgs;
            if (explicitArgs != null) {
                minNrOfArgs = explicitArgs.length;
            }
            else {
                if (mbd.hasConstructorArgumentValues()) {
                    // 构造函数的参数
                    ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
                    resolvedValues = new ConstructorArgumentValues();
                    // 将构造函数的参数解析进resolvedValues中
                    minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
                }
                else {
                    minNrOfArgs = 0;
                }
            }
 
            LinkedList<UnsatisfiedDependencyException> causes = null;
            // 遍历 candidates 数组
            for (Method candidate : candidates) {
                // 方法体的参数
                Class<?>[] paramTypes = candidate.getParameterTypes();
 
                if (paramTypes.length >= minNrOfArgs) {
                    // 保存参数的对象
                    ArgumentsHolder argsHolder;
 
                    if (explicitArgs != null) {
                        // 显示给定参数,参数长度必须完全匹配
                        if (paramTypes.length != explicitArgs.length) {
                            continue;
                        }
                        // 根据参数创建参数持有者 ArgumentsHolder 对象
                        argsHolder = new ArgumentsHolder(explicitArgs);
                    }
                    else {
                        try {
                            String[] paramNames = null;
                            
                            // ParameterNameDiscoverer 是用于解析方法和构造函数的参数名称的接口,为参数名称探测器
                            ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                            // 获取指定构造函数的参数名称
                            if (pnd != null) {
                                paramNames = pnd.getParameterNames(candidate);
                            }
                            // 在已经解析的构造函数参数值的情况下,创建一个参数持有者 ArgumentsHolder 对象
                            argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw,
                                    paramTypes, paramNames, candidate, autowiring, candidates.length == 1);
                        }
                        catch (UnsatisfiedDependencyException ex) {
                            if (logger.isTraceEnabled()) {
                                logger.trace("Ignoring factory method [" + candidate + "] of bean '" + beanName + "': " + ex);
                            }
                            if (causes == null) {
                                causes = new LinkedList<>();
                            }
                            causes.add(ex);
                            continue;
                        }
                    }
 
                    // isLenientConstructorResolution 判断解析构造函数的时候是否以宽松模式还是严格模式
                    // 严格模式:解析构造函数时,必须所有的都需要匹配,否则抛出异常
                    // 宽松模式:使用具有"最接近的模式"进行匹配
                    // typeDiffWeight:类型差异权重
                    int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                            argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
                    // 代表最接近的类型匹配,则选择作为构造函数
                    if (typeDiffWeight < minTypeDiffWeight) {
                        factoryMethodToUse = candidate;
                        argsHolderToUse = argsHolder;
                        argsToUse = argsHolder.arguments;
                        minTypeDiffWeight = typeDiffWeight;
                        ambiguousFactoryMethods = null;
                    }
                    // 如果具有相同参数数量的方法具有相同的类型差异权重,则收集此类型选项
                    // 但是,仅在非宽松构造函数解析模式下执行该检查,并显式忽略重写方法(具有相同的参数签名)
                    else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
                            !mbd.isLenientConstructorResolution() &&
                            paramTypes.length == factoryMethodToUse.getParameterCount() &&
                            !Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
                        if (ambiguousFactoryMethods == null) {
                            ambiguousFactoryMethods = new LinkedHashSet<>();
                            // 存在多个可选方法
                            ambiguousFactoryMethods.add(factoryMethodToUse);
                        }
                        ambiguousFactoryMethods.add(candidate);
                    }
                }
            }
            if (factoryMethodToUse == null) {
                if (causes != null) {
                    UnsatisfiedDependencyException ex = causes.removeLast();
                    for (Exception cause : causes) {
                        this.beanFactory.onSuppressedException(cause);
                    }
                    throw ex;
                }
                List<String> argTypes = new ArrayList<>(minNrOfArgs);
                if (explicitArgs != null) {
                    for (Object arg : explicitArgs) {
                        argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null");
                    }
                }
                else if (resolvedValues != null) {
                    Set<ValueHolder> valueHolders = new LinkedHashSet<>(resolvedValues.getArgumentCount());
                    valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values());
                    valueHolders.addAll(resolvedValues.getGenericArgumentValues());
                    for (ValueHolder value : valueHolders) {
                        String argType = (value.getType() != null ? ClassUtils.getShortName(value.getType()) :
                                (value.getValue() != null ? value.getValue().getClass().getSimpleName() : "null"));
                        argTypes.add(argType);
                    }
                }
                String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "No matching factory method found: " +
                        (mbd.getFactoryBeanName() != null ?
                            "factory bean '" + mbd.getFactoryBeanName() + "'; " : "") +
                        "factory method '" + mbd.getFactoryMethodName() + "(" + argDesc + ")'. " +
                        "Check that a method with the specified name " +
                        (minNrOfArgs > 0 ? "and arguments " : "") +
                        "exists and that it is " +
                        (isStatic ? "static" : "non-static") + ".");
            }
            else if (void.class == factoryMethodToUse.getReturnType()) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Invalid factory method '" + mbd.getFactoryMethodName() +
                        "': needs to have a non-void return type!");
            }
            else if (ambiguousFactoryMethods != null) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Ambiguous factory method matches found in bean '" + beanName + "' " +
                        "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
                        ambiguousFactoryMethods);
            }
 
            if (explicitArgs == null && argsHolderToUse != null) {
                mbd.factoryMethodToIntrospect = factoryMethodToUse;
                argsHolderToUse.storeCache(mbd, factoryMethodToUse);
            }
        }
        // 验证
        Assert.state(argsToUse != null, "Unresolved factory method arguments");
        // 创建 Bean 对象,并设置到 bw 中
        bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));
        return bw;
    }

后面两个不分析了,比较常规的实例化操作。

3.2.3、属性填充bean
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        if (bw == null) {
            if (mbd.hasPropertyValues()) {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            }
            else {
                // Skip property population phase for null instance.
                return;
            }
        }
            // 实现了InstantiationAwareBeanPostProcessor,上面3.2.1有过分析
            if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
                    // 返回值为是否继续填充 bean
                    // postProcessAfterInstantiation:如果应该在 bean上面设置属性则返回 true,否则返回 false
                    // 返回 false 的话,将会阻止在此 Bean 实例上调用任何后续的 InstantiationAwareBeanPostProcessor 实例。
                if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                    return;
                }
            }
        }
        PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
        int resolvedAutowireMode = mbd.getResolvedAutowireMode();
        // 自动注入 
        if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
            // 将 PropertyValues封装成 MutablePropertyValues对象
            // 注意:MutablePropertyValues允许对属性进行简单的操作,并提供构造函数以支持Map的深度复制和构造。
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
            // 根据名称自动注入
            if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
            }
            // 根据类型自动注入
            if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
            }
            pvs = newPvs;
        }
        // 是否已经注册了 InstantiationAwareBeanPostProcessors
        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
        // 是否进行依赖检查
        boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
        PropertyDescriptor[] filteredPds = null;
        if (hasInstAwareBpps) {
            if (pvs == null) {
                pvs = mbd.getPropertyValues();
            }
            for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
                // 对所有需要依赖检查的属性进行后处理
                PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
                if (pvsToUse == null) {
                    // 从 bw对象中提取 PropertyDescriptor 结果集
                    // PropertyDescriptor:可以通过一对存取方法提取一个属性
                    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) {
            applyPropertyValues(beanName, mbd, bw, pvs);
        }
    }
3.2.3.1、属性填充的核心方法
  • getResolvedAutowireMode 检测自动注入
  • autowireByName 根据名称注入
  • autowireByType 根据类型注入
  • applyPropertyValues 赋值属性的操作
3.2.4、初始化bean
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 {
            // Aware接口处理
            // 比如实现了BeanNameAware接口,那么对其bean的属性beanName上set上对应的beanName。
            // 如果实现了BeanFactoryAware接口,那么对其beanFactory属性设置上创建该bean使用的bean工厂
            invokeAwareMethods(beanName, bean);
        }
        Object wrappedBean = bean;
        // 如果这个bd不是属于内部类的bd,就调用后置处理器的postProcessBeforeInitialization对bean进行操作。
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }
        try {
            //如果bean实现了InitializingBean或者用户自定义的init方法方法,那么调用这些初始化方法对bean的属性进行一些个性化设置。
            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()) {
            // 执行后置处理器的postProcessAfterInitialization方法。apo的代理也会在这里处理。
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }
        return wrappedBean;
    }

初始化步骤大体上可以分为四步:

  1. 对实现Aware接口对bean的设置。
  2. 依次回调bean后置处理器的postProcessBeforeInitialization方法。
  3. 执行实现了InitializingBean或者用户自定义的init方法方法。
  4. 依次回调bean后置处理器的postProcessAfterInitialization方法
3.2.4.1. invokeAwareMethods - 激活 Aware 方法

这个方法很简单,完成了 Aware 接口的激活功能。spring中常见的Aware:

  • BeanFactoryAware 获取IoC 容器-BeanFactory
  • ApplicationContextAware 获取Spring 应用上下文-ApplicationContext 对象
  • EnvironmentAware 获取Environment 对象
  • ResourceLoaderAware 获取资源加载器对象-ResourceLoader
  • BeanClassLoaderAware 获取加载当前Bean Class 的ClassLoader
  • BeanNameAware 获取当前Bean 的名称
  • MessageSourceAware 获取MessageSource 对象,用于Spring 国际化
  • ApplicationEventPublisherAware 获取ApplicationEventPublishAware 对象,用于Spring 事件
  • EmbeddedValueResolverAware 获取StringValueResolver 对象,用于占位符处理
    在初始化过程中,我们只关注BeanNameAware,BeanClassLoaderAware和BeanFactoryAware:
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);
            }
        }
    }
3.2.4.2. invokeInitMethods - 激活自定义的init方法

spring为bean提供了两种初始化bean的方式,Bean 的初始化方法除了可以使用 init-method 属性(或者 @Bean(initMethod=’’”)),还可以通过实现InitializingBean接口,并且在afterPropertiesSet 方法中实现自己初始化的业务逻辑,两种方式可以同时使用,但是如果调用afterPropertiesSet方法时出错,则不会再继续调用init-method指定的方法。
InitializingBean 在bean初始化过程中会:

  1. 判断当前 bean 是否实现了 InitializingBean,实现了则调用afterPropertiesSet() 方法,进行初始化工作。
  2. 检查Bean是否也指定了 init-method ,如果指定了则通过反射机制调用指定的 init-method 方法。

实现InitializingBean接口是直接调用afterPropertiesSet方法,比通过反射调用init-method指定的方法效率相对来说要高点。但是init-method方式消除了对spring的依赖。

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
            throws Throwable {
        // 首先检查是否是InitializingBean,如果是的话则需要调用 afterPropertiesSet 方法。
        boolean isInitializingBean = (bean instanceof InitializingBean);
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            if (logger.isTraceEnabled()) {
                logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
            }
            // 调用 afterPropertiesSet  方法
            if (System.getSecurityManager() != null) {
                try {
                    AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                        ((InitializingBean) bean).afterPropertiesSet();
                        return null;
                    }, getAccessControlContext());
                }
                catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            }
            else {
                ((InitializingBean) bean).afterPropertiesSet();
            }
        }
        
        if (mbd != null && bean.getClass() != NullBean.class) {
            // 从RootBeanDefinition 中获取initMethod 方法名称
            String initMethodName = mbd.getInitMethodName();
            // 调用initMethod 方法。
            if (StringUtils.hasLength(initMethodName) &&
                    !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                    !mbd.isExternallyManagedInitMethod(initMethodName)) {
                invokeCustomInitMethod(beanName, bean, mbd);
            }
        }
    }
3.2.5.3、 常用初始化方法的执行顺序

Bean在实例化的过程中:
@PostConstruct > InitializingBean > init-method

1、 @PostConstruct

PostConstruct注解的方法主要是在CommonAnnotationBeanPostProcessor中执行的。

public CommonAnnotationBeanPostProcessor() {
        setOrder(Ordered.LOWEST_PRECEDENCE - 3);
        setInitAnnotationType(PostConstruct.class);
        setDestroyAnnotationType(PreDestroy.class);
        ignoreResourceType("javax.xml.ws.WebServiceContext");
    }

在CommonAnnotationBeanPostProcessor类加载的时候就会执行上面的静态代码块,我们看静态代码块中的逻辑,可以看出就是向resourceAnnotationTypes中添加了三个注解,就是这个类要解析的注解所代表的接口。

CommonAnnoatationBeanPostProcessor的父类是InitDestoryAnnoatationBeanPostProcessor,在InitDestoryAnnoatationBeanPostProcessor类中postProcessMergedBeanDefinition方法主要完成的解析和初始化(@PostConstruct)和销毁(@PreDestory)相关的注解并缓存到lifecycleMetadataCache中。

CommonAnnoatationBeanPostProcessor的findResourceMetadata方法主要完成的是解析@Resource、@WebServiceRef、@EJB三个注解并缓存到injectionMetadataCache中。

后面就是对PostConstruct的方法的执行
InitDestroyAnnotationBeanPostProcessor#postProcessBeforeInitialization

@Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
        try {
            metadata.invokeInitMethods(bean, beanName);
        }
        catch (InvocationTargetException ex) {
            throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
        }
        catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
        }
        return bean;
    }

2、InitializingBean 和init-method查看 3.2.4.2

四、循环依赖

4.1、getBean

先来看下几个概念:

/** 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 ConcurrentHashMap<>(16);

 /** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
  • singletonObjects:第一级缓存,里面存放的都是创建好的成品Bean。
  • earlySingletonObjects : 第二级缓存,里面存放的都是半成品的Bean。
  • singletonFactories :第三级缓存, 不同于前两个存的是 Bean对象引用,此缓存存的bean 工厂对象,也就存的是 专门创建Bean的一个工厂对象。此缓存用于解决循环依赖
    下面是getSingleton的代码:
@Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        // 在一级缓存中获取bean
        Object singletonObject = this.singletonObjects.get(beanName);
        //只有正在创建中的bean会进入
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                synchronized (this.singletonObjects) {
                    // Consistent creation of early reference within full singleton lock
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        //从二级缓存中寻找
                        singletonObject = this.earlySingletonObjects.get(beanName);
                        if (singletonObject == null) {
                            //从三级缓存中寻找
                            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                            if (singletonFactory != null) {
                                singletonObject = singletonFactory.getObject();
                                this.earlySingletonObjects.put(beanName, singletonObject);
                                this.singletonFactories.remove(beanName);
                            }
                        }
                    }
                }
            }
        }
        return singletonObject;
    }

可以看到如果在创建bean 的过程中出现了循环依赖了,spring是这样处理的:

  1. 单例bean必须是正在创建中的。
  2. 一级二级缓存中如果没有找到springbean的缓存(因为正在创建中),则会通过三级缓存去创建,三级缓存是存在singletonFactories中的,是一个ObjectFactory。在3.2.2章节中有分析,通过AbstractAutowireCapableBeanFactory#doCreateBean()实例化bean的时候会将当前正在创建的bean的放入三级缓存。
  3. 从三级缓存ObjetFactory中获取到bean后会将其放入二级缓存earlySingletonObjects中。

4.2、为什么要用三级缓存

先说结论:因为spring会有aop代理的存在。
假设目前有A和B两个bean,A依赖B,B依赖A那么他们的创建过程是(主要看3.2的操作过程):

  1. A进行实例化doCreateBean操作,将A存入三级缓存中;
  2. A进行populateBean填充属性操作;
  3. A在进行填充属性的时候发现依赖B。于是开始B的初始化操作;
  4. B进行实例化doCreateBean操作,将B存入三级缓存中;
  5. B进行populateBean填充属性操作;
  6. B在进行填充属性的时候发现依赖A。然后就去getBean(“A”),去缓存中招一直找到三级缓存,获取A的ObjectFactory,然后调用ObjectFactory。
    如果A需要通过Aop代理,则会用AOP的后置处理器类:getEarlyBeanReference,拿到代理后的A bean,最后填充到B的属性中。
  7. 完成B的创建,并填充到A中。最后完成A的初始化。
  8. 3.2.2中有个比较重要的代码:
if (earlySingletonExposure) {
            // 获取 earlySingletonReference
            Object earlySingletonReference = getSingleton(beanName, false);
            
            // 只有在存在循环依赖的情况下,earlySingletonReference 才不会为空
            if (earlySingletonReference != null) {
                // 如果 exposedObject 没有在初始化方法中被改变,也就是没有被增强
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                }
                ……
             }
}

这里就是在A初始化完成后,直接返回A的代理对象。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值