AbstractBeanFactory

一时失言乱红尘 2024-03-23 19:22 30阅读 0赞

*  这是一个抽象基类，用于实现\{@link org.springframework.beans.factory.BeanFactory\}的全功能，提供了\{@link org.springframework.beans.factory.config.ConfigurableBeanFactory\}的所有能力。
 *  这个抽象类的子类需要实现的主要模板方法是\{@link \#getBeanDefinition\}和\{@link \#createBean\}，分别用于获取给定bean名称的bean定义和为给定的bean定义创建一个bean实例。这些操作的默认实现可以在\{@link DefaultListableBeanFactory\}和\{@link AbstractAutowireCapableBeanFactory\}中找到。

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {}

*  这是一个父Bean工厂属性，用于实现Bean的继承支持。

@Nullable
    	private BeanFactory parentBeanFactory;

*  这是一个用于解析Bean类名的ClassLoader属性，如果需要的话。默认情况下，它使用ClassUtils.getDefaultClassLoader()方法获取默认的ClassLoader。

@Nullable
    	private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();

*  这是一个临时用于解析Bean类名的ClassLoader属性，如果需要的话。

@Nullable
    	private ClassLoader tempClassLoader;

*  这是一个布尔类型的属性，用于确定是否缓存bean元数据，还是每次访问时重新获取。默认情况下，它设置为true，表示要缓存bean元数据。

private boolean cacheBeanMetadata = true;

*  这是一个用于对Bean定义值中的表达式进行解析的解析器属性。它可以解析Bean定义中的表达式，并将其转换为实际的值。如果没有指定解析器，将使用默认的解析策略。

@Nullable
    	private BeanExpressionResolver beanExpressionResolver;

*  这是一个Spring ConversionService属性，用于替代PropertyEditors进行类型转换。ConversionService是Spring框架提供的一个强大的类型转换机制，可以将一个类型转换为另一个类型。如果没有指定ConversionService，将使用默认的PropertyEditors进行类型转换。

@Nullable
    	private ConversionService conversionService;

*  这是一个用于注册自定义PropertyEditorRegistrar的属性集合，可以将其应用于此工厂中的所有bean。PropertyEditorRegistrar可以注册自定义的PropertyEditors，用于将字符串转换为特定类型的属性值。通过使用PropertyEditorRegistrar，可以在BeanFactory中注册多个自定义的PropertyEditorRegistrar实例来支持不同类型的属性编辑。这个属性是一个Set集合，初始化容量为4。

private final Set<PropertyEditorRegistrar> propertyEditorRegistrars = new LinkedHashSet<>(4);

*  这是一个用于注册自定义PropertyEditor的属性映射，可以将其应用于此工厂中的所有bean。PropertyEditor用于将字符串转换为特定类型的属性值。通过使用自定义的PropertyEditor，可以为特定的属性类型提供自定义的转换逻辑。这个属性是一个Map映射，其中键是属性类型的Class对象，值是对应的自定义PropertyEditor的Class对象。初始化时使用HashMap，并设置容量为4。

private final Map<Class<?>, Class<? extends PropertyEditor>> customEditors = new HashMap<>(4);

*  `typeConverter`字段用于指定在Spring应用程序中处理类型转换的自定义 `TypeConverter`。它允许您覆盖默认的 `PropertyEditor`机制。
 *  类型转换是将一个值从一种数据类型转换为另一种类型的过程。在Spring应用程序中，通常在将请求参数绑定到方法参数或从配置文件转换属性值时进行类型转换。
 *  默认情况下，Spring使用 `PropertyEditor`来执行类型转换。但是，您可以提供自己的 `TypeConverter`接口实现，并将其设置为 `typeConverter`属性，以自定义类型转换过程。

@Nullable
    	private TypeConverter typeConverter;

*  这是一个String解析器列表，用于处理注解属性值中的字符串。它存储多个StringValueResolver对象，可以将占位符或表达式解析为相应的值。这个列表是线程安全的，可以在并发环境中使用。

private final List<StringValueResolver> embeddedValueResolvers = new CopyOnWriteArrayList<>();

*  BeanPostProcessorCacheAwareList是一个特殊的实现类，实现了List接口，并具有缓存功能。它可以在使用BeanPostProcessor时提供更高的性能和效率。
 *  通过对beanPostProcessors列表添加自定义的BeanPostProcessor对象，可以在Spring应用程序中对Bean进行一系列的定制化处理，例如修改属性值、注册事件监听器、代理Bean等。

private final List<BeanPostProcessor> beanPostProcessors = new BeanPostProcessorCacheAwareList();

*  在这个方法中，它调用了 `doGetBean()` 方法来获取指定名称的 bean 对象。 `doGetBean()` 方法是 `AbstractBeanFactory` 中定义的一个抽象方法，需要具体的子类来实现。

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

*  在这个方法中，它调用了 `doGetBean()` 方法来获取指定名称和类型的 bean 对象。 `doGetBean()` 方法是 `AbstractBeanFactory` 中定义的一个抽象方法，需要具体的子类来实现。

@Override
    	public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
    		return doGetBean(name, requiredType, null, false);
    	}

