Spring IOC系列学习笔记九：getBean方法

最新推荐文章于 2022-11-24 23:13:45 发布
最新推荐文章于 2022-11-24 23:13:45 发布
阅读量268 收藏
点赞数
分类专栏： Spring 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhengguofeng0328/article/details/115480617
版权

原文地址程序员囧辉大佬

相关文章

Spring IOC系列学习笔记一：前置刷新
Spring IOC系列学习笔记二：obtainFreshBeanFactory方法
Spring IOC系列学习笔记三：parseDefaultElement详解
Spring IOC系列学习笔记四：parseCustomElement解析
Spring IOC系列学习笔记五：context:component-scan 节点解析
Spring IOC系列学习笔记六：invokeBeanFactoryPostProcessors解析
Spring IOC系列学习笔记七：registerBeanPostProcessors
Spring IOC系列学习笔记八：finishBeanFactoryInitialization
Spring IOC系列学习笔记九：getBean方法
Spring IOC系列学习笔记十：createBean方法（上）
Spring IOC系列学习笔记十一：createBean方法（下）
Spring IOC系列学习笔记十二：@Autowire注解

文章目录

前言

前面讲解了finishBeanFactoryInitialization方法，接着进入getBean方法的解析。

代码块一：getBean

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


	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
		1、解析beanName，主要是去掉&前缀
		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		2、从缓存中获取bean实例
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isDebugEnabled()) {
				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、如果缓存中存在并且args参数为空，则直接获取beanName的实例对象
			（主要是解析FactoryBean，如果不是该类型则直接返回）
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
			判断scope为prototype的循环依赖校验，就是如果A已经在正在创建的缓存，而现在我们在当前线程中还要创建该实例，则出现循环依赖。
			Spring中对多例的循环依赖没有解决所以直接抛出异常。
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// Check if bean definition exists in this factory.
			4.1、获取parentBeanFactory
			BeanFactory parentBeanFactory = getParentBeanFactory();
			4.2、parentBeanFactory不为空&&缓存中不存在beanName，尝试从父容器创建bean实例
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				4.3、规范beanName
				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 {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}

			if (!typeCheckOnly) {
				5、如果不是仅仅做类型检测，而是创建bean实例，这里要将beanName放到alreadyCreated缓存
				移除了mergedBeanDefinitions中的beanName，后续创建一个最新的
				markBeanAsCreated(beanName);
			}

			try {
				6.1、创建一个新的
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
				6.2、拿到该实例以来的bean集合
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						6.3、判断dep是否依赖beanName，检查循环依赖
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						6.4、将dep和beanName注册到依赖缓存中，引进了两个缓存（容易搞混淆）
						registerDependentBean(dep, beanName);
						6.5、获取依赖bean的实例
						getBean(dep);
					}
				}

				// Create bean instance.
				if (mbd.isSingleton()) {
					7、如果是单例的创建一个单例对象（lambda表达式重写了ObjectFactory的getObject方法）
					sharedInstance = getSingleton(beanName, () -> {
						try {
							7.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;
						}
					});
					7.2、返回beanName对应的实例对象
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}

				else if (mbd.isPrototype()) {
					// It's a prototype -> create a new instance.
					8.1、scope是prototype的bean创建
					Object prototypeInstance = null;
					try {
						8.2、创建实例前的操作（将beanName保存到prototypesCurrentlyInCreation缓存中）
						beforePrototypeCreation(beanName);
						8.3、创建bean实例对象
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						8.4、创建实例后的操作（将beanName从prototypesCurrentlyInCreation缓存中移除）
						afterPrototypeCreation(beanName);
					}
					8.5、返回beanName对应的实例对象
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				else {
					9.1、其他scope的bean创建，可能是request之类的
					9.2、根据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、其他scope的bean创建（新建了一个ObjectFactory，并且重写了getObject方法）
						Object scopedInstance = scope.get(beanName, () -> {
							beforePrototypeCreation(beanName);
							try {
								return createBean(beanName, mbd, args);
							}
							finally {
								afterPrototypeCreation(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) {
				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.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;
	}

2、从缓存中获取bean实例建见finishBeanFactoryInitialization中的代码块七
3、返回beanName对应的实例对象见代码块二
5、如果不是仅仅做类型检测，而是创建bean实例见代码块六
6.3、判断dep是否依赖beanName，检查循环依赖代码块isDependent见代码块七
6.4、将dep和beanName注册到依赖缓存中，引进了两个缓存（容易搞混淆）代码块八
7、如果是单例的创建一个单例对象代码块九
8.2和8.4、创建实例前的操作和创建实例后的操作代码块十二

代码块二：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包含前缀& 并且beanInstance不是FactoryBean类型直接抛出异常
		if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
			throw new BeanIsNotAFactoryException(transformedBeanName(name), 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.1、beanInstance不是FactoryBean直接返回
		2.2、beanInstance是FactoryBean并且name包含前缀& 表示要的就是FactoryBean的实例则直接返回
		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}
		3、到这儿表示 beanInstance是FactoryBean但是name前缀不包含&，则要用FactoryBean来创建bean的实例
		Object object = null;
		if (mbd == null) {
			3.1、从factoryBeanObjectCache缓存中获取bean的实例
			object = getCachedObjectForFactoryBean(beanName);
		}
		if (object == null) {
			// Return bean instance from factory.
			3.2、直接转换成FactoryBean
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			// Caches object obtained from FactoryBean if it is a singleton.
			if (mbd == null && containsBeanDefinition(beanName)) {
				3.3、mbd为null并且缓存中存在beanName，则获取该bean的MergedLocalBean
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			3.4、判断是不是合成的
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			3.5、从FactoryBean中获取实例
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}

3.5、从FactoryBean中获取实例见代码块三

代码块三：getObjectFromFactoryBean

	protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
		1、factory是单例的&&beanName存在缓存中
		if (factory.isSingleton() && containsSingleton(beanName)) {
			synchronized (getSingletonMutex()) {
				2.1、从factoryBeanObjectCache缓存中获取该beanName的实例
				Object object = this.factoryBeanObjectCache.get(beanName);
				if (object == null) {
					2.2、真正的创建方法 带do开头的
					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)
					2.3、再从从缓存中获取
					Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
					if (alreadyThere != null) {
						2.4、如果获取到了则替换，用从缓存中获取的
						object = alreadyThere;
					}
					else {
						if (shouldPostProcess) {
							try {
								2.5、FactoryBean的后置处理
								object = postProcessObjectFromFactoryBean(object, beanName);
							}
							catch (Throwable ex) {
								throw new BeanCreationException(beanName,
										"Post-processing of FactoryBean's singleton object failed", ex);
							}
						}
						2.6、放到缓存当中
						this.factoryBeanObjectCache.put(beanName, object);
					}
				}
				return object;
			}
		}
		else {
			3.1、调用FactoryBean的getObject方法获取对象实例
			Object object = doGetObjectFromFactoryBean(factory, beanName);
			if (shouldPostProcess) {
				try {
					3.2、对bean实例进行后置处理
					object = postProcessObjectFromFactoryBean(object, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
				}
			}
			return object;
		}
	}

2.2、真正的创建方法 带do开头的见代码块四
3.2、对bean实例进行后置处理见代码块五

代码块四：doGetObjectFromFactoryBean

private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
			throws BeanCreationException {

		Object object;
		try {
			if (System.getSecurityManager() != null) {
				AccessControlContext acc = getAccessControlContext();
				try {
					1、带权限验证执行getObject方法获取bean实例
					object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () ->
							factory.getObject(), acc);
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
				2、直接获取
				object = factory.getObject();
			}
		}
		catch (FactoryBeanNotInitializedException ex) {
			throw new BeanCurrentlyInCreationException(beanName, ex.toString());
		}
		catch (Throwable ex) {
			throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
		}

		// Do not accept a null value for a FactoryBean that's not fully
		// initialized yet: Many FactoryBeans just return null then.
		if (object == null) {
			if (isSingletonCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(
						beanName, "FactoryBean which is currently in creation returned null from getObject");
			}
			object = new NullBean();
		}
		return object;
	}

代码块五：postProcessObjectFromFactoryBean

@Override
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
    return applyBeanPostProcessorsAfterInitialization(object, beanName);
}
 
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
        throws BeansException {
 
    Object result = existingBean;
    // 1.遍历所有注册的BeanPostProcessor实现类，调用postProcessAfterInitialization方法
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        // 2.在bean初始化后，调用postProcessAfterInitialization方法
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
        if (result == null) {
            // 3.如果返回null，则不会调用后续的BeanPostProcessors
            return result;
        }
    }
    return result;
}

这儿执行的是AbstractAutowireCapableBeanFactory中的方法。我们回到代码块一进入5。

代码块六：markBeanAsCreated

	protected void markBeanAsCreated(String beanName) {
		1、alreadyCreated缓存中不包含beanName
		if (!this.alreadyCreated.contains(beanName)) {
			synchronized (this.mergedBeanDefinitions) {
				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移除了beanName的实例，后续重新创建一个新的
					clearMergedBeanDefinition(beanName);
					3、将beanName添加进已经创建或者正在创建的缓存中
					this.alreadyCreated.add(beanName);
				}
			}
		}
	}

代码块七：isDependent

private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
		1、已经检查直接跳过
		if (alreadySeen != null && alreadySeen.contains(beanName)) {
			return false;
		}
		2、规范名称
		String canonicalName = canonicalName(beanName);
		3、获取依赖canonicalName的beanName集合
		Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
		4、如果为空表示没有依赖beanName的直接返回
		if (dependentBeans == null) {
			return false;
		}
		5、dependentBeans包含了dependentBeanName，表示dependentBeanName依赖了beanName，出现循环依赖
		if (dependentBeans.contains(dependentBeanName)) {
			return true;
		}
		6、循环检查，即检查依赖canonicalName的所有beanName是否存在被dependentBeanName依赖的（即隔层依赖）
		for (String transitiveDependency : dependentBeans) {
			if (alreadySeen == null) {
				alreadySeen = new HashSet<>();
			}
			alreadySeen.add(beanName);
			if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
				return true;
			}
		}
		return false;
	}

