踩坑记:根据类型获取Spring容器中的Bean

  1. 云栖社区>
  2. 博客>
  3. 正文

踩坑记:根据类型获取Spring容器中的Bean

木叶之荣 2018-09-14 00:03:08 浏览1019
展开阅读全文

在项目开发中遇到了这样的一个问题:有同事在BeanFactoryPostProcessor的实现方法中写了类似这样的一段代码:

@Component
public class BeanFactoryPostProcessorImpl implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        //就是这一段代码
        beanFactory.getBean(GetBeanByType.class);
    }
}

然后导致了一些实现了FactoryBean接口的Bean被提前创建了,当时感觉很奇怪,我只是根据传入的Class会获取Bean,为什么会导致一些实现了FactoryBean接口的Bean也被创建呢?其实即使我们是根据类型从Spring容器中获取Bean,但是Spring容器在实现的时候,最底层还是会调用getBean(java.lang.String, java.lang.Class, java.lang.Object...)这个方法获取Bean,那么当我们根据类型从Spring容器中获取Bean的时候就先找到这个类型对应的在Spring容器中的beanName,问题就出在获取这个beanName的地方。真正出问题的是AbstractBeanFactory#isTypeMatch(java.lang.String, org.springframework.core.ResolvableType)这个方法。下面我们来分一下获取beanName的这个过程。
其入口方法为:DefaultListableBeanFactory#getBeanNamesForType(java.lang.Class<?>),代码如下:

    public String[] getBeanNamesForType(Class<?> type) {
        //这里传入的三个参数 type是bean的Class 第二个参数的意思是 是否包含非单例的bean
        //第三个参数很重要 这里传入的值为true 这里传入true 代表允许提前初始化Bean
        //如果这个值为false的话 代表不允许提前初始化Bean 问题就出在这个值为true!!!
        return getBeanNamesForType(type, true, true);
    }
    @Override
    public String[] getBeanNamesForType(Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
        //如果是在容器启动过程中 这个值为false 如果在容器启动完成之后 这个值会变为true 这个值的更改在
        //DefaultListableBeanFactory#freezeConfiguration 可以看一下它的调用关系
        //下面的内容就很简单了  我们主要分析doGetBeanNamesForType这个方法
        if (!isConfigurationFrozen() || type == null || !allowEagerInit) {
            return doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit);
        }
        //这里是从缓存中获取,includeNonSingletons是否包含非单例的方法
        Map<Class<?>, String[]> cache =
                (includeNonSingletons ? this.allBeanNamesByType : this.singletonBeanNamesByType);
        String[] resolvedBeanNames = cache.get(type);
        if (resolvedBeanNames != null) {
            return resolvedBeanNames;
        }
        resolvedBeanNames = doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, true);
        if (ClassUtils.isCacheSafe(type, getBeanClassLoader())) {
            cache.put(type, resolvedBeanNames);
        }
        return resolvedBeanNames;
    }