*  `AbstractBeanFactory` 类中 `doGetBean()方法做了以下工作：`

1.  获取转换后的 bean 名称。
2.  首先检查单例缓存中是否存在手动注册的单例实例。如果存在且没有指定参数 args，则直接返回该实例。
3.  如果正在创建该原型 bean 实例，则抛出 `BeanCurrentlyInCreationException` 异常，以避免循环引用。
4.  检查当前工厂中是否存在该 bean 的定义。如果不存在，则查找父级 BeanFactory 并委托它去获取该 bean。
5.  如果不仅用于类型检查（typeCheckOnly 为 false），则将该 bean 标记为已创建。
6.  创建一个 StartupStep，记录 bean 的实例化过程。
7.  根据 requiredType 获取合并后的 RootBeanDefinition，并进行相关的检查。
8.  确保初始化当前 bean 依赖的所有 beans。
9.  根据 BeanDefinition 的作用域，创建对应类型的 bean 实例，并将其放入合适的容器中（单例实例放入 singletonObjects 容器，原型实例不缓存，作用域实例放入相应的作用域容器）。
10. 将 bean 实例返回，根据需要进行类型适配。

protected <T> T doGetBean(
    			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    			throws BeansException {
    
    		String beanName = transformedBeanName(name);
    		Object beanInstance;
    
    		// Eagerly check singleton cache for manually registered singletons.
    		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 + "'");
    				}
    			}
    			beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    		}
    
    		else {
    			// Fail if we're already creating this bean instance:
    			// We're assumably within a circular reference.
    			if (isPrototypeCurrentlyInCreation(beanName)) {
    				throw new BeanCurrentlyInCreationException(beanName);
    			}
    
    			// Check if bean definition exists in this factory.
    			BeanFactory parentBeanFactory = getParentBeanFactory();
    			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    				// Not found -> check parent.
    				String nameToLookup = originalBeanName(name);
    				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);
    			}
    
    			StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
    					.tag("beanName", name);
    			try {
    				if (requiredType != null) {
    					beanCreation.tag("beanType", requiredType::toString);
    				}
    				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;
    						}
    					});
    					beanInstance = 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);
    					}
    					beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
    				}
    
    				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);
    	}

*  `AbstractBeanFactory` 类中方法 `adaptBeanInstance()做了以下工作：`

1.  检查所需类型是否与实际 bean 实例的类型匹配。
2.  如果所需类型不为空且与实际 bean 实例的类型不匹配，则尝试进行类型转换。
3.  如果类型转换失败，则抛出 `BeanNotOfRequiredTypeException` 异常。
4.  将转换后的 bean 实例返回。

