AbstractBeanFactory
- 这是一个抽象基类，用于实现{@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 propertyEditorRegistrars = new LinkedHashSet<>(4); - 这是一个用于注册自定义PropertyEditor的属性映射，可以将其应用于此工厂中的所有bean。PropertyEditor用于将字符串转换为特定类型的属性值。通过使用自定义的PropertyEditor，可以为特定的属性类型提供自定义的转换逻辑。这个属性是一个Map映射，其中键是属性类型的Class对象，值是对应的自定义PropertyEditor的Class对象。初始化时使用HashMap，并设置容量为4。
private final Map, Class> customEditors = new HashMap<>(4); typeConverter字段用于指定在Spring应用程序中处理类型转换的自定义TypeConverter。它允许您覆盖默认的PropertyEditor机制。- 类型转换是将一个值从一种数据类型转换为另一种类型的过程。在Spring应用程序中，通常在将请求参数绑定到方法参数或从配置文件转换属性值时进行类型转换。
- 默认情况下，Spring使用
PropertyEditor来执行类型转换。但是，您可以提供自己的TypeConverter接口实现，并将其设置为typeConverter属性，以自定义类型转换过程。
@Nullable
private TypeConverter typeConverter;- 这是一个String解析器列表，用于处理注解属性值中的字符串。它存储多个StringValueResolver对象，可以将占位符或表达式解析为相应的值。这个列表是线程安全的，可以在并发环境中使用。
private final List embeddedValueResolvers = new CopyOnWriteArrayList<>(); - BeanPostProcessorCacheAwareList是一个特殊的实现类，实现了List接口，并具有缓存功能。它可以在使用BeanPostProcessor时提供更高的性能和效率。
- 通过对beanPostProcessors列表添加自定义的BeanPostProcessor对象，可以在Spring应用程序中对Bean进行一系列的定制化处理，例如修改属性值、注册事件监听器、代理Bean等。
private final List 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 getBean(String name, Class requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
} AbstractBeanFactory 类中doGetBean()方法做了以下工作：
- 获取转换后的 bean 名称。
- 首先检查单例缓存中是否存在手动注册的单例实例。如果存在且没有指定参数 args，则直接返回该实例。
- 如果正在创建该原型 bean 实例，则抛出
BeanCurrentlyInCreationException 异常，以避免循环引用。 - 检查当前工厂中是否存在该 bean 的定义。如果不存在，则查找父级 BeanFactory 并委托它去获取该 bean。
- 如果不仅用于类型检查（typeCheckOnly 为 false），则将该 bean 标记为已创建。
- 创建一个 StartupStep，记录 bean 的实例化过程。
- 根据 requiredType 获取合并后的 RootBeanDefinition，并进行相关的检查。
- 确保初始化当前 bean 依赖的所有 beans。
- 根据 BeanDefinition 的作用域，创建对应类型的 bean 实例，并将其放入合适的容器中（单例实例放入 singletonObjects 容器，原型实例不缓存，作用域实例放入相应的作用域容器）。
- 将 bean 实例返回，根据需要进行类型适配。
protected T doGetBean(
String name, @Nullable Class 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()做了以下工作：
- 检查所需类型是否与实际 bean 实例的类型匹配。
- 如果所需类型不为空且与实际 bean 实例的类型不匹配，则尝试进行类型转换。
- 如果类型转换失败，则抛出
BeanNotOfRequiredTypeException 异常。 - 将转换后的 bean 实例返回。
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() 方法做了以下工作：
- 获取转换后的 bean 名称。
- 如果单例缓存或者 Bean 定义中包含该 bean 名称，则返回 true。
- 如果名称是一个工厂引用，则检查是否是 FactoryBean。
- 如果找不到该 bean 名称，则检查父级 BeanFactory 中是否存在对应的 bean。
- 如果存在父级 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() 方法的实现：
- 获取转换后的 bean 名称。
- 如果单例缓存中存在该 bean 实例，首先检查该实例是否是一个 FactoryBean。如果是 FactoryBean，则根据是否是工厂引用（以
& 开头）或 FactoryBean 自身是否是单例来判断返回结果；如果不是 FactoryBean，则根据是否是工厂引用来判断返回结果。 - 如果找不到该 bean 名称，则检查父级 BeanFactory 中是否存在对应的 bean 定义，并返回父级 BeanFactory 的结果。
- 如果该 bean 定义标识为单例，再次检查是否是 FactoryBean。如果是 FactoryBean，则根据是否是工厂引用来判断返回结果；如果不是 FactoryBean，则返回是否是工厂引用的结果。
- 如果该 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() 方法的实现：
- 获取转换后的 bean 名称。
- 检查父级 BeanFactory 中是否存在对应的 bean 定义，如果存在，则委托给父级 BeanFactory 来判断该 bean 是否是原型对象。
- 如果在当前 BeanFactory 中找到了 bean 定义，则根据 merged bean 定义信息判断该 bean 是否是原型对象。如果是原型对象，并且该 bean 不是一个工厂引用或 FactoryBean 对象，则返回 true。
- 如果该 bean 是 FactoryBean 对象，并且不是一个工厂引用（以
& 开头），则根据 FactoryBean 的类型和 isSingleton() 方法来判断是否是原型对象。 - 如果以上条件都不满足，则返回 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) () ->
((fb instanceof SmartFactoryBean && ((SmartFactoryBean) fb).isPrototype()) ||
!fb.isSingleton()),
getAccessControlContext());
}
else {
return ((fb instanceof SmartFactoryBean && ((SmartFactoryBean) fb).isPrototype()) ||
!fb.isSingleton());
}
}
else {
return false;
}
} -
AbstractBeanFactory 类中的isTypeMatch() 方法：
- 首先，根据给定的
name 参数获取对应的 bean 的名称，并进行相关的转换和处理。 - 判断是否是 FactoryDereference（工厂引用），即检查
name 是否是以& 开头的。 - 检查手动注册的单例 bean 是否存在并对其类型进行判断。如果单例 bean 是
FactoryBean 对象，则根据isFactoryDereference 来判断是否与指定的typeToMatch 匹配。如果单例 bean 不是FactoryBean，则通过直接比较类型来判断。如果类型匹配，则返回 true。 - 如果存在单例 bean 实例但未进行类型匹配，则根据是否持有泛型信息和是否包含对应的 bean 定义来判断。
- 如果以上逻辑都不满足，则继续后面的判断。
- 如果存在单例 bean 实例但没有对应的 bean 定义（即注册了空实例），则返回 false。
- 如果有父级
BeanFactory 并且当前BeanFactory 中不包含与指定的name 对应的 bean 定义，则将匹配操作委托给父级BeanFactory。 - 否则，根据
name 参数获取与其对应的合并后的 bean 定义信息和装饰 bean 定义信息。 - 设置要进行匹配的类型数组，并在需要时预测 bean 的类型。
- 根据预测的类型和其他信息进行进一步的类型匹配判断。如果能够获取到 bean 的具体类型信息，则通过
typeToMatch 的isAssignableFrom() 方法判断是否匹配。若无法获取具体类型信息，则返回 false。 - 最后，根据匹配结果返回相应的布尔值。
/**
* 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) 方法的具体实现：
- 首先，将给定的
name 参数进行转换处理，得到对应的 bean 名称beanName。 - 检查手动注册的单例 bean 是否存在，并获取其实例对象。
- 如果单例实例不为null且类型不是
NullBean，则执行以下判断：- 如果单例实例是
FactoryBean类型，且不是工厂引用，则返回通过调用getTypeForFactoryBean()方法获取的 bean 类型。 - 否则，直接返回单例实例的类型。
- 如果单例实例是
- 如果单例实例不为null且类型不是
- 如果没有找到单例实例，则检查是否有父级
BeanFactory 并且当前BeanFactory 中不包含与beanName 参数对应的 bean 定义。- 如果满足条件，将调用父级
BeanFactory 的getType() 方法获取 bean 类型。
- 如果满足条件，将调用父级
- 如果以上条件都不满足，则获取合并后的本地 bean 定义信息
mbd。 - 检查是否有装饰的 bean 定义
dbd，如果存在且不是工厂引用，则预测装饰的 bean 的类型targetClass。- 如果预测到装饰的 bean 的类型，并且不是 FactoryBean 类型，则返回预测到的类型。
- 调用
predictBeanType() 方法预测 bean 类型，并将结果赋值给beanClass 变量。 - 检查
beanClass 是否是 FactoryBean 类型的子类，如果是，则根据是否为工厂引用来判断返回 bean 类型还是 FactoryBean 类型。- 如果不是 FactoryBean 类型，则通过调用
getTypeForFactoryBean() 方法获取 FactoryBean 创建的对象类型。 - 如果是工厂引用，则直接返回
beanClass，表示返回的是 FactoryBean 类型。
- 如果不是 FactoryBean 类型，则通过调用
- 如果以上条件都不满足，则根据是否为工厂引用来判断返回 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() 方法的具体实现：
- 首先，尝试获取自定义类型转换器
customConverter。 - 如果存在自定义类型转换器，则直接返回该转换器。
- 如果不存在自定义类型转换器，则创建一个默认的类型转换器
SimpleTypeConverter。 - 为默认类型转换器设置转换服务
ConversionService，通过调用getConversionService() 方法获取转换服务。 - 注册自定义编辑器（custom editors）到类型转换器，通过调用
registerCustomEditors() 方法实现。 - 最后，返回创建的默认类型转换器
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) 方法的具体实现：
- 首先，检查传入的
value 参数是否为 null，如果为 null，则直接返回 null。 - 将
value 赋值给result 变量，用于存储解析后的结果。 - 遍历内部的嵌入值解析器列表
embeddedValueResolvers 中的每个解析器resolver，依次对result 进行解析。 - 对每个解析器
resolver，调用它的resolveStringValue() 方法对result 进行解析，得到新的解析结果并赋值给result。 - 如果解析结果
result 为 null，则直接返回 null。 - 最后，返回解析后的结果
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() 方法的具体实现：
- 首先，尝试获取已存在的 Bean 后置处理器缓存
bpCache。 - 如果
bpCache 为 null，则说明缓存为空，需要重新构建。 - 创建一个新的 Bean 后置处理器缓存对象
BeanPostProcessorCache。 - 遍历当前 Bean 后置处理器列表
beanPostProcessors 中的每个后置处理器bp。 - 对于实现了
InstantiationAwareBeanPostProcessor 接口的后置处理器bp，将其添加到缓存的instantiationAware 列表中，并判断是否还实现了SmartInstantiationAwareBeanPostProcessor 接口，如果是，则将其也添加到缓存的smartInstantiationAware 列表中。 - 对于实现了
DestructionAwareBeanPostProcessor 接口的后置处理器bp，将其添加到缓存的destructionAware 列表中。 - 对于实现了
MergedBeanDefinitionPostProcessor 接口的后置处理器bp，将其添加到缓存的mergedDefinition 列表中。 - 将构建好的缓存对象赋值给成员变量
this.beanPostProcessorCache。 - 返回缓存对象
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) 方法的具体实现：
- 首先，将传入的 bean 名称转换为规范化的 bean 名称（如果存在别名）。
- 尝试从单例缓存中获取 bean 的实例。如果能够获取到实例，则判断该实例是否为 FactoryBean 的实现，若是则返回 true，否则返回 false。
- 如果单例缓存中不存在 bean 实例，则进行下一步操作。
- 首先判断当前工厂中是否包含指定名称的 bean 定义。如果不包含，并且父工厂是可配置的 Bean 工厂，则将检查委托给父工厂的
isFactoryBean(String name) 方法。 - 如果包含了当前工厂中的 bean 定义，将调用
isFactoryBean(String beanName, RootBeanDefinition bd) 方法来进行判断。 - 在
isFactoryBean(String beanName, RootBeanDefinition bd) 方法中，会根据合并后的 bean 定义来判断是否是 FactoryBean 的实现。如果合并后的 bean 定义指定了factoryBeanName 属性，则表明该 bean 定义是 FactoryBean 的实现，返回 true；否则，返回 false。 - 如果上述步骤都无法确定给定名称的 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) 方法的具体实现：
-
首先，通过
DisposableBeanAdapter 类来包装 bean 实例，并提供必要的信息，如 bean 名称、合并的 bean 定义、后置处理器缓存等。 -
创建
DisposableBeanAdapter 对象时，会传入相应的参数，如 bean 实例、bean 名称、合并的 bean 定义、销毁感知的标志以及访问控制上下文。 -
最后，调用
DisposableBeanAdapter 的destroy() 方法来执行销毁逻辑。DisposableBeanAdapter 会首先调用所有DestructionAwareBeanPostProcessor 的postProcessBeforeDestruction() 方法对 bean 进行预处理，然后再调用 bean 自身实现DisposableBean 接口的destroy() 方法进行销毁。 -
在销毁过程中，可以触发各种清理操作，如资源释放、销毁相关的对象等。
在默认情况下，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.
* 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;