DefaultListableBeanFactory#doGetBeanNamesForType

    private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
        List<String> result = new ArrayList<String>();
        // Check all bean definitions.
        // 注意这里是循环Spring容器中所有的BeanDefinition
        for (String beanName : this.beanDefinitionNames) {
            // Only consider bean as eligible if the bean name
            // is not defined as alias for some other bean.
            //beanName不是别名
            if (!isAlias(beanName)) {
                try {
                    //这里你可以暂时理解为根据BeanName获取BeanDefinition
                    RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                    // Only check bean definition if it is complete.
                    //下面这个判断比较长 一个一个的来说一下
                    //mbd.isAbstract()判断这个类是不是抽象类 默认是false
                    //allowEagerInit  是否允许提前初始化 这个值是传入的值  我们这里传入的值是true 即允许提前初始化
                    //mbd.hasBeanClass()  是否已经有BeanClass了
                    //mbd.isLazyInit()是否允许延迟初始化 默认false
                    //isAllowEagerClassLoading() 是否允许提前加载  上面这四个值是或的关系  只有有一个为true就可以
                    //requiresEagerInitForType 检查特殊的Bean是否需要提前被初始化 这里传入的是工厂方法的名字
                    //我们把这个条件总结一下 如果这个Bean不是一个抽象类,并且(被允许提前初始化 或者 (这个Bean的  
                    //BeanDefinition设置了BeanClass了 或者 这个Bean没有设置延迟加载 或者 即使这个Bean标注为延迟加载了,也可以被提前加载(全局变量)  并且 BeanDefinition中的FactoryBeanName是否允许被提前初始化))
                    //根据我们前面的分析 allowEagerInit 的值为true 这个Bean也不是个抽象类,所以会继续下面的流程
                    if (!mbd.isAbstract() && (allowEagerInit ||
                            ((mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading())) &&
                                    !requiresEagerInitForType(mbd.getFactoryBeanName()))) {
                        // In case of FactoryBean, match object created by FactoryBean.
                        // 判断是不是FactoryBean
                        boolean isFactoryBean = isFactoryBean(beanName, mbd);
                        BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
                        // 这个地方是判断是不是找到匹配的beanName 这里关键的是isTypeMatch这个方法
                        // 在这个方法中会导致一些FactoryBean被提前实例化 所以这里给我们的一个提示是:
                        // 在Spring容器的启动阶段,调用isTypeMatch这个方法去判断Bean的类型的时候要慎重一些。 
                        // 我们要重点分析isTypeMatch这个方法
                        boolean matchFound =
                                (allowEagerInit || !isFactoryBean ||
                                        (dbd != null && !mbd.isLazyInit()) || containsSingleton(beanName)) &&
                                (includeNonSingletons ||
                                        (dbd != null ? mbd.isSingleton() : isSingleton(beanName))) &&
                                isTypeMatch(beanName, type);
                        //如果类型不匹配 并且还是FactoryBean类型的BeanDefinition
                        if (!matchFound && isFactoryBean) {
                            // In case of FactoryBean, try to match FactoryBean instance itself next.
                            //这里讲beanName变为&beanName
                            beanName = FACTORY_BEAN_PREFIX + beanName;
                            //继续判断类型匹配不匹配
                            matchFound = (includeNonSingletons || mbd.isSingleton()) && isTypeMatch(beanName, type);
                        }
                        //如果类型相匹配的话 则将beanName放入到结果集中
                        if (matchFound) {
                            result.add(beanName);
                        }
                    }
                }
                catch (CannotLoadBeanClassException ex) {
                }
                catch (BeanDefinitionStoreException ex) {
                }
            }
        }
        //这一部分的处理流程大致相同
        // Check manually registered singletons too.
        for (String beanName : this.manualSingletonNames) {
            try {
                // In case of FactoryBean, match object created by FactoryBean.
                if (isFactoryBean(beanName)) {
                    if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) {
                        result.add(beanName);
                        // Match found for this bean: do not match FactoryBean itself anymore.
                        continue;
                    }
                    // In case of FactoryBean, try to match FactoryBean itself next.
                    beanName = FACTORY_BEAN_PREFIX + beanName;
                }
                // Match raw bean instance (might be raw FactoryBean).
                if (isTypeMatch(beanName, type)) {
                    result.add(beanName);
                }
            }
            catch (NoSuchBeanDefinitionException ex) {
            }
        }
        return StringUtils.toStringArray(result);
    }

