Spring【版本5.2.2】容器初始化过程(六)getBean 详解

接着上文的

6.registerBeanPostProcessors

代码块4:getBean

这个是重点:

	@Override
	public Object getBean(String name) throws BeansException {
	    // 获取name对应的bean实例,如果不存在,则创建一个
	    return doGetBean(name, null, null, false);
	}

	/**
	 * 真正实现向IOC容器获取Bean的功能,也是触发依赖注入功能的地方
	 */
	@SuppressWarnings("unchecked")
	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

		/*
		 * 通过name获取beanName,这里不用name直接作为beanName的原因:
		 * 1. name可能是以&开头,表名调用者想获取FactoryBean本身,而非FactoryBean实现类所创建的bean
		 * 在BeanFactory中,FactoryBean的实现类和其他的Bean存储方式是一致的,所以要讲name中首字符&移除,
		 * 这样才能从缓存中渠道FactoryBean实例
		 * 2. 如果是别名,这将别名转成规范的Bean名称
		 */
		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		// 先从缓存中取是否已经有被创建的单态类型的Bean
		// 对于单例模式的Bean,整个IOC容器只创建一次,不需要重复创建
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			// 3.如果beanName的实例存在于缓存中
			if (logger.isTraceEnabled()) {
				// 校验Bean的创建状态
				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 + "'");
				}
			}
			/* 3.1 获取给定Bean的实例对象,主要是完成FactoryBean的相关处理
			 * 如果sharedInstance是普通的单例Bean,下面的方法直接返回。
			 * 如果sharedInstance是FactoryBean类型,则需要调用FactoryBean.getObject工厂方法获取真正的Bean实例
			 * 如果用户想获取FactoryBean本身,这里面也不会做特别处理直接返回即可
			 * 注意:BeanFactory是管理容器中Bean的工厂,而FactoryBean是创建创建对象的工厂Bean,两者之间有区别
			 */
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// 4.bean的状态是正在创建中,还没有被实例化,所以如果是原型,直接抛出异常
			// scope为prototype的循环依赖校验:如果beanName已经正在创建Bean实例中,
			// 而此时我们又要再一次创建beanName的实例,则代表出现了循环依赖,需要抛出异常。
			// 例子:如果存在A中有B的属性,B中有A的属性,那么当依赖注入的时候,
			// 就会产生当A还未创建完的时候因为对于B的创建再次返回创建A,造成循环依赖
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}
			// Check if bean definition exists in this factory.
			// 5. 检查是否存在默认的父工厂
			BeanFactory parentBeanFactory = getParentBeanFactory();
			// 5.1 如果parentBeanFactory存在,并且beanName在当前BeanFactory不存在Bean定义,
			// 则尝试从parentBeanFactory中获取bean实例
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				// 5.2 将别名解析成真正的beanName
				String nameToLookup = originalBeanName(name);
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly);
				}
				// 5.3 尝试在parentBeanFactory中获取bean对象实例
				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) {
				// 6.如果不是仅仅做类型检测,而是创建bean实例,这里要将beanName放到alreadyCreated缓存
				markBeanAsCreated(beanName);
			}

			try {
				// 7.根据beanName重新获取MergedBeanDefinition(步骤6将MergedBeanDefinition删除了,这边获取一个新的)
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				// 7.1 检查MergedBeanDefinition
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				// 8.拿到当前bean依赖的bean名称集合,在实例化自己之前,需要先实例化自己依赖的bean
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					// 8.1 遍历当前bean依赖的bean名称集合
					for (String dep : dependsOn) {
						// 8.2 检查dep是否依赖于beanName,即检查是否存在循环依赖
						if (isDependent(beanName, dep)) {
							// 8.3 如果是循环依赖则抛异常
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						// 8.4 将dep和beanName的依赖关系注册到缓存中
						registerDependentBean(dep, beanName);
						try {
							// 8.5 获取dep对应的bean实例,如果dep还没有创建bean实例,则创建dep的bean实例
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				// Create bean instance.
				// 9.针对不同的scope进行bean的创建
				if (mbd.isSingleton()) {
					// 实例化bean
					// 9.1 scope为singleton的bean创建(新建了一个ObjectFactory,并且重写了getObject方法)
					sharedInstance = getSingleton(beanName, () -> {
						try {
							// 9.1.1 创建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.
							destroySingleton(beanName);
							throw ex;
						}
					});
					// 9.1.2 返回beanName对应的实例对象
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				// 下面检查其他工作,暂时不做细说
				else if (mbd.isPrototype()) {
					// It's a prototype -> create a new instance.
					// 9.2 scope为prototype的bean创建,创建一个新的实例
					Object prototypeInstance = null;
					try {
						// 9.2.1 创建实例前的操作(将beanName保存到prototypesCurrentlyInCreation缓存中)
						beforePrototypeCreation(beanName);
						// 9.2.2 创建Bean实例
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						// 9.2.3 创建实例后的操作(将创建完的beanName从prototypesCurrentlyInCreation缓存中移除)
						afterPrototypeCreation(beanName);
					}
					// 9.2.4 返回beanName对应的实例对象
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}
				else {
					// 9.3 其他scope的bean创建,可能是request之类的
					// 9.3.1 根据scopeName,从缓存拿到scope实例
					String scopeName = mbd.getScope();
					final Scope scope = this.scopes.get(scopeName);
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
					}
					try {
						// 9.3.2 其他scope的bean创建(新建了一个ObjectFactory,并且重写了getObject方法)
						Object scopedInstance = scope.get(beanName, () -> {
							// 9.3.3 创建实例前的操作(将beanName保存到prototypesCurrentlyInCreation缓存中)
							beforePrototypeCreation(beanName);
							try {
								// 9.3.4 创建bean实例
								return createBean(beanName, mbd, args);
							}
							finally {
								// 9.3.5 创建实例后的操作(将创建完的beanName从prototypesCurrentlyInCreation缓存中移除)
								afterPrototypeCreation(beanName);
							}
						});
						// 9.3.6 返回beanName对应的实例对象
						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) {
				// 如果创建bean实例过程中出现异常,则将beanName从alreadyCreated缓存中移除
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}

		// Check if required type matches the type of the actual bean instance.
		// 10.检查所需类型是否与实际的bean对象的类型匹配
		if (requiredType != null && !requiredType.isInstance(bean)) {
			try {
				// 10.1 类型不对,则尝试转换bean类型
				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
				if (convertedBean == null) {
					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
				}
				return 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());
			}
		}
		// 11.返回创建出来的bean实例对象
		return (T) bean;
	}

9.1.2、9.2.4、9.3.6 返回 beanName 对应的实例对象,见代码块1详解。

代码块4.1: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.判断他是不是FactoryBean,只要看他是不是&开头,
		if (BeanFactoryUtils.isFactoryDereference(name)) {
			if (beanInstance instanceof NullBean) {
				return beanInstance;
			}
			if (!(beanInstance instanceof FactoryBean)) {
				throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
			}
			if (mbd != null) {
				mbd.isFactoryBean = true;
			}
			return beanInstance;
		}

		// 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.1 如果beanInstance不是FactoryBean(也就是普通bean),则直接返回beanInstance
		// 2.2 如果beanInstance是FactoryBean,并且name以“&”为前缀,则直接返回beanInstance(以“&”为前缀代表想获取的是FactoryBean本身)
		if (!(beanInstance instanceof FactoryBean)) {
			return beanInstance;
		}
		// 3.走到这边,代表beanInstance是FactoryBean,但name不带有“&”前缀,表示想要获取的是FactoryBean创建的对象实例
		Object object = null;
		if (mbd != null) {
			// 标记是否是FactoryBean
			mbd.isFactoryBean = true;
		}
		else {
			// 4.如果mbd为空,则尝试从factoryBeanObjectCache缓存中获取该FactoryBean创建的对象实例
			object = getCachedObjectForFactoryBean(beanName);
		}
		if (object == null) {
			// Return bean instance from factory.
			// 5.只有beanInstance是FactoryBean才能走到这边,因此直接强转
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			// Caches object obtained from FactoryBean if it is a singleton.
			if (mbd == null && containsBeanDefinition(beanName)) {
				// 6.mbd为空,但是该bean的BeanDefinition在缓存中存在,则获取该bean的MergedBeanDefinition
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			// 7.mbd是否是合成的(这个字段比较复杂,mbd正常情况都不是合成的,也就是false,有兴趣的可以自己查阅资料看看)
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			// 8.从FactoryBean获取对象实例
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		// 9.返回对象实例
		return object;
	}
代码块4.2:postProcessObjectFromFactoryBean
	/**
	 * 对所有已注册的BeanPostProcessors应用postProcessAfterInitialization回调,
	 * 使它们有机会对从FactoryBeans获得的对象进行后处理(例如,自动代理它们)。
	 */
	@Override
	protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
		return applyBeanPostProcessorsAfterInitialization(object, beanName);
	}
	
代码块4.3:markBeanAsCreated
	protected void markBeanAsCreated(String beanName) {

		if (!this.alreadyCreated.contains(beanName)) {
			synchronized (this.mergedBeanDefinitions) {
				// 1.如果alreadyCreated缓存中不包含beanName,
				// 这边代码为啥判断两次contains,知道的留个言告知一下。
				if (!this.alreadyCreated.contains(beanName)) {
					// Let the bean definition get re-merged now that we're actually creating
					// the bean... just in case some of its metadata changed in the meantime.
					// 2.这边跟以前版本有变化,如果mergedBeanDefinitions中存在当前的bean
					// 将当前的RootBeanDefinition的stale设置成true
					clearMergedBeanDefinition(beanName);
					// 3.将beanName添加到alreadyCreated缓存中,代表该beanName的bean实例已经创建(或即将创建)
					this.alreadyCreated.add(beanName);
				}
			}
		}
	}
	/**
	 * 删除指定bean的合并bean定义,在下一次访问时重新创建它。
	 */
	protected void clearMergedBeanDefinition(String beanName) {
		RootBeanDefinition bd = this.mergedBeanDefinitions.get(beanName);
		if (bd != null) {
			bd.stale = true;
		}
	}
	
代码块4.4:isDependent
	private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
		// 已经检查过的直接跳过
		if (alreadySeen != null && alreadySeen.contains(beanName)) {
			return false;
		}
		// 1.将别名解析为真正的名称
		String canonicalName = canonicalName(beanName);
		// 2.拿到依赖canonicalName的beanName集合
		Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
		// 3.如果dependentBeans为空,则两者必然还未确定依赖关系,返回false
		if (dependentBeans == null) {
			return false;
		}
		// 4.如果dependentBeans包含dependentBeanName,则表示两者已确定依赖关系,返回true
		if (dependentBeans.contains(dependentBeanName)) {
			return true;
		}
		// 5.循环检查,即检查依赖canonicalName的所有beanName是否存在被dependentBeanName依赖的(即传递依赖)
		// 传递依赖:例如:A 依赖了B,B依赖了C,则A也算依赖了C
		for (String transitiveDependency : dependentBeans) {
			if (alreadySeen == null) {
				alreadySeen = new HashSet<>();
			}
			// 6.已经检查过的添加到alreadySeen,避免重复检查
			alreadySeen.add(beanName);
			// 通过迭代的方式,处理传递依赖
			if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
				return true;
			}
		}
		return false;
	}

代码块4.5:registerDependentBean

 这边又引入了一个跟 dependentBeanMap 类似的缓存,dependenciesForBeanMap:beanName -> beanName 对应的 bean 依赖的所有 bean 的 beanName 集合。
 这两个缓存很容易搞混,举个简单例子:例如B依赖了A,则dependentBeanMap缓存中应该存放一对映射:其中 key为A,value为含有B的Set;而dependenciesForBeanMap缓存中也应该存放一对映射:其中key为:B,value为含有A的Set。

public void registerDependentBean(String beanName, String dependentBeanName) {
		// 处理Bean名称,将别名转换为规范的Bean名称
		String canonicalName = canonicalName(beanName);

		// 4.如果依赖关系还没有注册,则将两者的关系注册到dependentBeanMap和dependenciesForBeanMap缓存
		synchronized (this.dependentBeanMap) {
			// 4.1 将dependentBeanName添加到依赖canonicalName的beanName集合中
			Set<String> dependentBeans =
					this.dependentBeanMap.computeIfAbsent(canonicalName,
							k -> new LinkedHashSet<>(8));
			// 向容器中:bean名称-->全部依赖Bean名称集合添加Bean的依赖信息
			// 即,将Bean所依赖的Bean添加到容器的集合中
			if (!dependentBeans.add(dependentBeanName)) {
				return;
			}
		}

		synchronized (this.dependenciesForBeanMap) {
			// 4.2 将canonicalName添加到dependentBeanName依赖的beanName集合中
			Set<String> dependenciesForBean =
					this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName,
							k -> new LinkedHashSet<>(8));
			dependenciesForBean.add(canonicalName);
		}
	}