<T> T adaptBeanInstance(String name, Object bean, @Nullable Class<?> requiredType) {
    		// Check if required type matches the type of the actual bean instance.
    		if (requiredType != null && !requiredType.isInstance(bean)) {
    			try {
    				Object convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
    				if (convertedBean == null) {
    					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    				}
    				return (T) 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;
    	}

*  `AbstractBeanFactory` 类中的 `containsBean()` 方法做了以下工作：

1.  获取转换后的 bean 名称。
2.  如果单例缓存或者 Bean 定义中包含该 bean 名称，则返回 true。
3.  如果名称是一个工厂引用，则检查是否是 FactoryBean。
4.  如果找不到该 bean 名称，则检查父级 BeanFactory 中是否存在对应的 bean。
5.  如果存在父级 BeanFactory 并且父级 BeanFactory 中包含原始的 bean 名称，则返回 true。

@Override
    	public boolean containsBean(String name) {
    		String beanName = transformedBeanName(name);
    		if (containsSingleton(beanName) || containsBeanDefinition(beanName)) {
    			return (!BeanFactoryUtils.isFactoryDereference(name) || isFactoryBean(name));
    		}
    		// Not found -> check parent.
    		BeanFactory parentBeanFactory = getParentBeanFactory();
    		return (parentBeanFactory != null && parentBeanFactory.containsBean(originalBeanName(name)));
    	}

*  `AbstractBeanFactory` 类中的 `isSingleton()` 方法的实现：

1.  获取转换后的 bean 名称。
2.  如果单例缓存中存在该 bean 实例，首先检查该实例是否是一个 FactoryBean。如果是 FactoryBean，则根据是否是工厂引用（以 `&` 开头）或 FactoryBean 自身是否是单例来判断返回结果；如果不是 FactoryBean，则根据是否是工厂引用来判断返回结果。
3.  如果找不到该 bean 名称，则检查父级 BeanFactory 中是否存在对应的 bean 定义，并返回父级 BeanFactory 的结果。
4.  如果该 bean 定义标识为单例，再次检查是否是 FactoryBean。如果是 FactoryBean，则根据是否是工厂引用来判断返回结果；如果不是 FactoryBean，则返回是否是工厂引用的结果。
5.  如果该 bean 定义标识不是单例，则返回 false。

@Override
    	public boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
    		String beanName = transformedBeanName(name);
    
    		Object beanInstance = getSingleton(beanName, false);
    		if (beanInstance != null) {
    			if (beanInstance instanceof FactoryBean) {
    				return (BeanFactoryUtils.isFactoryDereference(name) || ((FactoryBean<?>) beanInstance).isSingleton());
    			}
    			else {
    				return !BeanFactoryUtils.isFactoryDereference(name);
    			}
    		}
    
    		// No singleton instance found -> check bean definition.
    		BeanFactory parentBeanFactory = getParentBeanFactory();
    		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    			// No bean definition found in this factory -> delegate to parent.
    			return parentBeanFactory.isSingleton(originalBeanName(name));
    		}
    
    		RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    
    		// In case of FactoryBean, return singleton status of created object if not a dereference.
    		if (mbd.isSingleton()) {
    			if (isFactoryBean(beanName, mbd)) {
    				if (BeanFactoryUtils.isFactoryDereference(name)) {
    					return true;
    				}
    				FactoryBean<?> factoryBean = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
    				return factoryBean.isSingleton();
    			}
    			else {
    				return !BeanFactoryUtils.isFactoryDereference(name);
    			}
    		}
    		else {
    			return false;
    		}
    	}

*  `AbstractBeanFactory` 类中的 `isPrototype()` 方法的实现：

1.  获取转换后的 bean 名称。
2.  检查父级 BeanFactory 中是否存在对应的 bean 定义，如果存在，则委托给父级 BeanFactory 来判断该 bean 是否是原型对象。
3.  如果在当前 BeanFactory 中找到了 bean 定义，则根据 merged bean 定义信息判断该 bean 是否是原型对象。如果是原型对象，并且该 bean 不是一个工厂引用或 FactoryBean 对象，则返回 true。
4.  如果该 bean 是 FactoryBean 对象，并且不是一个工厂引用（以 `&` 开头），则根据 FactoryBean 的类型和 isSingleton() 方法来判断是否是原型对象。
5.  如果以上条件都不满足，则返回 false。