这边引入了一个缓存 dependentBeanMap：beanName -> 所有依赖 beanName 对应的 bean 的 beanName 集合。内容比较简单，就是检查依赖 beanName 的集合中是否包含 dependentBeanName，隔层依赖也算。例如：A 依赖了 B，B 依赖了 C，则 A 也算依赖了 C。

代码块八：registerDependentBean

public void registerDependentBean(String beanName, String dependentBeanName) {
		// A quick check for an existing entry upfront, avoiding synchronization...
		1、规范beanName名称
		String canonicalName = canonicalName(beanName);
		2、获取依赖canonicalName的bean的集合
		Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
		3、dependentBeans不为空&& dependentBeanName在缓存中表示已经存在依赖关系了不需要再次创建
		if (dependentBeans != null && dependentBeans.contains(dependentBeanName)) {
			return;
		}

		// No entry yet -> fully synchronized manipulation of the dependentBeans Set
		4、如果依赖关系还没有注册，则将两者的关系注册到dependentBeanMap和dependenciesForBeanMap缓存
		synchronized (this.dependentBeanMap) {
			dependentBeans = this.dependentBeanMap.get(canonicalName);
			if (dependentBeans == null) {
				dependentBeans = new LinkedHashSet<>(8);
				5、存入缓存中，dependentBeans表示的是依赖key的bean是value集合
				this.dependentBeanMap.put(canonicalName, dependentBeans);
			}
			dependentBeans.add(dependentBeanName);
		}
		synchronized (this.dependenciesForBeanMap) {
			Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
			if (dependenciesForBean == null) {
				dependenciesForBean = new LinkedHashSet<>(8);
				6、dependenciesForBeanMap表示key依赖的bean是value集合
				this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
			}
			dependenciesForBean.add(canonicalName);
		}
	}

