spring getBean()方法解析概述

本文主要是介绍spring getBean()方法解析概述，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1.getBean(beanName) 整体概述

1.transformedBeanName(name)

name可能是别名，将别名(alias)解析成真正的beanName
截取&beanName中&字符，获得beanName

2.getSingleton(beanName) 从缓存中获取bean，有三个缓存集合，循环依赖会有单章讲解。

singletonObjects ：缓存已经初始化完成的bean对象
earlySingletonObjects : 循环引用中，提前暴露的bean对象
singletonFactories ：会调用getObject() 方法，返回一个earlyBean，放到earlySingletonObjects中，主要为了解决循环依赖时动态代理的问题

3.如果缓存中有bean对象，调用getObjectForBeanInstance 方法

当前bean不是FactoryBean，直接返回对象
当前bean是FactoryBean，且beanName中包换‘&’符号，直接放回对象。
当前bean是FactoryBean，且beanName中不包含‘&’符号，调用当前bean的getObject()方法，返回getObject()方法的返回值。

4.如果bean中没有缓存对象

检查是否有父工厂，有就要尝试从父工厂中拿，这里就实现了springmvc中的父子容器
检查是否存在依赖的bean，有则优先实例化依赖的bean
如果父工厂为空，或没有该bean，调用createBean(beanName, mbd, args)方法，创建对象，这里会判断scope类型，分别创建。

5.检查指定类型（requiredType）是否与获得Bean实例的类型匹配，不匹配就要使用转换器进行转换，转换失败就抛出异常。