@Override
    	public boolean isPrototype(String name) throws NoSuchBeanDefinitionException {
    		String beanName = transformedBeanName(name);
    
    		BeanFactory parentBeanFactory = getParentBeanFactory();
    		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    			// No bean definition found in this factory -> delegate to parent.
    			return parentBeanFactory.isPrototype(originalBeanName(name));
    		}
    
    		RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    		if (mbd.isPrototype()) {
    			// In case of FactoryBean, return singleton status of created object if not a dereference.
    			return (!BeanFactoryUtils.isFactoryDereference(name) || isFactoryBean(beanName, mbd));
    		}
    
    		// Singleton or scoped - not a prototype.
    		// However, FactoryBean may still produce a prototype object...
    		if (BeanFactoryUtils.isFactoryDereference(name)) {
    			return false;
    		}
    		if (isFactoryBean(beanName, mbd)) {
    			FactoryBean<?> fb = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
    			if (System.getSecurityManager() != null) {
    				return AccessController.doPrivileged(
    						(PrivilegedAction<Boolean>) () ->
    								((fb instanceof SmartFactoryBean && ((SmartFactoryBean<?>) fb).isPrototype()) ||
    										!fb.isSingleton()),
    						getAccessControlContext());
    			}
    			else {
    				return ((fb instanceof SmartFactoryBean && ((SmartFactoryBean<?>) fb).isPrototype()) ||
    						!fb.isSingleton());
    			}
    		}
    		else {
    			return false;
    		}
    	}

*  `AbstractBeanFactory` 类中的 `isTypeMatch()` 方法：

1.  首先，根据给定的 `name` 参数获取对应的 bean 的名称，并进行相关的转换和处理。
2.  判断是否是 FactoryDereference（工厂引用），即检查 `name` 是否是以 `&` 开头的。
3.  检查手动注册的单例 bean 是否存在并对其类型进行判断。如果单例 bean 是 `FactoryBean` 对象，则根据 `isFactoryDereference` 来判断是否与指定的 `typeToMatch` 匹配。如果单例 bean 不是 `FactoryBean`，则通过直接比较类型来判断。如果类型匹配，则返回 true。
4.  如果存在单例 bean 实例但未进行类型匹配，则根据是否持有泛型信息和是否包含对应的 bean 定义来判断。
5.  如果以上逻辑都不满足，则继续后面的判断。
6.  如果存在单例 bean 实例但没有对应的 bean 定义（即注册了空实例），则返回 false。
7.  如果有父级 `BeanFactory` 并且当前 `BeanFactory` 中不包含与指定的 `name` 对应的 bean 定义，则将匹配操作委托给父级 `BeanFactory`。
8.  否则，根据 `name` 参数获取与其对应的合并后的 bean 定义信息和装饰 bean 定义信息。
9.  设置要进行匹配的类型数组，并在需要时预测 bean 的类型。
10. 根据预测的类型和其他信息进行进一步的类型匹配判断。如果能够获取到 bean 的具体类型信息，则通过 `typeToMatch` 的 `isAssignableFrom()` 方法判断是否匹配。若无法获取具体类型信息，则返回 false。
11. 最后，根据匹配结果返回相应的布尔值。