代码块4.6:getSingleton
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "Bean name must not be null");
		// 1.加锁,避免重复创建单例对象
		synchronized (this.singletonObjects) {
			// 2.首先检查beanName对应的bean实例是否在缓存中存在,如果已经存在,则直接返回
			Object singletonObject = this.singletonObjects.get(beanName);
			// 3.beanName对应的bean实例不存在于缓存中,则进行Bean的创建
			if (singletonObject == null) {
				// 4.当bean工厂的单例处于destruction状态时,不允许进行单例bean创建,抛出异常
				if (this.singletonsCurrentlyInDestruction) {
					throw new BeanCreationNotAllowedException(beanName,
							"Singleton bean creation not allowed while singletons of this factory are in destruction " +
							"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
				}
				// 5.创建单例前的操作
				beforeSingletonCreation(beanName);
				boolean newSingleton = false;
				// suppressedExceptions用于记录异常相关信息
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<>();
				}
				try {
					// 6.执行singletonFactory的getObject方法获取bean实例
					singletonObject = singletonFactory.getObject();
					// 标记为新的单例对象
					newSingleton = true;
				}
				catch (IllegalStateException ex) {
					// Has the singleton object implicitly appeared in the meantime ->
					// if yes, proceed with it since the exception indicates that state.
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
						throw ex;
					}
				}
				catch (BeanCreationException ex) {
					if (recordSuppressedExceptions) {
						for (Exception suppressedException : this.suppressedExceptions) {
							ex.addRelatedCause(suppressedException);
						}
					}
					throw ex;
				}
				finally {
					if (recordSuppressedExceptions) {
						this.suppressedExceptions = null;
					}
					// 7.创建单例后的操作
					afterSingletonCreation(beanName);
				}
				if (newSingleton) {
					// 8.如果是新的单例对象,将beanName和对应的bean实例添加到缓存中(singletonObjects、registeredSingletons)
					addSingleton(beanName, singletonObject);
				}
			}
			// 9.返回创建出来的单例对象
			return singletonObject;
		}
	}