6.返回最终bean对象。

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


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

	    //name可能是别名，将别名(alias)解析成真正的beanName
        //截取&beanName中&字符，获得beanName
		String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
		// 检查单例缓存中是否有单例对象
		Object sharedInstance = getSingleton(beanName);
		// 如果有bean的单例对象，且没有创建bean实例时要使用的参数
		if (sharedInstance != null && args == null) {
			// 当前bean不是FactoryBean，直接返回对象
            // 当前bean是FactoryBean，且beanName中包换‘&’符号，直接放回对象。
            // 当前bean是FactoryBean，且beanName中不包含‘&’符号，调用当前bean的getObject(）        
            //         方法，返回getObject()方法的返回值。
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// 原型模式下如果存在循环依赖的情况，那么直接抛出异常
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// 当前bean不存在，就检查是否有父工厂
			BeanFactory parentBeanFactory = getParentBeanFactory();
			// 如果当前工厂中不包含beanName，那么就尝试从父容器中获取
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				//如果name前面有'&'，则会返回'&'+规范名称
				String nameToLookup = originalBeanName(name);
				// 如果父工厂是AbstractBeanFactory
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					// 调用父工厂的doGetBean方法
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly);
				}
                //有参数
				else if (args != null) {
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
                //有类型
				else if (requiredType != null) {
					// No args -> delegate to standard getBean method.
					// 没有创建bean实例时要使用的参数 -> 委托给标准的getBean方法。
					// 使用父工厂获取该bean对象,通bean全类名和所需的bean类型
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
				else {
					return (T) parentBeanFactory.getBean(nameToLookup);
				}
			}
		
			if (!typeCheckOnly) {
				// 将beanName标记为已经创建
				markBeanAsCreated(beanName);
			}

			try {
				// 当前bean的BeanDefinition是否有parentBeanDefinition,如果有就需要合并
				RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				// 检查mbd是否时抽象的
				checkMergedBeanDefinition(mbd, beanName, args);

				// 如果是否存在依赖的bean，有则优先实例化依赖的bean
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						// dep所指定的bean，和当前bean不能相互依赖
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						// 注册依赖关系
						registerDependentBean(dep, beanName);
						try {
							// 实例化被依赖的Bean
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				// Create bean instance.
				// 创建单例bean
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							// 真正创建bean实例
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							destroySingleton(beanName);
							throw ex;
						}
					});
					// 当前bean不是FactoryBean，直接返回对象
                    // 当前bean是FactoryBean，且beanName中包换‘&’符号，直接放回对象。
                    // 当前bean是FactoryBean，且beanName中不包含‘&’符号，调用当前bean的        
                    //            getObject()方法，返回getObject()方法的返回值。
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				// 原型模式的bean对象创建
				else if (mbd.isPrototype()) {
					Object prototypeInstance = null;
					try {
						// beanName添加到prototypesCurrentlyInCreation，标记为正在创建
						beforePrototypeCreation(beanName);
						// 创建一个bean实例
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						// 将beanName从prototypesCurrentlyInCreation移除，表示创建完成
						afterPrototypeCreation(beanName);
					}
	                // 当前bean不是FactoryBean，直接返回对象
                    // 当前bean是FactoryBean，且beanName中包换‘&’符号，直接放回对象。
                    // 当前bean是FactoryBean，且beanName中不包含‘&’符号，调用当前bean的        
                    //            getObject()方法，返回getObject()方法的返回值。
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				else {
					String scopeName = mbd.getScope();
					if (!StringUtils.hasLength(scopeName)) {
						throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
					}
					// springmvc中，有session 或 request作用域
					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, () -> {
							// 类似与ProtoType,不能循环依赖
							beforePrototypeCreation(beanName);
							try {
								//创建一个bean实例
								return createBean(beanName, mbd, args);
							}
							finally {
								afterPrototypeCreation(beanName);
							}
						});
						// 当前bean不是FactoryBean，直接返回对象
                        // 当前bean是FactoryBean，且beanName中包换‘&’符号，直接放回对象。
                        // 当前bean是FactoryBean，且beanName中不包含‘&’符号，调用当前bean的        
                        //            getObject()方法，返回getObject()方法的返回值。
						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创建失败后，对缓存的元数据执行适当的清理
				cleanupAfterBeanCreationFailure(beanName);
				throw ex;
			}
		}

		// 如果requiredType不为null&&bean不是requiredType的实例
		if (requiredType != null && !requiredType.isInstance(bean)) {
			try {
				// 获取类型转换器，将bean转换为requiredType
				T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
				// 如果convertedBean为null，转换失败
				if (convertedBean == null) {
					throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
				}
				return convertedBean;
			}
			catch (TypeMismatchException ex) {
				
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		// 将bean返回
		return (T) bean;
	}

2.createBean（）方法概述

1.resolveBeanClass(mbd, beanName) ：获取当前bean的class对象，因为mbd中beanClassName属性值可能是字符串类型，需要反射加载。

2.mbdToUse.prepareMethodOverrides() ：对lookup-method replace-method 修饰的方法，设置为未覆盖(意味着需要后面进行覆盖)。后面bean实例化时会有方法和这里对应。

3.resolveBeforeInstantiation(beanName, mbdToUse) : 调用InstantiationAwareBeanPostProcessor后置处理器的postProcessBeforeInstantiation（），如果有对象返回，则后续实例化工作不再继续。bean的后置处理的分类在这里https://blog.csdn.net/weixin_41009314/article/details/117293706 有说明。

4.doCreateBean(beanName, mbdToUse, args) ：创建bean对象。

    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		if (logger.isTraceEnabled()) {
			logger.trace("Creating instance of bean '" + beanName + "'");
		}
		RootBeanDefinition mbdToUse = mbd;

		// 锁定class，mbd中存储的可能是bean的Class对象，也可能是类的全限定类名的字符串。
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		// 全限定类名的字符串解析成Class对象，需要设置BeanClass属性，再次创建时可复用
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			// 重新创建一个RootBeanDefinition对象
			mbdToUse = new RootBeanDefinition(mbd);
			// 设置BeanClass属性值
			mbdToUse.setBeanClass(resolvedClass);
		}

		// 验证及准备覆盖的方法,lookup-method  replace-method，
		// 当需要创建的bean对象中包含了lookup-method和replace-method标签的时候，会产生覆盖操作
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
			//调用InstantiationAwareBeanPostProcessor后置处理器的postProcessBeforeInstantiation（），
			// 如果有对象返回，则后续实例化工作不再继续
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
			if (bean != null) {
				return bean;
			}
		}
		catch (Throwable ex) {
			throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
					"BeanPostProcessor before instantiation of bean failed", ex);
		}

		try {
			// 实际创建bean的调用
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
			// A previously detected exception with proper bean creation context already,
			// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
		}
	}

3.doCreateBean（）整体概述

1.创建bean对象，用BeanWrapper 类包装放回。

2.调用MergedBeanDefinitionPostProcessor 的postProcessMergedBeanDefinition（）方法，主要用于@Autowire, @Resource 标记的属性注入（找到需要注入的属性并缓存）。

3.在三级缓存singletonFactories中添加getEarlyBeanReference（）方法，用以解决循环依赖问题。

4.调用populateBean（）方法，对bean的属性进行填充。

5.调用initializeBean（）方法，对bean进行初始化。