/**
    	 * Internal extended variant of {@link #isTypeMatch(String, ResolvableType)}
    	 * to check whether the bean with the given name matches the specified type. Allow
    	 * additional constraints to be applied to ensure that beans are not created early.
    	 * @param name the name of the bean to query
    	 * @param typeToMatch the type to match against (as a
    	 * {@code ResolvableType})
    	 * @return {@code true} if the bean type matches, {@code false} if it
    	 * doesn't match or cannot be determined yet
    	 * @throws NoSuchBeanDefinitionException if there is no bean with the given name
    	 * @since 5.2
    	 * @see #getBean
    	 * @see #getType
    	 */
    	protected boolean isTypeMatch(String name, ResolvableType typeToMatch, boolean allowFactoryBeanInit)
    			throws NoSuchBeanDefinitionException {
    
    		String beanName = transformedBeanName(name);
    		boolean isFactoryDereference = BeanFactoryUtils.isFactoryDereference(name);
    
    		// Check manually registered singletons.
    		Object beanInstance = getSingleton(beanName, false);
    		if (beanInstance != null && beanInstance.getClass() != NullBean.class) {
    			if (beanInstance instanceof FactoryBean) {
    				if (!isFactoryDereference) {
    					Class<?> type = getTypeForFactoryBean((FactoryBean<?>) beanInstance);
    					return (type != null && typeToMatch.isAssignableFrom(type));
    				}
    				else {
    					return typeToMatch.isInstance(beanInstance);
    				}
    			}
    			else if (!isFactoryDereference) {
    				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)) {
    						// Check raw class match as well, making sure it's exposed on the proxy.
    						Class<?> classToMatch = typeToMatch.resolve();
    						if (classToMatch != null && !classToMatch.isInstance(beanInstance)) {
    							return false;
    						}
    						if (typeToMatch.isAssignableFrom(targetType)) {
    							return true;
    						}
    					}
    					ResolvableType resolvableType = mbd.targetType;
    					if (resolvableType == null) {
    						resolvableType = mbd.factoryMethodReturnType;
    					}
    					return (resolvableType != null && typeToMatch.isAssignableFrom(resolvableType));
    				}
    			}
    			return false;
    		}
    		else if (containsSingleton(beanName) && !containsBeanDefinition(beanName)) {
    			// null instance registered
    			return false;
    		}
    
    		// No singleton instance found -> check bean definition.
    		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.
    		RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    		BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
    
    		// Setup the types that we want to match against
    		Class<?> classToMatch = typeToMatch.resolve();
    		if (classToMatch == null) {
    			classToMatch = FactoryBean.class;
    		}
    		Class<?>[] typesToMatch = (FactoryBean.class == classToMatch ?
    				new Class<?>[] {classToMatch} : new Class<?>[] {FactoryBean.class, classToMatch});
    
    
    		// Attempt to predict the bean type
    		Class<?> predictedType = null;
    
    		// We're looking for a regular reference but we're a factory bean that has
    		// a decorated bean definition. The target bean should be the same type
    		// as FactoryBean would ultimately return.
    		if (!isFactoryDereference && dbd != null && isFactoryBean(beanName, mbd)) {
    			// We should only attempt if the user explicitly set lazy-init to true
    			// and we know the merged bean definition is for a factory bean.
    			if (!mbd.isLazyInit() || allowFactoryBeanInit) {
    				RootBeanDefinition tbd = getMergedBeanDefinition(dbd.getBeanName(), dbd.getBeanDefinition(), mbd);
    				Class<?> targetType = predictBeanType(dbd.getBeanName(), tbd, typesToMatch);
    				if (targetType != null && !FactoryBean.class.isAssignableFrom(targetType)) {
    					predictedType = targetType;
    				}
    			}
    		}
    
    		// If we couldn't use the target type, try regular prediction.
    		if (predictedType == null) {
    			predictedType = predictBeanType(beanName, mbd, typesToMatch);
    			if (predictedType == null) {
    				return false;
    			}
    		}
    
    		// Attempt to get the actual ResolvableType for the bean.
    		ResolvableType beanType = null;
    
    		// If it's a FactoryBean, we want to look at what it creates, not the factory class.
    		if (FactoryBean.class.isAssignableFrom(predictedType)) {
    			if (beanInstance == null && !isFactoryDereference) {
    				beanType = getTypeForFactoryBean(beanName, mbd, allowFactoryBeanInit);
    				predictedType = beanType.resolve();
    				if (predictedType == null) {
    					return false;
    				}
    			}
    		}
    		else if (isFactoryDereference) {
    			// 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.
    			predictedType = predictBeanType(beanName, mbd, FactoryBean.class);
    			if (predictedType == null || !FactoryBean.class.isAssignableFrom(predictedType)) {
    				return false;
    			}
    		}
    
    		// We don't have an exact type but if bean definition target type or the factory
    		// method return type matches the predicted type then we can use that.
    		if (beanType == null) {
    			ResolvableType definedType = mbd.targetType;
    			if (definedType == null) {
    				definedType = mbd.factoryMethodReturnType;
    			}
    			if (definedType != null && definedType.resolve() == predictedType) {
    				beanType = definedType;
    			}
    		}
    
    		// If we have a bean type use it so that generics are considered
    		if (beanType != null) {
    			return typeToMatch.isAssignableFrom(beanType);
    		}
    
    		// If we don't have a bean type, fallback to the predicted type
    		return typeToMatch.isAssignableFrom(predictedType);
    	}

*  `AbstractBeanFactory` 类中的 `getType(String name, boolean allowFactoryBeanInit)` 方法的具体实现：