下面我们来看看isTypeMatch这个方法的内容


    @Override
    public boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException {
        //这里是对beanName进行转换 如:如果传入的beanName是&beanName,则将&去掉。如果传入的beanName有别名的话,则替换为别名
        String beanName = transformedBeanName(name);
        
        // Check manually registered singletons.
        //根据beanName获取bean的实例 前提是其对应的bean已经被实例化了 或者正在实例化中
        Object beanInstance = getSingleton(beanName, false);
        if (beanInstance != null) {
            //如果是FactoryBean类型的实例
            if (beanInstance instanceof FactoryBean) {
                //是否要获取在FactoryBean中创建的Bean实例 调用 getObject getObjectType方法
                //这个地方的判断条件是 传入的beanName是否以&开头 如果以&开头,则返回true
                if (!BeanFactoryUtils.isFactoryDereference(name)) {
                    //这里是调用FactoryBean的getObjectType方法 来获取bean的类型
                    Class<?> type = getTypeForFactoryBean((FactoryBean<?>) beanInstance);
                    return (type != null && typeToMatch.isAssignableFrom(type));
                }
                else {
                    //直接获取FactoryBean类型的实例
                    return typeToMatch.isInstance(beanInstance);
                }
            }
            //判断beanName是否以&开头,如果以&开头的话 则返回true
            else if (!BeanFactoryUtils.isFactoryDereference(name)) {
                //如果beanName不是以&开头 则直接进行类型比较
                if (typeToMatch.isInstance(beanInstance)) {
                    // Direct match for exposed instance?
                    return true;
                }
                //泛型的处理
                else if (typeToMatch.hasGenerics() && containsBeanDefinition(beanName)) {
                    // Generics potentially only match on the target class, not on the proxy...
                    RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                    Class<?> targetType = mbd.getTargetType();
                    if (targetType != null && targetType != ClassUtils.getUserClass(beanInstance) &&
                            typeToMatch.isAssignableFrom(targetType)) {
                        // Check raw class match as well, making sure it's exposed on the proxy.
                        Class<?> classToMatch = typeToMatch.resolve();
                        return (classToMatch == null || classToMatch.isInstance(beanInstance));
                    }
                }
            }
            return false;
        }
        else if (containsSingleton(beanName) && !containsBeanDefinition(beanName)) {
            // null instance registered
            return false;
        }

        // No singleton instance found -> check bean definition.
        //这里是从父BeanFactory中进行查找匹配 查找匹配的过程是一样的。
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // No bean definition found in this factory -> delegate to parent.
            return parentBeanFactory.isTypeMatch(originalBeanName(name), typeToMatch);
        }

        // Retrieve corresponding bean definition.
        //根据beanName重新检索BeanDefinition 这里返回一个RootBeanDefinition 如果父子容器中存在相同类型的bean会进行合并
        RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
        //解析出 class的类型
        Class<?> classToMatch = typeToMatch.resolve();
        if (classToMatch == null) {
            classToMatch = FactoryBean.class;
        }
        //如果传入的class类型为FactoryBean类型 则直接返回FactoryBean类型的数组 否则会将传入的class的类型和FactoryBean组装在一起
        Class<?>[] typesToMatch = (FactoryBean.class == classToMatch ?
                new Class<?>[] {classToMatch} : new Class<?>[] {FactoryBean.class, classToMatch});

        // Check decorated bean definition, if any: We assume it'll be easier
        // to determine the decorated bean's type than the proxy's type.
        //这个地方是获取最原始的BeanDefinition 不是组装之后的 RootBeanDefinition
        BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
        //如果dbd 存在并且 beanName不是以&开头
        if (dbd != null && !BeanFactoryUtils.isFactoryDereference(name)) {
            RootBeanDefinition tbd = getMergedBeanDefinition(dbd.getBeanName(), dbd.getBeanDefinition(), mbd);
            //这里是取BeanDefinition中的bean类型
            Class<?> targetClass = predictBeanType(dbd.getBeanName(), tbd, typesToMatch);
            if (targetClass != null && !FactoryBean.class.isAssignableFrom(targetClass)) {
                return typeToMatch.isAssignableFrom(targetClass);
            }
        }
        //获取目标类型 通常是去BeanDefinition中的resolvedTargetType
        Class<?> beanType = predictBeanType(beanName, mbd, typesToMatch);
        if (beanType == null) {
            return false;
        }
        
        // Check bean class whether we're dealing with a FactoryBean.
        //如果BeanDefinition中的beanType是FactoryBean类型
        if (FactoryBean.class.isAssignableFrom(beanType)) {
            if (!BeanFactoryUtils.isFactoryDereference(name)) {
                // If it's a FactoryBean, we want to look at what it creates, not the factory class.
                //就是这个地方 会将FactoryBean类型的Bean进行实例化
                //我们来分析这个方法
                beanType = getTypeForFactoryBean(beanName, mbd);
                if (beanType == null) {
                    return false;
                }
            }
        }
        else if (BeanFactoryUtils.isFactoryDereference(name)) {
            // Special case: A SmartInstantiationAwareBeanPostProcessor returned a non-FactoryBean
            // type but we nevertheless are being asked to dereference a FactoryBean...
            // Let's check the original bean class and proceed with it if it is a FactoryBean.
            //这个地方需要注意的是 SmartInstantiationAwareBeanPostProcessor类型的BeanPostProcessor会对返回的Bean类型做修改
            beanType = predictBeanType(beanName, mbd, FactoryBean.class);
            if (beanType == null || !FactoryBean.class.isAssignableFrom(beanType)) {
                return false;
            }
        }

        ResolvableType resolvableType = mbd.targetType;
        if (resolvableType == null) {
            //工厂方法创建的Bean
            resolvableType = mbd.factoryMethodReturnType;
        }
        if (resolvableType != null && resolvableType.resolve() == beanType) {
            return typeToMatch.isAssignableFrom(resolvableType);
        }
        return typeToMatch.isAssignableFrom(beanType);
    }