代码块4.7:beforeSingletonCreation、afterSingletonCreation
	protected void beforeSingletonCreation(String beanName) {
		// 先校验beanName是否为要在创建检查排除掉的(inCreationCheckExclusions缓存),如果不是,
		// 则将beanName加入到正在创建bean的缓存中(Set),
		// 如果beanName已经存在于该缓存,会返回false抛出异常(这种情况出现在构造器的循环依赖)
		if (!this.inCreationCheckExclusions.contains(beanName) 
		&& !this.singletonsCurrentlyInCreation.add(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
	}
	protected void afterSingletonCreation(String beanName) {
		// 先校验beanName是否为要在创建检查排除掉的(inCreationCheckExclusions缓存),如果不是,
		// 则将beanName从正在创建bean的缓存中(Set)移除,
		// 如果beanName不存在于该缓存,会返回false抛出异常
		if (!this.inCreationCheckExclusions.contains(beanName) 
		&& !this.singletonsCurrentlyInCreation.remove(beanName)) {
			throw new IllegalStateException("Singleton '" + 
			beanName + "' isn't currently in creation");
		}
	}
代码块4.8:beforePrototypeCreation、afterPrototypeCreation

该方法上面两个方法类似。主要是在进行 bean 实例的创建前,将 beanName 添加到 prototypesCurrentlyInCreation 缓存;bean 实例创建后,将 beanName 从 prototypesCurrentlyInCreation 缓存中移除。这边 prototypesCurrentlyInCreation 存放的类型为 Object,在只有一个 beanName 的时候,直接存该 beanName,也就是 String 类型;当有多个 beanName 时,转成 Set 来存放。

	protected void beforePrototypeCreation(String beanName) {
		// 1.拿到当前线程中正在创建的prototype的bean的beanName集合
		Object curVal = this.prototypesCurrentlyInCreation.get();
		if (curVal == null) {
			// 2.如果为空,则将ThreadLocal设置成当前的beanName
			this.prototypesCurrentlyInCreation.set(beanName);
		}
		// 3.如果不为空,并且是String类型,则代表目前只有一个beanName,
		// 将之前和当前的一起封装成Set<String>,设置到ThreadLocal中
		else if (curVal instanceof String) {
			Set<String> beanNameSet = new HashSet<>(2);
			beanNameSet.add((String) curVal);
			beanNameSet.add(beanName);
			this.prototypesCurrentlyInCreation.set(beanNameSet);
		}
		// 4.如果不为空,并且不是String,则必然是Set<String>类型,将当前的beanName加到Set中去
		else {
			Set<String> beanNameSet = (Set<String>) curVal;
			beanNameSet.add(beanName);
		}
	}
	protected void afterPrototypeCreation(String beanName) {
		// 1.拿到当前线程中正在创建的prototype的bean的beanName集合
		Object curVal = this.prototypesCurrentlyInCreation.get();
		// 2.如果是String类型,则代表目前只有一个beanName,则直接移除
		if (curVal instanceof String) {
			this.prototypesCurrentlyInCreation.remove();
		}
		else if (curVal instanceof Set) {
			// 3.如果是Set类型,则从Set从移除beanName
			Set<String> beanNameSet = (Set<String>) curVal;
			beanNameSet.remove(beanName);
			if (beanNameSet.isEmpty()) {
				this.prototypesCurrentlyInCreation.remove();
			}
		}
	}
单元测试

留个坑。。

总结

留个坑。。

参考

https://blog.csdn.net/v123411739/article/details/87954818

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值