1.  首先，将给定的 `name` 参数进行转换处理，得到对应的 bean 名称 `beanName`。
2.  检查手动注册的单例 bean 是否存在，并获取其实例对象。
    
     *  如果单例实例不为null且类型不是 `NullBean`，则执行以下判断：
        
         *  如果单例实例是 `FactoryBean`类型，且不是工厂引用，则返回通过调用 `getTypeForFactoryBean()`方法获取的 bean 类型。
         *  否则，直接返回单例实例的类型。
3.  如果没有找到单例实例，则检查是否有父级 `BeanFactory` 并且当前 `BeanFactory` 中不包含与 `beanName` 参数对应的 bean 定义。
    
     *  如果满足条件，将调用父级 `BeanFactory` 的 `getType()` 方法获取 bean 类型。
4.  如果以上条件都不满足，则获取合并后的本地 bean 定义信息 `mbd`。
5.  检查是否有装饰的 bean 定义 `dbd`，如果存在且不是工厂引用，则预测装饰的 bean 的类型 `targetClass`。
    
     *  如果预测到装饰的 bean 的类型，并且不是 FactoryBean 类型，则返回预测到的类型。
6.  调用 `predictBeanType()` 方法预测 bean 类型，并将结果赋值给 `beanClass` 变量。
7.  检查 `beanClass` 是否是 FactoryBean 类型的子类，如果是，则根据是否为工厂引用来判断返回 bean 类型还是 FactoryBean 类型。
    
     *  如果不是 FactoryBean 类型，则通过调用 `getTypeForFactoryBean()` 方法获取 FactoryBean 创建的对象类型。
     *  如果是工厂引用，则直接返回 `beanClass`，表示返回的是 FactoryBean 类型。
8.  如果以上条件都不满足，则根据是否为工厂引用来判断返回 bean 类型还是 null 值。

@Override
    	@Nullable
    	public Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException {
    		String beanName = transformedBeanName(name);
    
    		// Check manually registered singletons.
    		Object beanInstance = getSingleton(beanName, false);
    		if (beanInstance != null && beanInstance.getClass() != NullBean.class) {
    			if (beanInstance instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) {
    				return getTypeForFactoryBean((FactoryBean<?>) beanInstance);
    			}
    			else {
    				return beanInstance.getClass();
    			}
    		}
    
    		// No singleton instance found -> check bean definition.
    		BeanFactory parentBeanFactory = getParentBeanFactory();
    		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    			// No bean definition found in this factory -> delegate to parent.
    			return parentBeanFactory.getType(originalBeanName(name));
    		}
    
    		RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    
    		// Check decorated bean definition, if any: We assume it'll be easier
    		// to determine the decorated bean's type than the proxy's type.
    		BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
    		if (dbd != null && !BeanFactoryUtils.isFactoryDereference(name)) {
    			RootBeanDefinition tbd = getMergedBeanDefinition(dbd.getBeanName(), dbd.getBeanDefinition(), mbd);
    			Class<?> targetClass = predictBeanType(dbd.getBeanName(), tbd);
    			if (targetClass != null && !FactoryBean.class.isAssignableFrom(targetClass)) {
    				return targetClass;
    			}
    		}
    
    		Class<?> beanClass = predictBeanType(beanName, mbd);
    
    		// Check bean class whether we're dealing with a FactoryBean.
    		if (beanClass != null && FactoryBean.class.isAssignableFrom(beanClass)) {
    			if (!BeanFactoryUtils.isFactoryDereference(name)) {
    				// If it's a FactoryBean, we want to look at what it creates, not at the factory class.
    				return getTypeForFactoryBean(beanName, mbd, allowFactoryBeanInit).resolve();
    			}
    			else {
    				return beanClass;
    			}
    		}
    		else {
    			return (!BeanFactoryUtils.isFactoryDereference(name) ? beanClass : null);
    		}
    	}

*  `AbstractBeanFactory` 类中的 `getTypeConverter()` 方法的具体实现：

1.  首先，尝试获取自定义类型转换器 `customConverter`。
2.  如果存在自定义类型转换器，则直接返回该转换器。
3.  如果不存在自定义类型转换器，则创建一个默认的类型转换器 `SimpleTypeConverter`。
4.  为默认类型转换器设置转换服务 `ConversionService`，通过调用 `getConversionService()` 方法获取转换服务。
5.  注册自定义编辑器（custom editors）到类型转换器，通过调用 `registerCustomEditors()` 方法实现。
6.  最后，返回创建的默认类型转换器 `typeConverter`。