isTypeMatch这个方法就是进行各种Bean类型的判断,如是已经实例化的FactoryBean可能会调用它的getObjectType方法获取Bean的类型,或者从BeanDefinition中获取Bean的类型,并且如果是未实例化的FactoryBean,为了进行Bean类型的判断会导致FactoryBean的实例化。
下面我们来看看org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#getTypeForFactoryBean这个方法的内容:

    protected Class<?> getTypeForFactoryBean(String beanName, RootBeanDefinition mbd) {
        //工程Bean和工厂方法名 根据工厂方法创建Bean
        String factoryBeanName = mbd.getFactoryBeanName();
        String factoryMethodName = mbd.getFactoryMethodName();
        
        if (factoryBeanName != null) {
            if (factoryMethodName != null) {
                // Try to obtain the FactoryBean's object type from its factory method declaration
                // without instantiating the containing bean at all.
                BeanDefinition fbDef = getBeanDefinition(factoryBeanName);
                if (fbDef instanceof AbstractBeanDefinition) {
                    AbstractBeanDefinition afbDef = (AbstractBeanDefinition) fbDef;
                    if (afbDef.hasBeanClass()) {
                        Class<?> result = getTypeForFactoryBeanFromMethod(afbDef.getBeanClass(), factoryMethodName);
                        if (result != null) {
                            return result;
                        }
                    }
                }
            }
            // If not resolvable above and the referenced factory bean doesn't exist yet,
            // exit here - we don't want to force the creation of another bean just to
            // obtain a FactoryBean's object type...
            if (!isBeanEligibleForMetadataCaching(factoryBeanName)) {
                return null;
            }
        }

        // Let's obtain a shortcut instance for an early getObjectType() call...
        //getSingletonFactoryBeanForTypeCheck和getNonSingletonFactoryBeanForTypeCheck这两个方法是创建FactoryBean的实例了
        FactoryBean<?> fb = (mbd.isSingleton() ?
                getSingletonFactoryBeanForTypeCheck(beanName, mbd) :
                getNonSingletonFactoryBeanForTypeCheck(beanName, mbd));

        if (fb != null) {
            // Try to obtain the FactoryBean's object type from this early stage of the instance.
            //调用getObjectType方法
            Class<?> result = getTypeForFactoryBean(fb);
            if (result != null) {
                return result;
            }
            else {
                // No type found for shortcut FactoryBean instance:
                // fall back to full creation of the FactoryBean instance.
                return super.getTypeForFactoryBean(beanName, mbd);
            }
        }

        if (factoryBeanName == null && mbd.hasBeanClass()) {
            // No early bean instantiation possible: determine FactoryBean's type from
            // static factory method signature or from class inheritance hierarchy...
            if (factoryMethodName != null) {
                return getTypeForFactoryBeanFromMethod(mbd.getBeanClass(), factoryMethodName);
            }
            else {
                return GenericTypeResolver.resolveTypeArgument(mbd.getBeanClass(), FactoryBean.class);
            }
        }

        return null;
    }