这两个缓存很容易搞混，举个简单例子：例如 B 依赖了 A，则 dependentBeanMap 缓存中应该存放一对映射：其中 key 为 A，value 为含有 B 的 Set；而 dependenciesForBeanMap 缓存中也应该存放一对映射：其中 key 为：B，value 为含有 A 的 Set。

代码块九：getSingleton

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "Bean name must not be null");
		synchronized (this.singletonObjects) {
			1、从单例缓存中获取bean实例
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) {
				2、如果当前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 + "'");
				}
				3、创建之前的操作，主要是将bean加入到singletonsCurrentlyInCreation缓存
				beforeSingletonCreation(beanName);
				boolean newSingleton = false;
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<>();
				}
				try {
					4、创建了实例
					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;
					}
					5、后续操作，对应3主要是将bean从singletonsCurrentlyInCreation缓存中移除
					afterSingletonCreation(beanName);
				}
				if (newSingleton) {
					6、如果是新的单例对象，将beanName和对应的bean实例添加到缓存中（singletonObjects、registeredSingletons）
					addSingleton(beanName, singletonObject);
				}
			}
			return singletonObject;
		}
	}

3和5、创建前后的操作见代码块十
6、如果是新的单例对象，将beanName和对应的bean实例添加到缓存中（singletonObjects、registeredSingletons）见代码块十一