6.假设exposedObject对象应该被代理，由于循环依赖提前生成了代理对象（earlySingletonObjects中），initializeBean()中返回的对象可能是未被代理，因此需要将提前生成的代理对象赋值给exposedObject，并返回。

    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		// 持有创建出来的bean对象
		BeanWrapper instanceWrapper = null;
		// 从缓存中获取
		if (mbd.isSingleton()) {
			// 如果是单例对象，从factorybean实例缓存中移除当前bean定义信息
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		// 没有就创建实例
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		// 从包装类中获取bean
		Object bean = instanceWrapper.getWrappedInstance();
		// 获取具体的bean对象的Class属性
		Class<?> beanType = instanceWrapper.getWrappedClass();
		// 如果不等于NullBean类型，那么修改目标类型
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		// 允许beanPostProcessor去修改合并的beanDefinition
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					// MergedBeanDefinitionPostProcessor后置处理器修改合并bean的定义
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
		// 判断当前bean是否需要提前曝光：单例&允许循环依赖&当前bean正在创建中（检测循环依赖）
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			// 为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

		}

		// Initialize the bean instance.
		// 初始化bean实例
		Object exposedObject = bean;
		try {
			// 对bean的属性进行填充，将各个属性值注入，
			populateBean(beanName, mbd, instanceWrapper);
			// 执行初始化逻辑，动态代理也在这里实现
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		catch (Throwable ex) {
			if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
				throw (BeanCreationException) ex;
			}
			else {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
			}
		}

		if (earlySingletonExposure) {
			// 从缓存中获取具体的对象
			Object earlySingletonReference = getSingleton(beanName, false);
			// 检测到有循环依赖
			if (earlySingletonReference != null) {
				// 如果bean在循环依赖情况下，提前被代理，这里的exposedObject并不会被代理，因此需要赋值操作。
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					for (String dependentBean : dependentBeans) {
						// 返回false说明依赖还没实例化好
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
					// 因为bean创建后所依赖的bean一定是已经创建的
					// actualDependentBeans不为空则表示当前bean创建后其依赖的bean却没有全部创建完，也就是说存在循环依赖
					if (!actualDependentBeans.isEmpty()) {
						throw new BeanCurrentlyInCreationException(beanName,
								"Bean with name '" + beanName + "' has been injected into other beans [" +
								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
								"] in its raw version as part of a circular reference, but has eventually been " +
								"wrapped. This means that said other beans do not use the final version of the " +
								"bean. This is often the result of over-eager type matching - consider using " +
								"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		// Register bean as disposable.
		try {
			// 注册bean对象，方便后续在容器销毁的时候销毁对象
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

4.createBeanInstance() 方法解析

1.判断beanDefinition 中是否设置Supplier，可提前实例化，不需要走后面推断构造器，再实例化的过程。

2.判断beanDefinition 中是否有工厂方法（FactoryMethod），可提前实例化，不需要走后面推断构造器，再实例化的过程。

3.判断构造方法是否已经解析过来，如果已经解析过，直接实例化，没有解析过需要根据【注解@Autowire，参数（propertyValues）】等推断构造方法，再实例化


    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// 获取bean的class对象
		Class<?> beanClass = resolveBeanClass(mbd, beanName);

		// class不为空，并且访问权限是public
		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
		}

		// 判断beanDefinition中是否设置InstanceSupplier，可通过种方式实例化对象。
		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		// 判断当前bean是否使用FactoryMethod实例化bean
		if (mbd.getFactoryMethodName() != null) {
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

	
		// 标记当前bean的构造函数是否已经被解析
		boolean resolved = false;
		// 当前bean是否开启自动注入模式
		boolean autowireNecessary = false;
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
                // resolvedConstructorOrFactoryMethod 保存已经被解析的构造方法
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
                    //constructorArgumentsResolved 表示进入过autowireConstructor（）方法，也就是进行过自动注入
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		// 构造函数是否已经被解析
		if (resolved) {
			// 进行过自动注入
			if (autowireNecessary) {
				// 进行过自动注入，即使构造函数已经被解析过，还是需要进入自动注入的方法
                // 原因：在自动注入的情况下，构造函数可能不是无参构造，也就是会有参数
                //       下面的instantiateBean(beanName, mbd) 只能实例化无参构造，                
                //       autowireConstructor（）即可以实例化无参构造，也可以实例化有参构造
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				// 使用默认构造函数构造
				return instantiateBean(beanName, mbd);
			}
		}

		// 调用SmartInstantiationAwareBeanPostProcessor 的determineCandidateConstructors（）方法 
        // 主要用与解析@Autowire标注的构造方法
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		// 以下情况符合其一即可进入
		// 1、存在可选构造方法（@Autowire修饰）
		// 2、自动装配模型为构造函数自动装配
		// 3、给BeanDefinition中设置了构造参数值
		// 4、有参与构造函数参数列表的参数
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// Preferred constructors for default construction?
		// 找出最合适的默认构造方法，一般返回null
		ctors = mbd.getPreferredConstructors();
		if (ctors != null) {
			return autowireConstructor(beanName, mbd, ctors, null);
		}

		// 使用默认无参构造函数创建对象
		return instantiateBean(beanName, mbd);
	}

注：getBean流程中有很多细节，需要新的章节说明，这里无法展开。本文为个人理解和参考他人，如有问题请指出。

这篇关于spring getBean()方法解析概述的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

spring getBean()方法解析概述

1.getBean(beanName) 整体概述

2.createBean（）方法概述

3.doCreateBean（）整体概述

4.createBeanInstance() 方法解析

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