@Override
    	public TypeConverter getTypeConverter() {
    		TypeConverter customConverter = getCustomTypeConverter();
    		if (customConverter != null) {
    			return customConverter;
    		}
    		else {
    			// Build default TypeConverter, registering custom editors.
    			SimpleTypeConverter typeConverter = new SimpleTypeConverter();
    			typeConverter.setConversionService(getConversionService());
    			registerCustomEditors(typeConverter);
    			return typeConverter;
    		}
    	}

*  `AbstractBeanFactory` 类中的 `resolveEmbeddedValue(String value)` 方法的具体实现：

1.  首先，检查传入的 `value` 参数是否为 null，如果为 null，则直接返回 null。
2.  将 `value` 赋值给 `result` 变量，用于存储解析后的结果。
3.  遍历内部的嵌入值解析器列表 `embeddedValueResolvers` 中的每个解析器 `resolver`，依次对 `result` 进行解析。
4.  对每个解析器 `resolver`，调用它的 `resolveStringValue()` 方法对 `result` 进行解析，得到新的解析结果并赋值给 `result`。
5.  如果解析结果 `result` 为 null，则直接返回 null。
6.  最后，返回解析后的结果 `result`。

@Override
    	@Nullable
    	public String resolveEmbeddedValue(@Nullable String value) {
    		if (value == null) {
    			return null;
    		}
    		String result = value;
    		for (StringValueResolver resolver : this.embeddedValueResolvers) {
    			result = resolver.resolveStringValue(result);
    			if (result == null) {
    				return null;
    			}
    		}
    		return result;
    	}

*  `AbstractBeanFactory` 类中的 `getBeanPostProcessorCache()` 方法的具体实现：

1.  首先，尝试获取已存在的 Bean 后置处理器缓存 `bpCache`。
2.  如果 `bpCache` 为 null，则说明缓存为空，需要重新构建。
3.  创建一个新的 Bean 后置处理器缓存对象 `BeanPostProcessorCache`。
4.  遍历当前 Bean 后置处理器列表 `beanPostProcessors` 中的每个后置处理器 `bp`。
5.  对于实现了 `InstantiationAwareBeanPostProcessor` 接口的后置处理器 `bp`，将其添加到缓存的 `instantiationAware` 列表中，并判断是否还实现了 `SmartInstantiationAwareBeanPostProcessor` 接口，如果是，则将其也添加到缓存的 `smartInstantiationAware` 列表中。
6.  对于实现了 `DestructionAwareBeanPostProcessor` 接口的后置处理器 `bp`，将其添加到缓存的 `destructionAware` 列表中。
7.  对于实现了 `MergedBeanDefinitionPostProcessor` 接口的后置处理器 `bp`，将其添加到缓存的 `mergedDefinition` 列表中。
8.  将构建好的缓存对象赋值给成员变量 `this.beanPostProcessorCache`。
9.  返回缓存对象 `bpCache`。

BeanPostProcessorCache getBeanPostProcessorCache() {
    		BeanPostProcessorCache bpCache = this.beanPostProcessorCache;
    		if (bpCache == null) {
    			bpCache = new BeanPostProcessorCache();
    			for (BeanPostProcessor bp : this.beanPostProcessors) {
    				if (bp instanceof InstantiationAwareBeanPostProcessor) {
    					bpCache.instantiationAware.add((InstantiationAwareBeanPostProcessor) bp);
    					if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
    						bpCache.smartInstantiationAware.add((SmartInstantiationAwareBeanPostProcessor) bp);
    					}
    				}
    				if (bp instanceof DestructionAwareBeanPostProcessor) {
    					bpCache.destructionAware.add((DestructionAwareBeanPostProcessor) bp);
    				}
    				if (bp instanceof MergedBeanDefinitionPostProcessor) {
    					bpCache.mergedDefinition.add((MergedBeanDefinitionPostProcessor) bp);
    				}
    			}
    			this.beanPostProcessorCache = bpCache;
    		}
    		return bpCache;
    	}

*  `AbstractBeanFactory` 类中的 `isFactoryBean(String name)` 方法的具体实现：