代码块十：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");
    }
}

代码块十一：addSingleton

protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        // 1.添加到单例对象缓存
        this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
        // 2.将单例工厂缓存移除（已经不需要）
        this.singletonFactories.remove(beanName);
        // 3.将早期单例对象缓存移除（已经不需要）
        this.earlySingletonObjects.remove(beanName);
        // 4.添加到已经注册的单例对象缓存
        this.registeredSingletons.add(beanName);
    }
}

代码块十二：beforePrototypeCreation、afterPrototypeCreation

protected void beforePrototypeCreation(String beanName) {
    // 1.拿到当前线程中正在创建的prototype的bean的beanName集合
    Object curVal = this.prototypesCurrentlyInCreation.get();
    // 2.如果为空，则将ThreadLocal设置成当前的beanName
    if (curVal == null) {
        this.prototypesCurrentlyInCreation.set(beanName);
    }
    // 3.如果不为空，并且是String类型，则代表目前只有一个beanName，将之前和当前的一起封装成Set<String>，设置到ThreadLocal中
    else if (curVal instanceof String) {
        Set<String> beanNameSet = new HashSet<String>(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();
        }
    }
}

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

总结

本文介绍了获取 bean 实例的大部分内容，包括先从缓存中检查、 FactoryBean 的 bean 创建、实例化自己的依赖（depend-on 属性）、创建 bean 实例的前后一些标记等，在下篇文章中，将解析创建 bean 的内容。