上面这个方法的内容是:如果是以工厂方法来创建Bean的话,则从工厂方法中返回bean类型,如果是FactoryBean类型的Bean的话,会实例化FactoryBean类型的Bean。实例化是在getSingletonFactoryBeanForTypeCheck或getNonSingletonFactoryBeanForTypeCheck方法中完成的。

    private FactoryBean<?> getSingletonFactoryBeanForTypeCheck(String beanName, RootBeanDefinition mbd) {
        synchronized (getSingletonMutex()) {
            //先从缓存中获取
            BeanWrapper bw = this.factoryBeanInstanceCache.get(beanName);
            if (bw != null) {
                return (FactoryBean<?>) bw.getWrappedInstance();
            }
            //这个bean是不是正在创建中
            if (isSingletonCurrentlyInCreation(beanName) ||
                    (mbd.getFactoryBeanName() != null && isSingletonCurrentlyInCreation(mbd.getFactoryBeanName()))) {
                return null;
            }

            Object instance = null;
            try {
                // Mark this bean as currently in creation, even if just partially.
                //判断是不是正在创建中的bean
                beforeSingletonCreation(beanName);
                // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
                //Bean实例化之前的一些处理 由Spring容器中InstantiationAwareBeanPostProcessor类型的实例来完成
                instance = resolveBeforeInstantiation(beanName, mbd);
                if (instance == null) {
                    //创建Bean的实例 看到这里就很明了了
                    bw = createBeanInstance(beanName, mbd, null);
                    instance = bw.getWrappedInstance();
                }
            }
            finally {
                // Finished partial creation of this bean.
                afterSingletonCreation(beanName);
            }

            FactoryBean<?> fb = getFactoryBean(beanName, instance);
            if (bw != null) {
                this.factoryBeanInstanceCache.put(beanName, bw);
            }
            return fb;
        }
    }

按照我们上面的分析,在doGetBeanNamesForType这个方法中,

private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) 

allowEagerInit是一个非常重要的参数,这个参数可以控制要不要提前实例化一些Bean。为什么这样说呢?因为要不要调用isTypeMatch这个方法在很大程度上是由这个条件控制的

if (!mbd.isAbstract() && (allowEagerInit ||((mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading())) &&!requiresEagerInitForType(mbd.getFactoryBeanName())))

通常我们的BeanDefinition都不是抽象类的,所以第一个条件为true,我们来看第二个条件,就是后面的那一大堆

(allowEagerInit ||((mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading())) &&!requiresEagerInitForType(mbd.getFactoryBeanName()))

这个条件分为两部分,是一个或的条件。如果allowEagerInit 为true的话,则整个条件为true,如果allowEagerInit 为false呢?mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()这三个条件基本上也是为true但是这个地方是一个与的条件,那么还要判断一下requiresEagerInitForType(mbd.getFactoryBeanName())这个方法是返回的true还是false。

    private boolean requiresEagerInitForType(String factoryBeanName) {
        //factoryBeanName不为null  isFactoryBean(factoryBeanName) 是否为FactoryBeanBean 
        //containsSingleton(factoryBeanName)) 如果这个Bean已经被实例化了 这个返回的值为true
        return (factoryBeanName != null && isFactoryBean(factoryBeanName) && !containsSingleton(factoryBeanName));
    }

因为我们在这篇文章中的分析是根据类型获取Bean会导致FactoryBean类型的Bean被提前实例化,所以factoryBeanName不为null,isFactoryBean(factoryBeanName) 为true,!containsSingleton(factoryBeanName)同样为true。综合requiresEagerInitForType这个方法返回true,那么

((mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading())) &&!requiresEagerInitForType(mbd.getFactoryBeanName())

会返回false,那这个这一大段的逻辑也就返回false了。
所以我们在根据类型获取Bean的时候要谨慎一点,如果整个Spring容器已经启动完成之后,根据类型获取Bean是没有问题的,如果是在Spring容器的启动过程中根据类型获取Bean可能会导致一些意想不到的结果。

网友评论

登录后评论
0/500
评论
木叶之荣
+ 关注