Spring5源码 - 从缓存中获取Bean

你的名字 2022-09-08 10:30 166阅读 0赞

先看一张笔者整理的一张学习路线，大概扫一眼即可。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBATXJESnVu_size_61_color_FFFFFF_t_70_g_se_x_16]  
获取Bean的方法在 AbstractBeanFactory 中的 doGetBean方法中，按照Spring的方法命名规则，以do开头的方法才是真正做事情的方法。

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
                              @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { 
        // 通过第三种形式获取 beanName，一个是原始的 beanName，一个是加了&的，一个是别名
        final String beanName = transformedBeanName(name);
        Object bean;
    
        // Eagerly check singleton cache for manually registered singletons.
        // 尝试从到单例缓存集合中获取bean实例（文章下面详细讲这个方法）
        Object sharedInstance = getSingleton(beanName);
        /* 如果先前已经创建过单例Bean的实例，并且调用的getBean方法传入的参数为空， 则执行if里面的逻辑，args之所以要求为空是因为如果有args就需要做进一步 赋值，因此无法直接返回。 */
        if (sharedInstance != null && args == null) { 
            if (logger.isTraceEnabled()) { 
                /* 如果Bean还在创建中，说明是循环引用。 singletonsCurrentlyInCreation 中存放的是正在创建Bean的名称集合。 */
                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，则返回getObject
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }
    	// 如果scope是prototype或者单例模式，但是缓存中还不存在Bean
        else { 
            // Fail if we're already creating this bean instance:
            // We're assumably within a circular reference.
            /* 如果scope为prototype并且显示还在创建中，则基本是循环依赖的情况， 针对prototype的循环依赖，spring无解，直接抛出异常。 为什么这里会产生循环依赖？A和B是两个Bean，A中注入B，B中注入了A， A会去调用getBean方法创建出B，创建B的过程中发现又有A的属性，又会调用 A的getBean方法，A等B创建出来，B又等A创建出来，如此下去产生循环依赖。 */
            if (isPrototypeCurrentlyInCreation(beanName)) { 
                throw new BeanCurrentlyInCreationException(beanName);
            }
    
            // Check if bean definition exists in this factory.
            // 从当前容器中找不到指定名称的Bean，此时递归去parentFactory中查找。
            BeanFactory parentBeanFactory = getParentBeanFactory();
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { 
                // Not found -> check parent.
                // 主要针对 FactoryBean，将Bean的&重新加上
                String nameToLookup = originalBeanName(name);
                /* 如果parent容器依旧是AbstractBeanFactory的实例instanceOf，通过 返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例 */
                if (parentBeanFactory instanceof AbstractBeanFactory) { 
                    // 直接递归调用方法来查找
                    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                        nameToLookup, requiredType, args, typeCheckOnly);
                }
                else if (args != null) { 
                    // Delegation to parent with explicit args.
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }
                else if (requiredType != null) { 
                    // No args -> delegate to standard getBean method.
                    // 如果有参数，则委派父级容器根据指定名称和显式的参数查找
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
                else { 
                    return (T) parentBeanFactory.getBean(nameToLookup);
                }
            }
    
            if (!typeCheckOnly) { 
                markBeanAsCreated(beanName);
            }
    
            try { 
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                checkMergedBeanDefinition(mbd, beanName, args);
    
                // Guarantee initialization of beans that the current bean depends on.
                String[] dependsOn = mbd.getDependsOn();
                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);
                        }
                    }
                }
    
                // Create bean instance.
                if (mbd.isSingleton()) { 
                    sharedInstance = getSingleton(beanName, () -> { 
                        try { 
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) { 
                            // Explicitly remove instance from singleton cache: It might have been put there
                            // eagerly by the creation process, to allow for circular reference resolution.
                            // Also remove any beans that received a temporary reference to the bean.
                            destroySingleton(beanName);
                            throw ex;
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }
    
                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);
                }
    
                else { 
                    String scopeName = mbd.getScope();
                    final 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);
                            }
                        });
                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    }
                    catch (IllegalStateException ex) { 
                        throw new BeanCreationException(beanName,
                                                        "Scope '" + scopeName + "' is not active for the current thread; consider " +
                                                        "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                                                        ex);
                    }
                }
            }
            catch (BeansException ex) { 
                cleanupAfterBeanCreationFailure(beanName);
                throw ex;
            }
        }
    
        // Check if required type matches the type of the actual bean instance.
        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) { 
                if (logger.isTraceEnabled()) { 
                    logger.trace("Failed to convert bean '" + name + "' to required type '" +
                                 ClassUtils.getQualifiedName(requiredType) + "'", ex);
                }
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        }
        return (T) bean;
    }

getSingleton 方法，Spring使用的三级缓存：

一级缓存：singletonObjects，存储完整单例对象。

二级缓存：earlySingletonObjects，存储半成品单例对象。

三级缓存：singletonFactories，存储单例工厂对象。