炸了毛的猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring IoC源码解析之getBean，血与泪的总结
m0_64383736的博客
11-25 359
getAccessControlContext()); } else { isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } //调用真正的getBean if (isEagerInit) { getBean(beanName); } } } else {//非工厂Bean就是普通的bean getBean(beanName)
Spring学习：Spring IOC 容器对 Bean 的生命周期进行管理的过程
anndy_的专栏
08-22 262
Bean的生命周期1. 通过构造器或工厂方法创建 Bean 实例2. 为 Bean 的属性设置值和对其他 Bean 的引用3.将 Bean 实例传递给 Bean 后置处理器的 postProcessBeforeInitialization 方法创建 Bean 后置处理器4. 调用 Bean 的初始化方法 init-method5. 将 Bean 实例传递给 Bean 后置处理器的 postProcessAfterInitialization 方法6. Bean 可以使用了7. 当容器关闭时, 调用 Bean
Spring IoC源码：getBean 详解
猪大肠的博客
11-24 988
先从缓存中获取实例对象，如果有实例则进行工厂对象解析流程，判断beanName是否带&符号，决定是返回工厂对象本身还是返回真正的实例，如果是返回真正的实例，则调用工厂对象的getObject返回，如果返回值为null，并且在isSingletonCurrentlyInCreation中存在，代表是一个正在创建的bean，不完整的工厂对象，则抛出异常。
Spring5 IOC源码解读系列12—getBean方法
JayLaiSCUT的博客
06-28 3348
一 概述 getBean方法从缓存中获取Bean对象得实例，如果获取不到，则触发Bean对象的创建方法createBean。 Bean根据作用域划有很多种，日常主要打交道的还是单例的比较多，本篇主要详细讲解单例bean的创建，其他的不做展开。 二 源码 2.1 getBean public Object getBean(String name) throws BeansException { //do开头方法才是实际干活 return doGetBean(name, null, null, fals
Spring源码讲解之 getBean 方法
misterhou的专栏
08-01 650
getBean 方法是用来进行获取 bean 实例对象的，是我们进行 spring 程序开发从 bean 工厂获取结果的。那这个方法的执行过程是什么样的，下面我们就去揭开它的面纱。 样例代码 ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); User user = ctx.getBean("user", User.class); getBean 方法执行过程 org.springf
4.1Spring源码解析——getBean方法的实现
szhlcy的博客
10-19 282
 getBean方法在BeanFactory中实现，实现的类有5个 实现类图.png 在这5个类中AbstractBeanFactory完成了getBean()方法的具体实现 public Object getBean(String name) throws BeansException { return doGetBean(name, nu...
Spring学习笔记之bean的基础知识
08-28
Spring框架中的Bean是其核心概念，它代表了应用程序中的对象，这些对象由Spring的Inversion of Control (IoC) 容器负责管理和初始化。在Spring和SpringMVC中，Bean的使用无处不在，理解并熟练掌握Bean的概念对于...
spring学习之路（黑马课程笔记）
最新发布
08-11
Spring学习之路（黑马课程笔记） Spring学习之路是指通过学习Spring框架来掌握IOC反转控制的关键技术。IOC反转控制的关键在于获取bean的创建权。当service需要bean时，在自己的文件下创建setBean(Bean bean)函数，...
spring学习笔记
08-28
Spring 框架是Java开发中最常用的轻量级框架之一，尤其以其依赖注入（Inversion of Control，简称IoC）和面向切面编程（Aspect-Oriented Programming，简称AOP）为核心特性。本文将深入探讨Spring框架的基础知识，...
Spring 学习笔记 spring帮助文档
07-30
在本篇Spring学习笔记中，我们将深入探讨Spring的基本概念，包括bean的配置、依赖注入、IOC容器以及Bean的实例化方式。 首先，Spring中的核心概念是bean。Bean是Spring框架中的基本构建块，它们是被管理的对象，...
Spring技术内幕学习笔记.docx
11-02
《Spring技术内幕》的系列学习笔记主要围绕Spring的IoC容器展开，这是一个核心概念，因为它负责管理应用中的所有对象，包括它们的创建、配置以及依赖关系的管理。IoC容器的两大主要接口是BeanFactory和...
[Spring]Spring Bean的初始化 ---- getBean方法
HeapStackk的博客
07-21 1631
Spring 无论实在spring 容器在初始化阶段 还是 懒加载的bean 都是通过BeanFactory的getBean方法来实例化bean的。 getBean方法提供了多种方式来获取bean 可以通过bean的名字，bean的类型等。 但是他们最后都是调用的doGetBean(...)方法 protected T doGetBean( final String name, f
spring中bean的获取流程，getBean的实现逻辑
LeoHan
06-19 1005
通过之前spring容器启动过程分析,以ClassPathXmlApplicationContext为例说明,我们看到在最后的
反射获取JavaBean 的 get set方法(Method)
renhq
04-26 1753
java反射bean的get方法 ： /** * java反射bean的get方法 * * @param objectClass * @param fieldName * @return */ @SuppressWarnings("unchecked") public static Method getGetMe...
接口ApplicationContext中的getBean()方法的详解
热门推荐
qq_23927391的博客
06-08 11万+
我们知道可以通过ApplicationContext的getBean方法来获取Spring容器中已初始化的bean。getBean一共有以下四种方法原型：l getBean(String name)l getBean(Class&lt;T&gt; type)l getBean(String name,Class&lt;T&gt; type)l getBean(String name,Object[...
SSM整合之spring笔记(IOC 获取bean的三种方式)（P063—P069）
m0_59281987的博客
10-28 787
SSM整合之spring笔记(IOC 获取bean的三种方式)（P063—P069）
Spring IOC（依赖注入，getBean）
T Yuan
05-12 1万+
入口DefaultListableBeanFactory的getBean类继承图流程总体流程 DefaultListableBeanFactory的getBean、doGetBeanpublic <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException { return d
Spring IoC源码学习：getBean 详解
程序员囧辉
02-27 1万+
前言 接着Spring IoC：finishBeanFactoryInitialization详解，我们正式开始学习获取bean实例方法，该方法是Spring最核心的方法。 正文 单击 preInstantiateSingletons方法里的getBean(beanName)代码，进入该方法。 getBean @Override public Object ...
完整版Java web开发教程PPT课件 Java开发进阶教程 第13章 spring ioc aop（共18页）.pptx
12-25
本资源是一份完整的Java web开发教程，涵盖了Java进阶课程的多个关键章节，其中第13章专门讲解Spring的IoC（Inversion of Control）和AOP（Aspect Oriented Programming）技术。Spring是一个2003年由Rod Johnson发起...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值