1.  首先，将传入的 bean 名称转换为规范化的 bean 名称（如果存在别名）。
2.  尝试从单例缓存中获取 bean 的实例。如果能够获取到实例，则判断该实例是否为 FactoryBean 的实现，若是则返回 true，否则返回 false。
3.  如果单例缓存中不存在 bean 实例，则进行下一步操作。
4.  首先判断当前工厂中是否包含指定名称的 bean 定义。如果不包含，并且父工厂是可配置的 Bean 工厂，则将检查委托给父工厂的 `isFactoryBean(String name)` 方法。
5.  如果包含了当前工厂中的 bean 定义，将调用 `isFactoryBean(String beanName, RootBeanDefinition bd)` 方法来进行判断。
6.  在 `isFactoryBean(String beanName, RootBeanDefinition bd)` 方法中，会根据合并后的 bean 定义来判断是否是 FactoryBean 的实现。如果合并后的 bean 定义指定了 `factoryBeanName` 属性，则表明该 bean 定义是 FactoryBean 的实现，返回 true；否则，返回 false。
7.  如果上述步骤都无法确定给定名称的 bean 是否为 FactoryBean 的实现，则抛出 NoSuchBeanDefinitionException 异常。

@Override
    	public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {
    		String beanName = transformedBeanName(name);
    		Object beanInstance = getSingleton(beanName, false);
    		if (beanInstance != null) {
    			return (beanInstance instanceof FactoryBean);
    		}
    		// No singleton instance found -> check bean definition.
    		if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
    			// No bean definition found in this factory -> delegate to parent.
    			return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);
    		}
    		return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));
    	}

*  `AbstractBeanFactory` 类中的 `destroyBean(String beanName, Object bean, RootBeanDefinition mbd)` 方法的具体实现：

1.  首先，通过 `DisposableBeanAdapter` 类来包装 bean 实例，并提供必要的信息，如 bean 名称、合并的 bean 定义、后置处理器缓存等。
2.  创建 `DisposableBeanAdapter` 对象时，会传入相应的参数，如 bean 实例、bean 名称、合并的 bean 定义、销毁感知的标志以及访问控制上下文。
3.  最后，调用 `DisposableBeanAdapter` 的 `destroy()` 方法来执行销毁逻辑。`DisposableBeanAdapter` 会首先调用所有 `DestructionAwareBeanPostProcessor` 的 `postProcessBeforeDestruction()` 方法对 bean 进行预处理，然后再调用 bean 自身实现 `DisposableBean` 接口的 `destroy()` 方法进行销毁。
4.  在销毁过程中，可以触发各种清理操作，如资源释放、销毁相关的对象等。

在默认情况下，Spring 容器并不会自动销毁作用域为单例的 bean 实例，而仅对作用域为原型的 bean 实例执行销毁操作。当容器关闭时，会触发单例 bean 的销毁。如果需要显式销毁单例 bean，可以通过配置 `destroy-method` 或实现 `DisposableBean` 接口来实现。

protected void destroyBean(String beanName, Object bean, RootBeanDefinition mbd) {
    		new DisposableBeanAdapter(
    				bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, getAccessControlContext()).destroy();
    	}

*  `AbstractBeanFactory` 类中的 `createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)` 方法的抽象声明：

该方法用于根据给定的合并的 bean 定义（和参数）创建一个 bean 实例。如果是子定义，则 bean 定义已经与父定义合并。 在实际创建 bean 时，所有的 bean 检索方法都会委托给这个方法。

具体的实现逻辑由具体的 bean 工厂实现类负责实现。

/**
    	 * Create a bean instance for the given merged bean definition (and arguments).
    	 * The bean definition will already have been merged with the parent definition
    	 * in case of a child definition.
    	 * <p>All bean retrieval methods delegate to this method for actual bean creation.
    	 * @param beanName the name of the bean
    	 * @param mbd the merged bean definition for the bean
    	 * @param args explicit arguments to use for constructor or factory method invocation
    	 * @return a new instance of the bean
    	 * @throws BeanCreationException if the bean could not be created
    	 */
    	protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    			throws BeanCreationException;

AbstractBeanFactory

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 AbstractBeanFactory

相关 AbstractBeanFactory和AbstractAutowireCapableBeanFactory的作用和区别