public Object getSingleton(String beanName) { 
        return getSingleton(beanName, true);
    }
    /** * allowEarlyReference：是否允许非延迟加载 */
    protected Object getSingleton(String beanName, boolean allowEarlyReference) { 
        // 尝试从一级缓存里面获取完备的bean
        Object singletonObject = this.singletonObjects.get(beanName);
        // 如果完备的单例还没有创建出来，创建中的bean的名字会被保存在SingletonCurrentlyInCreation中
        // 因此看看是否正在创建。
        // 如果当前bean是单例的并且正在创建中，那么执行if中的逻辑
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { 
            /* 尝试给一级缓存对象加锁，因为接下来就要对缓存对象进行操作了 防止其它线程此时对缓存的同时操作，导致if逻辑中的其它几级的缓存数据对不上 */
            synchronized (this.singletonObjects) { 
                // 尝试从二级缓存 earlySingletonObjects 中获取半成品的Bean
                singletonObject = this.earlySingletonObjects.get(beanName);
                // 如果还获取不到并且允许非延迟加载，allowEarlyReference为true则表示bean允许被循环引用
                if (singletonObject == null && allowEarlyReference) { 
                    /* 尝试从三级缓存 singletonFactories 这个 ObjectFactory 实例的缓存里尝试获取创建 此Bean的单例工厂实例 */
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                   	// 如果从三级缓存中获取到了工厂实例
                    if (singletonFactory != null) { 
                        // 调用单例工厂的getObject方法返回对象实例
                        singletonObject = singletonFactory.getObject();
                        // 将实例放入二级缓存里
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        // 从三级缓存中移除
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }

getObjectForBeanInstance 方法：如果是普通bean，直接返回，如果是FactoryBean，则返回getObject

// doGetBean方法中传入的参数为 getObjectForBeanInstance(sharedInstance, name, beanName, null);
    protected Object getObjectForBeanInstance(
        Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) { 
    
        // 如果name的名字是以&开头，则是FactoryBean
        if (BeanFactoryUtils.isFactoryDereference(name)) { 
            if (beanInstance instanceof NullBean) { 
                return beanInstance;
            }
            // 如果name是&开头的，但是不是FactoryBean，则直接抛异常
            if (!(beanInstance instanceof FactoryBean)) { 
                throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
            }
            if (mbd != null) { 
                mbd.isFactoryBean = true;
            }
            return beanInstance;
        }
    
        // Now we have the bean instance, which may be a normal bean or a FactoryBean.
        // If it's a FactoryBean, we use it to create a bean instance, unless the
        // caller actually wants a reference to the factory.
        if (!(beanInstance instanceof FactoryBean)) { 
            return beanInstance;
        }
    
        Object object = null;
        if (mbd != null) { 
            mbd.isFactoryBean = true;
        }
        else { 
            // 单例模式下，FactoryBean仅会创建一个Bean实例，因此需要优先从缓存中获取
            // 在之前FactoryBean 创建 Bean 实例的时候就存放到了缓存中
            object = getCachedObjectForFactoryBean(beanName);
        }
        // 如果缓存中没有Bean实例，那么尝试创建
        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)) { 
                // 在创建Bean之前会尝试从容器中获取 BeanDefinition 实例
                mbd = getMergedLocalBeanDefinition(beanName);
            }
            // synthetic 属性用于标识某个类是 Spring 容器内部创建的Bean，不允许用户对其进行修改
            boolean synthetic = (mbd != null && mbd.isSynthetic());
            // 调用 FactoryBeanRegistrySupport 中的getObjectFromFactoryBean方法获取Bean实例
            object = getObjectFromFactoryBean(factory, beanName, !synthetic);
        }
        return object;
    }

FactoryBeanRegistrySupport中的 getObjectFromFactoryBean方法：从FactoryBean中获取实例

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) { 
        // 如果需要在工厂模式下维持单例的话
        if (factory.isSingleton() && containsSingleton(beanName)) { 
            // 又见双重检查锁机制，尝试再从缓存中获取,防止多线程下可能有别的线程已完成该单例Bean的创建
            synchronized (getSingletonMutex()) { 
                // 调用工厂方法，创建Bean实例
                Object object = this.factoryBeanObjectCache.get(beanName);
                if (object == null) { 
                    // 调用工厂方法创建Bean实例
                    object = doGetObjectFromFactoryBean(factory, beanName);
                    // Only post-process and store if not put there already during getObject() call above
                    // (e.g. because of circular reference processing triggered by custom getBean calls)
                    // 看看此时是否被别的线程已经创建好了Bean实例，如果是则使用
                    Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                    if (alreadyThere != null) { 
                        object = alreadyThere;
                    }
                    else { 
                        if (shouldPostProcess) { 
                            if (isSingletonCurrentlyInCreation(beanName)) { 
                                // Temporarily return non-post-processed object, not storing it yet..
                                return object;
                            }
                            beforeSingletonCreation(beanName);
                            try { 
                                // 触发 BeanPostProcessor，第三方框架可以在此用AOP来包装bean实例
                                object = postProcessObjectFromFactoryBean(object, beanName);
                            }
                            catch (Throwable ex) { 
                                throw new BeanCreationException(beanName,
                                                                "Post-processing of FactoryBean's singleton object failed", ex);
                            }
                            finally { 
                                // 创建完成之后，从缓存锁定的名字里清除
                                afterSingletonCreation(beanName);
                            }
                        }
                        if (containsSingleton(beanName)) { 
                            // 将其放入缓存，证明单例已经创建完成了
                            this.factoryBeanObjectCache.put(beanName, object);
                        }
                    }
                }
                return object;
            }
        }
        // 如果不是单例，则直接创建并返回
        else { 
            Object object = doGetObjectFromFactoryBean(factory, beanName);
            if (shouldPostProcess) { 
                try { 
                    object = postProcessObjectFromFactoryBean(object, beanName);
                }
                catch (Throwable ex) { 
                    throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
                }
            }
            return object;
        }
    }

其它方法不再继续往下研究了，否则“没完没了”。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBATXJESnVu_size_61_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/3c94fbbe244e41dc9952089c86885f17.png