• Spring源码深度解析：七、bean的加载① - doGetBean概述

    一、前言

    文章目录：Spring源码深度解析：文章目录

    我们先通过getBean()流程图，来了解Spring的getBean()方法的工作流程，接着根据这个工作流程一步一步的阅读源码
    在这里插入图片描述

    getBean()方法是spring ioc的核心，阅读getBean()方法的源码也是理解spring容器工作原理所必须要做的事情！
    我们先来看一下getBean()方法，getBean()的具体实现逻辑在AbstractBeanFactory#doGetBean()方法中。

    文章目录：Spring源码分析：文章目录

    二、doGetBean() 入口

    在 Spring源码深度解析：三、容器的刷新 - refresh() 文章中分析了Spring容器的刷新过程。我们知道了 Spring 在容器刷新的后期 通过调用AbstractApplicationContext#finishBeanFactoryInitialization()方法来实例化了所有的非惰性bean。在这里面就通过beanFactory.preInstantiateSingletons();调用了一个非常关键的方法 AbstractBeanFactory#getBean(String name)，而其实际上调用的是 AbstractBeanFactory#doGetBean()方法

    AbstractApplicationContext#finishBeanFactoryInitialization()

    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// Initialize conversion service for this context.
		// 1. 对 ConversionService 的设置
		// 如果 BeanFactory 中加载了beanName 为 ConversionService 的bean，并且类型是 ConversionService。那么将其设置为 conversionService
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		// Register a default embedded value resolver if no bean post-processor
		// (such as a PropertyPlaceholderConfigurer bean) registered any before:
		// at this point, primarily for resolution in annotation attribute values.
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		// 开始调用 getBean 方法初始化LoadTimeWeaverAware
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// Allow for caching all bean definition metadata, not expecting further changes.
		// 2. 冻结所有的bean定义，说明注册的bean定义将不被修改或任何进一步的处理
		beanFactory.freezeConfiguration();

		// Instantiate all remaining (non-lazy-init) singletons.
		// 3. 初始化剩下的非惰性单实例
		beanFactory.preInstantiateSingletons();
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    ConfigurableListableBeanFactory#preInstantiateSingletons()

    	public void preInstantiateSingletons() throws BeansException {
		if (logger.isDebugEnabled()) {
			logger.debug("Pre-instantiating singletons in " + this);
		}

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
		// 获取所有 beanName
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		for (String beanName : beanNames) {
			// 获取合并后的 BeanDefinition
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			// 非抽象 && 单例 && 非惰性加载
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				// 判断是否是  FactoryBean 类型
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					// 如果是 Factorybean 则 拼接 & 前缀获取bean
					if (bean instanceof FactoryBean) {
						FactoryBean<?> factory = (FactoryBean<?>) bean;
						boolean isEagerInit;
						// 判断是否要立即初始化Bean。对于 FactoryBean，可能并不需要立即初始化其getObject 方法代理的对象。
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged(
									(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						// 如果需要立即初始化，则初始化bean
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {
					// 非 FactoryBean 类型直接获取bean
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		// 触发所有适用bean的初始化后回调。 这里实际上是触发 SmartInitializingSingleton#afterSingletonsInstantiated 方法
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
						smartSingleton.afterSingletonsInstantiated();
						return null;
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64

    AbstractBeanFactory#getBean()

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

    • 1
    • 2
    • 3

    如果说，Spring中，Bean的发现是在ConfigurationClassPostProcessor中进行的。那么Bean的创建就是在doGetBean方法中进行的。doGetBean完成了单例Bean的完整创建过程，包括bean的创建，BeanPostProcessor的方法调用、init-method等方法的调用、Aware等接口的实现。
    下面，我们开始来分析这个doGetBean。

    关于Bean 的加载过程，AbstractApplicationContext#finishBeanFactoryInitialization()经过几次跳转，最终会跳转到AbstractBeanFactory#doGetBean()方法。每个bean的创建都会经历此方法，所以本文的主要内容是分析AbstractBeanFactory#doGetBean()

    三、DefaultListableBeanFactory

    需要强调的是，本文中调用doGetBean方法的是AbstractBeanFactory的子类DefaultListableBeanFactory。如下图
    在这里插入图片描述
    DefaultListableBeanFactory结构图如下：
    在这里插入图片描述

    1. DefaultSingletonBeanRegistry

    在这里我们只需要知道DefaultListableBeanFactory继承了DefaultSingletonBeanRegistry类，拥有了DefaultSingletonBeanRegistry一系列的 集合类型来保存Bean相关信息。

    大体如下，其中我们主要只需要关注前四个即可：

    public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

	/** Cache of singleton objects: bean name --> bean instance */
	//	用于保存BeanName和创建bean实例之间的关系，即缓存bean。 beanname -> instance
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

	/** Cache of singleton factories: bean name --> ObjectFactory */
	// 用于保存BeanName和常见bean的工厂之间的关系。beanname-> ObjectFactory
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

	/** Cache of early singleton objects: bean name --> bean instance */
	// 也是保存BeanName和创建bean实例之间的关系，与singletonObjects 不同的是，如果一个单例bean被保存在此，则当bean还在创建过程中(比如 A类中有B类属性，当创建A类时发现需要先创建B类，这时候Spring又跑去创建B类，A类就会添加到该集合中，表示正在创建)，就可以通过getBean方法获取到了，其目的是用来检测循环引用。
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

	/** Set of registered singletons, containing the bean names in registration order */
	// 用来保存当前所有已经注册的bean
	private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

	/** Names of beans that are currently in creation */
	// 用来保存当前正在创建的Bean。也是为了解决循环依赖的问题
	private final Set<String> singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));

	/** Names of beans currently excluded from in creation checks */
	// 用来保存当前从创建检查中排除的bean名称
	private final Set<String> inCreationCheckExclusions =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));

	/** List of suppressed Exceptions, available for associating related causes */
	// 初始化过程中的异常列表
	@Nullable
	private Set<Exception> suppressedExceptions;

	/** Flag that indicates whether we're currently within destroySingletons */
	// 标志是否在销毁BeanFactory过程中
	private boolean singletonsCurrentlyInDestruction = false;

	/** Disposable bean instances: bean name --> disposable instance */
	// 一次性bean实例：beanName -> 一次性实例。暂未明白
	private final Map<String, Object> disposableBeans = new LinkedHashMap<>();

	/** Map between containing bean names: bean name --> Set of bean names that the bean contains */
	// 包含的Bean名称之间的映射：BeanName  -> Bean包含的BeanName集合
	private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);

	/** Map between dependent bean names: bean name --> Set of dependent bean names */
	// bean dependent(依赖的集合) : beanName -> 依赖该beanName 的 bean，即 key代表的bean 被value 所依赖
	private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);

	/** Map between depending bean names: bean name --> Set of bean names for the bean's dependencies */
	// bean 被哪些bean依赖 ：  beanName -> beanName 所依赖的 bean。即 key 依赖于value这些bean
	private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53

    1.1 关键缓存

    下面挑出来几个关键缓存集合来描述：

    • singletonObjects ：ConcurrentHashMap。最简单最重要的缓存Map。保存关系是 beanName ：bean实例关系。单例的bean在创建完成后都会保存在 singletonObjects 中，后续使用直接从singletonObjects中获取。
    • singletonFactories ：HashMap。这是为了解决循环依赖问题，用于提前暴露对象，保存形式是 beanName : ObjectFactory。
    • earlySingletonObjects ：HashMap。这也是为了解决循环依赖问题。和 singletonFactories互斥。因为singletonFactories保存的是ObjectFactory。而earlySingletonObjects个人认为是singletonFactories更进一步的缓存，保存的是ObjectFactory#getObject()的结果。
    • registeredSingletons ：LinkedHashSet，用于保存注册过的beanName，
    • singletonsCurrentlyInCreation ： 保存当前正在创建的bean。当一个bean开始创建时将保存其beanName，创建完成后将其移除
    • dependentBeanMap ：保存bean的依赖关系，比如A对象依赖于 B对象，会出现 B ：A。即保存的是key 被value依赖
    • dependenciesForBeanMap ：保存bean的依赖关系，不过和dependentBeanMap 反了过来。A对象依赖于 B对象，会出现 A ：B。保存的是key 依赖于 value

    我们拿一个简单的场景解释一下singletonFactories和earlySingletonObjects的关系 。
    下面的代码是DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean) 。我们可以看到其判断逻辑，

    锁定 singletonObjects，毕竟要操作singletonObjects

    从singletonFactories中获取ObjectFactory缓存

    如果存在ObjectFactory缓存，则更进一步提取ObjectFactory#getObject()的singletonObject对象。将singletonObject保存到earlySingletonObjects缓存中，同时从singletonFactories中移除。

    	@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				singletonObject = this.earlySingletonObjects.get(beanName);
				if (singletonObject == null && allowEarlyReference) {
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						singletonObject = singletonFactory.getObject();
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    1.2 图解

    补上一张图，来看一看 A,B循环依赖 singletonFactories 和 earlySingletonObjects 的变化
    在这里插入图片描述
    个人推测 ： 在创建过程中会被添加到singletonFactories中，但当bean被循环依赖时会被添加到earlySingletonObjects中。也即是说earlySingletonObjects中的bean都是被循环依赖的。

    2. BeanDefinition

    这里简单介绍一下，顾名思义，BeanDefinition是bean的信息，一个BeanDefinition 描述和定义了创建一个bean需要的所有信息，属性，构造函数参数以及访问它们的方法。还有其他一些信息，比如这些定义来源自哪个类等等。

    对于XML配置方式的Spring方式来说，BeanDefinition是配置文件 < bean >元素标签在容器中的内容表示形式。元素标签拥有class、scope、lazy-init等配置属性，BeanDefinition则提供了相应的beanClass、scope、lazyinit属性，BeanDefinition和 < bean >中的属性是一一对应的。其中RootBeanDefinition是最常用的实现类，一般对应< bean >元素标签。

    类似下图的定义：
    在这里插入图片描述
    需要注意的是 BeanDefinition 是一个接口，在Spring 中存在多种实现，具体请参考：
    https://blog.csdn.net/andy_zhang2007/article/details/85381148
    https://www.cnblogs.com/loongk/p/12262101.html

    四、doGetBean() 概述

    下面我们开始进入正题，进行 AbstractBeanFactory#doGetBean()的内容分析。这个方法是一切的核心(Bean的创建过程也是在这个方法中完成)。首先我们先来整体过一遍方法代码。后面将会对一些关键点进行详细解释。

    @SuppressWarnings("unchecked")
	protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {

		// 1. 提取出对应的beanName。该方法将doGetBean的参数name转换成容器中真实的beanName(获取容器中真实beanName)(传递过来的name有三种可能，一个是原始的beanName，一个是加了&的，一个是别名。所以我们要统一将其转换 )
		String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		// 2. 尝试从缓存中获取之前被实例化过了的单例bean或从singletonFacotries中的ObjectFactory中获取。
		Object sharedInstance = getSingleton(beanName);
		// 如果之前已经创建过该单例bean,并且args为空(单例 bean不可以用这个args,它是为多例设计的)
		if (sharedInstance != null && args == null) {
			if (logger.isDebugEnabled()) {
				// 如果Bean还在创建中，则说明是循环依赖.
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			// 3. 返回对应的实例，如果是普通的bean，直接返回,如果是factoryBean,则返回它的getObject. 这一步主要还是针对FactoryBean的处理。
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}
		// 如果scope->prototype,singleton.但是在缓存中无法找到
		else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			// 4. 先根据缓存判断一下当前的bean是否正在被创建，如果是的话表示依赖循环了;只有单例情况才会尝试解决循环依赖，原型模式直接抛出异常。因为原型模式无法解决循环依赖问题。
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// Check if bean definition exists in this factory.
			// 5. 获取父级的BeanFactory
			BeanFactory parentBeanFactory = getParentBeanFactory();
			// 如果在当前容器中无法找到指定名称的bean，此时递归去parentFactory查找.
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				// 递归到BeanFactory中检测,针对FactoryBean,将Bean的&重新拼上
				String nameToLookup = originalBeanName(name);
				// 如果parentBeanFactory属于AbstractBeanFactory实例
				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 {
					// No args -> delegate to standard getBean method.
					// 如果没有参数，委托父级容器根据指定名称和type进行查找
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}
			// 如果当前要获取的bean只是为了进行类型检查就标记bean已经被创建
			if (!typeCheckOnly) {
				// 这里是将 当前创建的beanName 保存到 alreadyCreated 集合中。alreadyCreated 中的bean表示当前bean已经创建了，在进行循环依赖判断的时候会使用
				markBeanAsCreated(beanName);
			}

			try {
				// 6. 将当前 beanName 的 BeanDefinition 和父类BeanDefinition 属性进行一个整合
				RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				// 对合并的BeanDefiniton进行检测，主要判断是否为abstract.
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				// 7. 寻找bean的依赖
				// 获取当前Bean所有依赖的Bean名称
				String[] dependsOn = mbd.getDependsOn();
				// 如果需要依赖，则递归实例化依赖bean
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						// 判断是否有循环依赖的情况 ： A依赖B，B依赖A
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						// 注册依赖信息，将依赖信息保存到 dependentBeanMap、dependenciesForBeanMap中
						registerDependentBean(dep, beanName);
						try {
							// 获取依赖的bean，这一步又回到了最初的getBean
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				// Create bean instance.
				// 8 针对不同的Scope 进行bean的创建
				// 实例化依赖的bean便可以实例化mdb本身了
				// 如果BeanDefiniton为单例
				if (mbd.isSingleton()) {
					// 匿名内部类，创建Bean实例对象,并且注册给所依赖的对象
					// 关键方法:单例类实例化的入口
					sharedInstance = getSingleton(beanName, () -> {
						try {
							// 创建单例bean的入口.
							// =============关键===============
							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.
							// 显性从单例缓存中删除bean实例.
							// 因为单例模式下为了解决循环依赖，可能留有残余的信息，此处进行销毁
							destroySingleton(beanName);
							throw ex;
						}
					});
					// 解决FactoryBean的问题
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

				else if (mbd.isPrototype()) {
					// It's a prototype -> create a new instance.
					// 原型模式的回调
					// 如果是原型模式，创建一个实例,在原型模式下，每次getBean都会产生一个新的实例
					Object prototypeInstance = null;
					try {
						// 保存当前线程正在创建的beanName 到 prototypesCurrentlyInCreation 中
						beforePrototypeCreation(beanName);
						// 直接创建bean
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						// 完成创建后，从 prototypesCurrentlyInCreation 中移除当前线程正在创建的beanName
						afterPrototypeCreation(beanName);
					}
					// 解决FactoryBean的问题
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				else {
					// 指定scope上实例化bean
					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, () -> {
							// 保存当前线程正在创建的beanName 到 prototypesCurrentlyInCreation 中
							beforePrototypeCreation(beanName);
							try {
								// 创建bean
								return createBean(beanName, mbd, args);
							}
							finally {
								// 移除当前线程正在创建的beanName 从 prototypesCurrentlyInCreation 中
								afterPrototypeCreation(beanName);
							}
						});
						//  解决FactoryBean的问题
						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
					catch (IllegalStateException ex) {
						throw new BeanCreationException(beanName,
								"Scope '" + scopeName + "' is not active for the current thread; consider " +
								"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
								ex);
					}
				}
			}
			catch (BeansException ex) {
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}

		// Check if required type matches the type of the actual bean instance.
		// 9 类型转换
		// 检查需要的类型是否符合bean 的实际类型
		if (requiredType != null && !requiredType.isInstance(bean)) {
			try {
				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
				if (convertedBean == null) {
					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
				}
				return convertedBean;
			}
			catch (TypeMismatchException ex) {
				if (logger.isDebugEnabled()) {
					logger.debug("Failed to convert bean '" + name + "' to required type '" +
							ClassUtils.getQualifiedName(requiredType) + "'", ex);
				}
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		return (T) bean;
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205

    综上所属，doGetBean的 大体流程如下：

    1. transformedBeanName(name)： 该方法将doGetBean的参数name转换成容器中真实的beanName(获取容器中真实beanName)(传递过来的name有三种可能，一个是原始的beanName，一个是加了&的，一个是别名。所以我们要统一将其转换 )
    2. getSingleton(beanName)： 尝试从单例缓存中获取 bean，主要是尝试从 singletonObjects 和 singletonFactories 中获取实例。（这一步中还使用了 earlySingletonObjects 来判断循环依赖的问题）
    3. getObjectForBeanInstance(sharedInstance, name, beanName, null)： 如果第二步获取到了bean，则会针对处理 FactoryBean 这种特殊情况，以获取到正确的bean。（因为Factorybean 的话可能需要将其 getObject 方法的返回值作为bean注入到容器中）。
    4. isPrototypeCurrentlyInCreation(beanName)： 如果第二步没有获取到bean，则会检测其原型模式下的循环依赖情况，如果原型模式下有循环依赖，则直接抛出异常，因为原型模式下无法解决循环依赖。
    5. getParentBeanFactory()： 如果第四步没有抛出异常，则会判断 当前BeanFactory 中是否包含该beanName 的定义信息，如果不包含，则会递归去 parentBeanFactory 中去寻找beanName的定义信息.
    6. getMergedLocalBeanDefinition(beanName)： 随后查询beanName 的 BeanDefinition 是否具有 父类的BeanDefinition， 如果有，则将 父类的一些属性和子类合并，形成一个新的BeanDefinition ： mdb
    7. mbd.getDependsOn()： 获取mdb中的 depends-on 属性，优先将依赖的bean创建，随后再创建当前bean。
    8. mbd.isSingleton()： 到这一步，则说明当前bean尚未创建，则会根据 singleton 或者 prototype 或其他逻辑，走不同的流程来创建bean
    9. getTypeConverter().convertIfNecessary(bean, requiredType)： 创建bean结束后，根据调用者需要的类型进行一个类型转换。比如调用者希望返回一个Integer，这里得到的结果却是String，则会进行一个类型的转换。

    五、 doGetBean() 详解

    1. 转换 beanName

    final String beanName = transformedBeanName(name);

    • 1

    这一步的目的是为了去除 beanName 的别名，获取bean的真正beanName（传递过来的name有三种可能，一个是原始的beanName，一个是加了&的，一个是别名。所以我们要统一将其转换）。

    这里的name传入的可能是bean的别名，或者是FactoryBean类型的bean。所以需要一系列的解析，解析包括

    1. 去除 FactoryBean 的修饰符。也就是说如果 name = “&name” 或者 name = “&&name” 这种多&& 情况也会去除& 使得 name = “name”。
    2. 取指定alias所表示的最终beanName。比如别名A指向B的bean，则会返回B。

    AbstractBeanFactory#transformedBeanName()

    protected String transformedBeanName(String name) {
		return canonicalName(BeanFactoryUtils.transformedBeanName(name));
	}

    • 1
    • 2
    • 3

    1.1 从别名中获取真正的beanName

    SimpleAliasRegistry#canonicalName(String name)

    /**
	 * Determine the raw name, resolving aliases to canonical names.
	 * @param name the user-specified name
	 * @return the transformed name
	 *
	 * 从别名中获取真正的beanName
	 */
	public String canonicalName(String name) {
		String canonicalName = name;
		// Handle aliasing...
		String resolvedName;
		do {
			// 从aliasMap 中获取到真实的beanName
			resolvedName = this.aliasMap.get(canonicalName);
			if (resolvedName != null) {
				canonicalName = resolvedName;
			}
		}
		while (resolvedName != null);
		return canonicalName;
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    1.2 判断beanName是否是以&开头，转化成真正的beanName

    BeanFactoryUtils#transformedBeanName(String name)

    	public static String transformedBeanName(String name) {
		Assert.notNull(name, "'name' must not be null");
		String beanName = name;
		// 如果不是以 & 开头直接返回
		while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
			//否则剪切到 开头的 & ，直至开头没有 &
			beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
		}
		return beanName;
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    2. 尝试从缓存中加载单例

    	Object sharedInstance = getSingleton(beanName);

    • 1

    对于单例Bean来说， Spring只会在同一容器中创建一次，并将创建好的Bean 实例保存到 singletonObjects中，下次再获取bean实例，直接从singletonObjects中获取。这一步的目的是从尝试从缓存中获取实例。需要注意的是，Spring为了解决循环依赖问题， 创建bean的原则是在不等bean创建完成就会将创建bean的ObjectFactory提早曝光加入到缓存中，一旦下一个bean创建时需要依赖上一个bean，则直接使用ObjectFactory。

    代码逻辑如下：

    1. 尝试从singletonObjects中获取Bean 实例。获取不到说明该bean尚未创建成功
    2. isSingletonCurrentlyInCreation返回 true，则说明当前bean 的创建过程存在循环依赖。下面的逻辑就是为了尝试解决循环依赖
    3. 尝试从earlySingletonObjects中获取，获取不到说明该bean并未在创建过程中。(为了解决循环依赖的问题)
    4. 当allowEarlyReference = true时，这个是针对循环引用的操作，是允许循环引用。
    5. 随后 从singletonFactories中加载ObjectFactory，并将结果保存到 earlySingletonObjects中，同时将singletonFactories中关于bean的定义移除。（earlySingletonObjects和singletonFactories互斥）

    这里我们看到
    singletonFactories的映射关系是 beanName : ObjectFactory
    earlySingletonObjects的映射关系是 beanName : ObjectFactory#getObject
    个人理解earlySingletonObjects是singletonFactories更进一步的缓存，所以二者互斥，相同的对象，一个缓存中存在即可。
    DefaultSingletonBeanRegistry#getSingleton(String beanName)

    	@Override
	@Nullable
	public Object getSingleton(String beanName) {
		// 第二个参数为是否允许立即加载,这里传入的是true
		return getSingleton(beanName, true);
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    DefaultSingletonBeanRegistry#getSingleton(String beanName, boolean allowEarlyReference)

    @Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		// 尝试从单例缓存(一级缓存) singletonObjects 中获取完整的Bean。
		Object singletonObject = this.singletonObjects.get(beanName);
		// 如果单例缓存(一级缓存)中没有对象，创建中的Bean的名字会被保存在singletonsCurrentlyInCreation中
		// 也就是说，当前所需要获取的bean是否是singleton的，并且处于创建中的形态
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			// 如果单例缓存中不存在该bean，则加锁进行接下来的处理
			// 这里作为锁还有一个原因是二级缓存和三级缓存都是HashMap，需要一个锁来控制这两个map的操作
			synchronized (this.singletonObjects) {
				// 尝试从二级缓存earlySingletonObjects中获取半成品的Bean, 则直接将singletonObject返回。
				// 二级缓存存储的是未对属性进行添加的Bean.
				singletonObject = this.earlySingletonObjects.get(beanName);
				// 如果还获取不到，并且allowEarlyReference为true，则表示可以进行循环引用
				if (singletonObject == null && allowEarlyReference) {
					// 从三级缓存singletonFactories这个ObjectFactory实例的缓存中尝试获取创建此Bean的单例工厂实例
					// ObjectFactory为用户定制(容器中的代理Bean),FactoryBean框架会进行特殊处理(自定义)
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						// 调用单例工厂的getObject方法获取对象实例
						singletonObject = singletonFactory.getObject();
						// 将实例放入二级缓存中.
						this.earlySingletonObjects.put(beanName, singletonObject);
						// 从三级缓存中删除
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    Spring默认支持循环依赖，在这个getSingleton()中，根据beanName去一级、二级、三级缓存中进行查找:

    • 尝试从一级缓存中查找完整的Bean实例，找到则直接返回.
    • 如果无法从一级缓存中查找，对一级缓存进行上锁，然后尝试从二级缓存中查找半成品的Bean.找到直接返回.
    • 从三级缓存中查找,找到则放入二级缓存，同时为了保证一个对象实例为单例，将该实例从第三级缓存中进行移除.

    3. 尝试从FactoryBean中获取对象

    	bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

    • 1

    当我们结束上一步之后，经过sharedInstance != null && args == null的判断后就会调用该方法。作为上一步获取到的结果 sharedInstance 。我们需要判断其是否是 FactoryBean 的 实现类，如果是，则需要将其getObject() 的结果注入。所以该方法的功能简单来说就是用来检测当前bean是否是FactoryBean类型的bean，如果是，则调用其getObject() 方法，并将其返回值作为bean。

    代码逻辑大体如下：

    1. 首先是在AbstractAutowireCapableBeanFactory#getObjectForBeanInstance中，添加依赖bean信息。随后跳转到AbstractBeanFactory#getObjectForBeanInstance中
    2. 判断程序是否想获取FactoryBean实例(beanName 是否以 & 开头)。如果是判断当前beanInstance是否是 FactoryBean。如果是则返回，否则抛出异常
    3. 如果不是想获取FactoryBean，那么就是想获取bean实例了。那么判断此时的beanInstance是普通的bean还是FactoryBean类型，如果是普通的bean则直接返回。
    4. 此时beanInstance必定是FactoryBean类型并且程序想获取bean实例。那么首先尝试从缓存factoryBeanObjectCache中获取。获取失败，则调用FactoryBean#getObject方法来获取bean实例。并且在允许调用后置方法的情况下(shouldPostProcess为true)，调用BeanPostProcessor#postProcessAfterInitialization()的方法。

    下面我们来看详细代码

    3.1 AbstractAutowireCapableBeanFactory#getObjectForBeanInstance()

    	@Override
	protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
		// 获取当前线程正在创建的bean。currentlyCreatedBean是一个ThreadLocal
		String currentlyCreatedBean = this.currentlyCreatedBean.get();
		// 如果当前线程正在创建其他bean，则说明currentlyCreatedBean的创建依赖于beanName。则去保存这个依赖关系
		if (currentlyCreatedBean != null) {
			// 注册依赖关系的bean
			registerDependentBean(beanName, currentlyCreatedBean);
		}

		return super.getObjectForBeanInstance(beanInstance, name, beanName, mbd);
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    DefaultSingletonBeanRegistry#registerDependentBean()

    	 /**
	 * 注册依赖关系的bean
	 */
	public void registerDependentBean(String beanName, String dependentBeanName) {
		// 获取真实的beanName
		String canonicalName = canonicalName(beanName);

		// 保存依赖关系。dependentBeanMap： key 被 value 依赖
		synchronized (this.dependentBeanMap) {
			Set<String> dependentBeans =
					this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
			if (!dependentBeans.add(dependentBeanName)) {
				return;
			}
		}
		// dependenciesForBeanMap : key 依赖于bean
		synchronized (this.dependenciesForBeanMap) {
			Set<String> dependenciesForBean =
					this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
			dependenciesForBean.add(canonicalName);
		}
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    这里我们可以知道其中有一个逻辑是判断当前线程是否存在创建中的currentlyCreatedBean，存在则说明currentlyCreatedBean依赖于正在创建的bean。因为对于bean的创建来说，如果发现当前bean依赖于其他bean，则会转向优先创建依赖的bean。

    3.2 AbstractBeanFactory#getObjectForBeanInstance()

    随后通过super.getObjectForBeanInstance(beanInstance, name, beanName, mbd); 调用了AbstractBeanFactory#getObjectForBeanInstance()

    protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

		// Don't let calling code try to dereference the factory if the bean isn't a factory.
		// 1. 检测name 是否是想获取 工厂类 (name 以 & 开头)
		if (BeanFactoryUtils.isFactoryDereference(name)) {
			if (beanInstance instanceof NullBean) {
				return beanInstance;
			}
			// 以&开头又不是FactoryBean实现类，则抛出异常
			if (!(beanInstance instanceof FactoryBean)) {
				throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
			}
		}

		// Now we have the bean instance, which may be a normal bean or a FactoryBean.
		// If it's a FactoryBean, we use it to create a bean instance, unless the
		// caller actually wants a reference to the factory.
		// 2. 此时bean可能是 FactoryBean 或者 普通的bean。判断如果 beanInstance 不是 FactoryBean而是普通的bean, 就直接返回
		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}

		// 3. 到这一步就可以确定，当前beanInstance 是FactoryBean，并且需要获取getObject() 的结果
		Object object = null;
		if (mbd == null) {
			object = getCachedObjectForFactoryBean(beanName);
		}
		if (object == null) {
			// Return bean instance from factory.
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			// Caches object obtained from FactoryBean if it is a singleton.
			// containsBeanDefinition 检测  beanDefinitionMap中也就是所有已经加载的类中检测是否定义beanName
			if (mbd == null && containsBeanDefinition(beanName)) {
				// 合并父类bean 定义的属性
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			// 4. 这一步中对FactoryBean进行了解析; 此处Spring使用了双重检测锁机制来创建FactoryBean.值得一读.
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43

    FactoryBeanRegistrySupport#getObjectFromFactoryBean()

    protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
		// 判断是否是单例模式 && singletonObjects 尚未缓存该bean(containsSingleton调用的是 singletonObjects)
		if (factory.isSingleton() && containsSingleton(beanName)) {
			// 上同步锁
			synchronized (getSingletonMutex()) {
				// 双重检测锁机制,先从缓存中获取，多线程下可能别的线程已完成该单例Bean的创建.
				Object object = this.factoryBeanObjectCache.get(beanName);
				if (object == null) {
					// 调用getObject工厂方法创建Bean实例
					object = doGetObjectFromFactoryBean(factory, beanName);
					// Only post-process and store if not put there already during getObject() call above
					// (e.g. because of circular reference processing triggered by custom getBean calls)
					// 如果在getObject期间别的线程异步进行了bean的创建,那么使用更早的版本,以保证单例
					// 为什么出现两次从缓存读取的操作，因为用户自定义的getObject可能会出现异步，所以这里需要再进行一次判断
					Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
					// 因为是单例模式，所以要保证变量的全局唯一。所以这里如果缓存中已经创建好了bean则替换为已经创建好的bean
					if (alreadyThere != null) {
						object = alreadyThere;
					}
					else {
						// Spring的内部类不会进入到这个方法，因为Spring不允许第三方框架通过后置处理器更改其内部类
						// 如果允许调用bean的后置处理器。因为这里是直接将bean创建返回了，如果要调用后置方法则只能在这里调用。
						if (shouldPostProcess) {
							// 该Bean实例是否有别的线程在尝试创建,但是未进行后置处理
							if (isSingletonCurrentlyInCreation(beanName)) {
								// Temporarily return non-post-processed object, not storing it yet..
								return object;
							}
							// 将beanName 添加到 singletonsCurrentlyInCreation 中缓存，表示当前bean正在创建中
							beforeSingletonCreation(beanName);
							try {
								// 触发BeanPostProcessor.第三方框架可以使用AOP来包装Bean实例
								// 调用了ObjectFactory的后置处理器。
								object = postProcessObjectFromFactoryBean(object, beanName);
							}
							catch (Throwable ex) {
								throw new BeanCreationException(beanName,
										"Post-processing of FactoryBean's singleton object failed", ex);
							}
							finally {
								// 将beanName 从 singletonsCurrentlyInCreation 中移除，表示当前bean已经创建结束
								afterSingletonCreation(beanName);
							}
						}
						// return this.singletonObjects.containsKey(beanName); 如果 singletonObjects缓存中存在当前beanName，则将其缓存到 factoryBeanObjectCache 中。
						if (containsSingleton(beanName)) {
							//  // 放入缓存中，证明单例已经创建完成了. 这里保存的是 beanName : FactoryBean
							this.factoryBeanObjectCache.put(beanName, object);
						}
					}
				}
				return object;
			}
		}
		else {
			// FactoryBean 非单例直接调用 getObject 方法
			Object object = doGetObjectFromFactoryBean(factory, beanName);
			// 如果允许调用后置方法，则调用postProcessObjectFromFactoryBean 方法
			if (shouldPostProcess) {
				try {
					object = postProcessObjectFromFactoryBean(object, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
				}
			}
			return object;
		}
	}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70

    4. 原型模式的依赖检查 - isPrototypeCurrentlyInCreation

    			// 4. 先根据缓存判断一下当前的bean是否正在被创建，如果是的话表示依赖循环了;只有单例情况才会尝试解决循环依赖，原型模式直接抛出异常。因为原型模式无法解决循环依赖问题。
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

    • 1
    • 2
    • 3
    • 4

    简而言之就是单例模式下才会尝试去解决循环依赖的问题，而原型模式则无法解决。也就是 isPrototypeCurrentlyInCreation返回true，则抛出异常。
    需要注意的是还有一个 方法是 判断单例模式的依赖检查 ： isSingletonCurrentlyInCreation

    5. 递归 parentBeanFactory

    这一步的逻辑比较简单，如下：

    1. 首先通过containsBeanDefinition(beanName)方法判断当前beanFactory中是否有bean的定义，如果有，皆大欢喜。直接进入下一步。
    2. 如果没有，且parentBeanFactory不为空，则会通过递归的方式，尝试从 parentBeanFactory中加载bean定义。
    // 5. 获取父级的BeanFactory
			BeanFactory parentBeanFactory = getParentBeanFactory();
			// 如果在当前容器中无法找到指定名称的bean，此时递归去parentFactory查找.
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				// 递归到BeanFactory中检测,针对FactoryBean,将Bean的&重新拼上
				String nameToLookup = originalBeanName(name);
				// 如果parentBeanFactory属于AbstractBeanFactory实例
				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 {
					// No args -> delegate to standard getBean method.
					// 如果没有参数，委托父级容器根据指定名称和type进行查找
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}
			// 如果当前要获取的bean只是为了进行类型检查就标记bean已经被创建
			if (!typeCheckOnly) {
				// 这里是将 当前创建的beanName 保存到 alreadyCreated 集合中。alreadyCreated 中的bean表示当前bean已经创建了，在进行循环依赖判断的时候会使用
				markBeanAsCreated(beanName);
			}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    6. 合并 BeanDefinition

    BeanDefinition 顾名思义，就是关于bean 的定义信息。通过xml的bean定义可以很清楚的看到一些属性定义。

    所以这一步就是检查当前 BeanDefinition 是否有父BeanDefinition ，如果有将一些属性和当前bean合并，生成一个 RootBeanDefinition。
    推荐阅读： https://blog.csdn.net/andy_zhang2007/article/details/86514320

    		final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
		checkMergedBeanDefinition(mbd, beanName, args);

    • 1
    • 2

    这一块的调用链路：getMergedLocalBeanDefinition -> getMergedBeanDefinition -> getMergedBeanDefinition。所以我们 这里直接来看getMergedBeanDefinition方法。
    首先，mdb 即MergedBeanDefinition的缩写，即一个合并的beanDefinition。

    AbstractBeanFactory#getMergedLocalBeanDefinition()

    	protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
		// Quick check on the concurrent map first, with minimal locking.
		RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
		if (mbd != null) {
			return mbd;
		}
		return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    AbstractBeanFactory#getMergedBeanDefinition(String beanName, BeanDefinition bd)

    protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
			throws BeanDefinitionStoreException {

		return getMergedBeanDefinition(beanName, bd, null);
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    	/**
	 * 如果给定bean的定义是子bean定义，则通过与父级合并返回RootBeanDefinition。
	 */
	protected RootBeanDefinition getMergedBeanDefinition(
			String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
			throws BeanDefinitionStoreException {

		synchronized (this.mergedBeanDefinitions) {
			RootBeanDefinition mbd = null;

			// Check with full lock now in order to enforce the same merged instance.
			if (containingBd == null) {
				mbd = this.mergedBeanDefinitions.get(beanName);
			}

			if (mbd == null) {
				// 判断如果parentName为空则没必要进行合并了，直接克隆返回即可
				if (bd.getParentName() == null) {
					// Use copy of given root bean definition.
					if (bd instanceof RootBeanDefinition) {
						mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
					}
					else {
						mbd = new RootBeanDefinition(bd);
					}
				}
				else {
					// Child bean definition: needs to be merged with parent.
					BeanDefinition pbd;
					try {
						// 转换beanName
						String parentBeanName = transformedBeanName(bd.getParentName());
						// 递归调用，解析更上层的parent BeanDefinition
						if (!beanName.equals(parentBeanName)) {
							pbd = getMergedBeanDefinition(parentBeanName);
						}
						else {
							BeanFactory parent = getParentBeanFactory();
							if (parent instanceof ConfigurableBeanFactory) {
								pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
							}
							else {
								throw new NoSuchBeanDefinitionException(parentBeanName,
										"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
										"': cannot be resolved without a ConfigurableBeanFactory parent");
							}
						}
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
								"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
					}
					// Deep copy with overridden values.
					// 深拷贝
					mbd = new RootBeanDefinition(pbd);
					mbd.overrideFrom(bd);
				}

				// Set default singleton scope, if not configured before.
				if (!StringUtils.hasLength(mbd.getScope())) {
					mbd.setScope(SCOPE_SINGLETON);
				}

				// A bean contained in a non-singleton bean cannot be a singleton itself.
				// Let's correct this on the fly here, since this might be the result of
				// parent-child merging for the outer bean, in which case the original inner bean
				// definition will not have inherited the merged outer bean's singleton status.
				if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
					mbd.setScope(containingBd.getScope());
				}

				// Cache the merged bean definition for the time being
				// (it might still get re-merged later on in order to pick up metadata changes)
				if (containingBd == null && isCacheBeanMetadata()) {
					this.mergedBeanDefinitions.put(beanName, mbd);
				}
			}

			return mbd;
		}
	}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82

    7. 寻找依赖

    这一步也是针对BeanDefinition的dependsOn属性来说的（对应注解则是 @DependsOn。主要是 优先加载Bean 的 depends-on依赖。

    注：
    在BeanDefinition加载过程中，通过扫描路径加载的时候，通过 ClassPathBeanDefinitionScanner#doScan()方法时会调用AnnotationConfigUtils#processCommonDefinitionAnnotations来进行BeanDefinition封装，其中就包含了诸多注解的解析，如下：
    在这里插入图片描述
    因为bean 的初始化过程中很可能会用到某些属性，而某些属性很可能是动态配置的，并且配置成依赖于其他的bean，那么这个时候就有必要先加载依赖的bean，所以，在Spring的加载顺序中，在初始化某一个bean的时候首先会初始化这个bean所对应的依赖。

    				// 7. 寻找bean的依赖
				// 获取当前Bean所有依赖的Bean名称
				String[] dependsOn = mbd.getDependsOn();
				// 如果需要依赖，则递归实例化依赖bean
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						// 判断是否有循环依赖的情况 ： A依赖B，B依赖A
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						// 注册依赖信息，将依赖信息保存到 dependentBeanMap、dependenciesForBeanMap中
						registerDependentBean(dep, beanName);
						try {
							// 获取依赖的bean，这一步又回到了最初的getBean
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    下面我们来看一看isDependent(beanName, dep)的处理逻辑
    DefaultSingletonBeanRegistry#isDependent(String beanName, String dependentBeanName)

    	protected boolean isDependent(String beanName, String dependentBeanName) {
		synchronized (this.dependentBeanMap) {
			return isDependent(beanName, dependentBeanName, null);
		}
	}

    • 1
    • 2
    • 3
    • 4
    • 5

    DefaultSingletonBeanRegistry#isDependent()

    private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
		// 是否已经检测过了，上层一直是null
		if (alreadySeen != null && alreadySeen.contains(beanName)) {
			return false;
		}
		// 格式化beanName
		String canonicalName = canonicalName(beanName);
		// 获取 依赖于 beanName 的 bean集合
		Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
		if (dependentBeans == null) {
			return false;
		}
		// 如果 依赖于 beanName中存在 dependentBeanName 则说明存在循环依赖。
		// 代码走到这里说明是beanName 创建过程中要依赖 dependentBeanName。但是dependentBeans.contains(dependentBeanName) = true 则说明dependentBeanName依赖于beanName
		// 造成了 A依赖B，B依赖A的情况
		if (dependentBeans.contains(dependentBeanName)) {
			return true;
		}
		// 递归，确定没有A->B->C-A 这种长链路的循环依赖情况
		for (String transitiveDependency : dependentBeans) {
			if (alreadySeen == null) {
				alreadySeen = new HashSet<>();
			}
			alreadySeen.add(beanName);
			if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
				return true;
			}
		}
		return false;
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    注：
    @DependsOn：注解是在另外一个实例创建之后才创建当前实例，也就是，最终两个实例都会创建，只是顺序不一样
    @ConditionalOnBean：注解是只有当另外一个实例存在时，才创建，否则不创建，也就是，最终有可能两个实例都创建了，有可能只创建了一个实例，也有可能一个实例都没创建

    8. bean创建

    上面这么多逻辑，都是准备工作。确定缓存中没有当前bean，并且当前bean的创建合法。准备开始创建。不过这里考虑到不同的 Scope，所以针对不同的Scope进行不同的初始化操作。创建bean 的过程也很复杂。

    下面代码就是根据 Singleton、Prototype 或者其他Scope 走不同的流程创建bean。

    				// 8 针对不同的Scope 进行bean的创建
				// 实例化依赖的bean便可以实例化mdb本身了
				// 如果BeanDefiniton为单例
				if (mbd.isSingleton()) {
					// 匿名内部类，创建Bean实例对象,并且注册给所依赖的对象
					// 关键方法:单例类实例化的入口
					sharedInstance = getSingleton(beanName, () -> {
						try {
							// 创建单例bean的入口.
							// =============关键===============
							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.
							// 显性从单例缓存中删除bean实例.
							// 因为单例模式下为了解决循环依赖，可能留有残余的信息，此处进行销毁
							destroySingleton(beanName);
							throw ex;
						}
					});
					// 解决FactoryBean的问题
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

				else if (mbd.isPrototype()) {
					// It's a prototype -> create a new instance.
					// 原型模式的回调
					// 如果是原型模式，创建一个实例,在原型模式下，每次getBean都会产生一个新的实例
					Object prototypeInstance = null;
					try {
						// 保存当前线程正在创建的beanName 到 prototypesCurrentlyInCreation 中
						beforePrototypeCreation(beanName);
						// 直接创建bean
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						// 完成创建后，从 prototypesCurrentlyInCreation 中移除当前线程正在创建的beanName
						afterPrototypeCreation(beanName);
					}
					// 解决FactoryBean的问题
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				else {
					// 指定scope上实例化bean
					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, () -> {
							// 保存当前线程正在创建的beanName 到 prototypesCurrentlyInCreation 中
							beforePrototypeCreation(beanName);
							try {
								// 创建bean
								return createBean(beanName, mbd, args);
							}
							finally {
								// 移除当前线程正在创建的beanName 从 prototypesCurrentlyInCreation 中
								afterPrototypeCreation(beanName);
							}
						});
						//  解决FactoryBean的问题
						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
					catch (IllegalStateException ex) {
						throw new BeanCreationException(beanName,
								"Scope '" + scopeName + "' is not active for the current thread; consider " +
								"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
								ex);
					}
				}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    1. 在真正的创建单例Bean之前，Spring会先检查当前beanName是否在prototypesCurrentlyInCreation中,prototypesCurrentlyInCreation是一个ThreadLocal的Set集合，其中存储了当前正在创建的多例BeanName集合,Spring不支持prototye作用域的循环依赖，所以会抛出一个BeanCurrentlyInCreationException.
    2. 向上递归获取父容器，尝试找到该beanName的对象实例.这里有点像类加载时的双亲委派机制去加载bean.
    3. 检查是否为类型检查，如果不仅仅是类型检查，那么Spring知晓为创建Bean了，会开始在一个alreadyCreated的Set集合中加入该BeanName的名称.这里会存储已经创建好的或者正在创建中的beanName并且进行clearMergedBeanDefinition操作。
    4. 如果从父容器无法获取，开始进行进行创建Bean之前的一些准备工作,例如getMergedLocalBeanDefinition,检测当前的RootBeanDefinition是否为abstract的同时，如果bean声明了dependsOn,还会进行相应的注册逻辑,同时递归调用getBean方法进行Bean的初始化.
      注意:dependsOn是不可以有循环声明的.因为dependsOn显示声明了Bean创建的顺序，如果还存在循环声明，就会乱套.
    5. 经过上面的校验后，如果Bean的作用域为singleton，就开始进行createBean操作了.此处Spring是调用了一个重载的getSingleton(String beanName, ObjectFactory singletonFactory)方法.而createBean()作为ObjectFactory这个函数式接口的代码块进行了传递.在这个getSingleton中，Spring会调用传进来的singletonFactory.getObject()方法，实际上，就是调用的createBean().

    9. 类型转换

    到这里整个流程基本就结束了。通常对该方法的调用参数requiredType是null。但某些情况可能会出现返回的bean是个String类型，但是requiredType传入的却是Integer类型，这时候就会触发这一步的操作，将String类型转换为Integer类型。

    if (requiredType != null && !requiredType.isInstance(bean)) {
			try {
				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
				if (convertedBean == null) {
					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
				}
				return convertedBean;
			}
			catch (TypeMismatchException ex) {
				if (logger.isDebugEnabled()) {
					logger.debug("Failed to convert bean '" + name + "' to required type '" +
							ClassUtils.getQualifiedName(requiredType) + "'", ex);
				}
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    以上：内容部分参考
    《Spring源码深度解析》
    如有侵扰，联系删除。 内容仅用于自我记录学习使用。如有错误，欢迎指正

  • 相关阅读:
    SpringBoot整合Redis缓存
    基于Java毕业设计在线投稿系统源码+系统+mysql+lw文档+部署软件
    LeetCode刷题系列 -- 230. 二叉搜索树中第K小的元素
    Wordpress页面生成器：Elementor 插件制作网站页面教程（图文完整）
    深入探索C语言自定义类型：打造你的编程世界
    js去除数组对象中的重复对象
    [极客大挑战 2019]Http
    pytorch 中 nn.Conv2d 解释
    JavaScript的综合案例
    七天.NET 8操作SQLite入门到实战 - 第三天SQLite快速入门
  • 原文地址：https://blog.csdn.net/wts563540/article/details/127860968