版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/zknxx/article/details/80822352
在项目开发中遇到了这样的一个问题：有同事在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可能会导致一些意想不到的结果。