Spring5 DI

最新推荐文章于 2022-10-10 09:35:01 发布
最新推荐文章于 2022-10-10 09:35:01 发布
阅读量408 收藏
点赞数
分类专栏： Spring5学习 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41194872/article/details/113174991
版权

文章目录


文章参考谭勇德老师的《Spring5核心原理与30个类手写实战》

我理解的DI

DI(Dependency Injection, 依赖注入)

当Spring IoC容器完成Bean定义资源的定位、载入和解析注册后，IoC容器就可以管理Bean定义的相关数据，IoC容器中维护着一个保存有BeanDefiniton（保存Bean的定义信息）的HashMap，此时IoC容器还没有对管理的Bean进行依赖注入。依赖注入就是指对象被动的就受依赖类而不自己主动寻找，容器实例化对象时主动将它的依赖类注入给它。

依赖注入发生的时间

两种情况

  1. 在用户第一次调用getBean()方法时，IoC容器触发依赖注入。
  2. 配置了< bean >元素的lazy-init=false属性时，在解析注册Bean定义时进行预实例化，触发依赖注入。

寻找获取Bean的入口

BeanFactory中可以找到getBean(String…)方法，但他的具体实现是在AbstractBeanFactory中，AbstractBeanFactory中的部分方法如下：
AbstractBeanFactory类方法
真正实现向IoC容器中获取Bean的功能，也是触发依赖注入的方法是doGetBean(String, Class< T>, Object[], boolean)，源码如下：

@SuppressWarnings("unchecked")
	protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {
			//根据指定名称获取被管理的Bean的名称，如果指定名称是别名，则将别名转化为规范的Bean名称
		String beanName = transformedBeanName(name);
		Object bean;

		//先从缓存中读取是否已经有被创建过的单例模式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 + "'");
				}
			}
			//获取给定Bean的实例对象
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// 缓存中已经有原型模式的Bean，但是由于循环引用导致实例化对象失败
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// 检查Bean定义是否存在，首先检查当前的BeanFactory中是否能获取需要的Bean，如果不能则向父类容器查找
			BeanFactory parentBeanFactory = getParentBeanFactory();
			//当前父类容器存在且当前容器中不存在指定的Bean
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// 解析指定Bean名称的原始名称
				String nameToLookup = originalBeanName(name);
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly);
				}
				else if (args != null) {
					// 委派父容器根据指定名称和参数查找
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}

			if (!typeCheckOnly) {
			//向容器标记指定的Bean已经被创建
				markBeanAsCreated(beanName);
			}

			try {
			//根据指定Bean名称获取其父级Bean定义，主要解决Bean继承时子类和父类功能属性问题
				RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// 保证当前Bean所依赖Bean的初始化
				String[] dependsOn = mbd.getDependsOn();
				//当前Bean有依赖Bean
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						//把被依赖的Bean注入注册给当前的Bean
						registerDependentBean(dep, beanName);
						try {
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				// 创建Bean实例
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							//显式的从容器中单例模式的Bean缓存中清楚实例对象
							destroySingleton(beanName);
							throw ex;
						}
					});
					//获取指定Bean的实例对象
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				//创建原型模式的Bean实例对象
				else if (mbd.isPrototype()) {
					// 原型模式每次都会创建一个新对象
					Object prototypeInstance = null;
					try {
					//注册当前创建的原型对象
						beforePrototypeCreation(beanName);
						//创建Bean的对象实例
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
					//告诉IoC容器不再创建指定Bean的原型对象
						afterPrototypeCreation(beanName);
					}
					//获取指定Bean的实例对象
					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 + "'");
					}
					Scope scope = this.scopes.get(scopeName);
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
					}
					try {
						Object scopedInstance = scope.get(beanName, () -> {
							beforePrototypeCreation(beanName);
							try {
								return createBean(beanName, mbd, args);
							}
							finally {
								afterPrototypeCreation(beanName);
							}
						});
						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;
			}
		}

		// 对创建的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;
	}

在Spring中如果Bean定义为单例模式的，则容器在创建之前先从缓存中查找，确保整个容器中只有一个实例对象。如果Bean定义为原型模式，则容器每次都会创建一个新对象。

开始实例化

doGetBean()方法中只根据Bean定义的不同模式采取不同的Bean实例对象创建方式，更具体地创建过程由ObjectFactory接口的匿名内部类的createBean()方法完成，createBean()方法的实现由接口的实现类AbstractAutowireCapableBeanFactory实现，源码如下：

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

		if (logger.isDebugEnabled()) {
			logger.debug("Creating instance of bean '" + beanName + "'");
		}
		RootBeanDefinition mbdToUse = mbd;
		// 判断需要创建的Bean是否可以实例化，即是否可以通过当前的类加载器加载
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		// Prepare method overrides.
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
			// 如果Bean配置了初始化前和初始化后的处理器，则试图返回一个一个需要创建Bean的代理对象
			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.isDebugEnabled()) {
				logger.debug("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);
		}
	}

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

		// 封装要创建的Bean对象
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		Object bean = instanceWrapper.getWrappedInstance();
		//获取实例化对象的类型
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// 调用PostProcessor后置处理器
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}
		//向容器中缓存单例模式的Bean对象，防止循环引用
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Bean对象的初始化，依赖注入在此触发
		Object exposedObject = bean;
		try {
		//将Bean实例对象封装，并将Bean定义中配置的属性赋值给实例对象
			populateBean(beanName, mbd, instanceWrapper);
			//初始化Bean对象
			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) {
		//获取指定名称的已注册的单例模式的Bean对象
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				if (exposedObject == bean) {
				//当前实例化的Bean初始化完成
					exposedObject = earlySingletonReference;
				}
				//当前Bean依赖其他Bean，当发生循环引用时不允许创建新的实例对象
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					//获取当前Bean所依赖的其他Bean
					for (String dependentBean : dependentBeans) {
					//对依赖Bean进行类型检查
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
					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.");
					}
				}
			}
		}

		//注册完成依赖注入的Bean
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

选择Bean实例化策略

在createBean()方法中需要用到createBeanInstance()封装Bean对象成BeanWrapper类型，源码如下：

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// 确定Bean是可以实例化的
		Class<?> beanClass = resolveBeanClass(mbd, beanName);
		//使用工厂方法对Bean进行实例化
		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());
		}

		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		if (mbd.getFactoryMethodName() != null) {
		//调用工厂方法进行实例化
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// 使用容器的自动装配方法进行实例化
		boolean resolved = false;
		boolean autowireNecessary = false;
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		if (resolved) {
			if (autowireNecessary) {
			//配置了自动装配属性，使用容器的自动装配进行实例化，容器的自动装配根据参数类型匹配Bean的构造方法
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
			//使用默认的无参构造方法进行实例化
				return instantiateBean(beanName, mbd);
			}
		}

		// 使用Bean的构造方法进行实例化
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			使用容器的自动装配特性，调用匹配的构造方法进行实例化
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// 使用默认的无参构造方法进行实例化
		return instantiateBean(beanName, mbd);
	}


protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
		try {
			Object beanInstance;
			if (System.getSecurityManager() != null) {
			//根据实例化策略创建对象
				beanInstance = AccessController.doPrivileged(
						(PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
						getAccessControlContext());
			}
			else {
			//将实例化的对象封装起来
				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
			}
			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
			initBeanWrapper(bw);
			return bw;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
		}
	}

执行Bean实例化

在使用默认的无参构造方法创建Bean实例对象时，getInstantiationStrategy().instantiate(mbd, beanName, this)方法调用了SimpleInstantiationStrategy类中的实例化方法，源码如下：

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
		// Don't override the class with CGLIB if no overrides.
		if (!bd.hasMethodOverrides()) {
			Constructor<?> constructorToUse;
			synchronized (bd.constructorArgumentLock) {
			//获取对象的构造方法或工厂方法
				constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
				//没有构造方法且没有工厂方法
				if (constructorToUse == null) {
					final Class<?> clazz = bd.getBeanClass();
					//判断实例化的Bean是否是接口
					if (clazz.isInterface()) {
						throw new BeanInstantiationException(clazz, "Specified class is an interface");
					}
					try {
						if (System.getSecurityManager() != null) {
						//获取Bean的构造方法
							constructorToUse = AccessController.doPrivileged(
									(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
						}
						else {
							constructorToUse = clazz.getDeclaredConstructor();
						}
						bd.resolvedConstructorOrFactoryMethod = constructorToUse;
					}
					catch (Throwable ex) {
						throw new BeanInstantiationException(clazz, "No default constructor found", ex);
					}
				}
			}
			//使用BeanUtils进行实例化，通过反射机制进行实例化
			return BeanUtils.instantiateClass(constructorToUse);
		}
		else {
			// 使用CGLib进行实例化
			return instantiateWithMethodInjection(bd, beanName, owner);
		}
	}

instantiateWithMethodInjection(bd, beanName, owner)方法调用SimpleInstantiationStrategy的子类CglibSubclassingInstantiationStrategy通过CGLib来进行实例化，源码如下：

public Object instantiate(@Nullable Constructor<?> ctor, @Nullable Object... args) {
//创建代理子类
			Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
			Object instance;
			if (ctor == null) {
				instance = BeanUtils.instantiateClass(subclass);
			}
			else {
				try {
					Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
					instance = enhancedSubclassConstructor.newInstance(args);
				}
				catch (Exception ex) {
					throw new BeanInstantiationException(this.beanDefinition.getBeanClass(),
							"Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", ex);
				}
			}
			// SPR-10785: set callbacks directly on the instance instead of in the
			// enhanced class (via the Enhancer) in order to avoid memory leaks.
			Factory factory = (Factory) instance;
			factory.setCallbacks(new Callback[] {NoOp.INSTANCE,
					new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
					new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
			return instance;
		}


private Class<?> createEnhancedSubclass(RootBeanDefinition beanDefinition) {
			Enhancer enhancer = new Enhancer();
			enhancer.setSuperclass(beanDefinition.getBeanClass());
			enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
			if (this.owner instanceof ConfigurableBeanFactory) {
				ClassLoader cl = ((ConfigurableBeanFactory) this.owner).getBeanClassLoader();
				enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(cl));
			}
			enhancer.setCallbackFilter(new MethodOverrideCallbackFilter(beanDefinition));
			enhancer.setCallbackTypes(CALLBACK_TYPES);
			//生成实例对象
			return enhancer.createClass();
		}

准备依赖注入

通过以上分析知，Bean的依赖注入主要分为两个步骤，首先调用createBeanInstance()方法生成Bean所包含的Java对象实例，然后调用populateBean()方法对Bean属性的依赖注入进行处理。populateBean()方法源码如下：

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		if (bw == null) {
			if (mbd.hasPropertyValues()) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			}
			else {
				// Skip property population phase for null instance.
				return;
			}
		}

		// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
		// state of the bean before properties are set. This can be used, for example,
		// to support styles of field injection.
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						return;
					}
				}
			}
		}
		//获取容器在解析Bean定义资源时为BeanDefiniton设置的属性值
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			// Add property values based on autowire by name if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// Add property values based on autowire by type if applicable.
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}

		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

		if (hasInstAwareBpps || needsDepCheck) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			if (hasInstAwareBpps) {
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvs == null) {
							return;
						}
					}
				}
			}
			if (needsDepCheck) {
				checkDependencies(beanName, mbd, filteredPds, pvs);
			}
		}

		if (pvs != null) {
		//对属性进行注入
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}


protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
		if (pvs.isEmpty()) {
			return;
		}

		if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
			((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
		}
		//封装属性值
		MutablePropertyValues mpvs = null;
		List<PropertyValue> original;

		if (pvs instanceof MutablePropertyValues) {
			mpvs = (MutablePropertyValues) pvs;
			if (mpvs.isConverted()) {
				// Shortcut: use the pre-converted values as-is.
				try {
				//为实例化对象设置属性值
					bw.setPropertyValues(mpvs);
					return;
				}
				catch (BeansException ex) {
					throw new BeanCreationException(
							mbd.getResourceDescription(), beanName, "Error setting property values", ex);
				}
			}
			//获取属性值对象的原始类型值
			original = mpvs.getPropertyValueList();
		}
		else {
			original = Arrays.asList(pvs.getPropertyValues());
		}
		//获取用户自定义的类型转换
		TypeConverter converter = getCustomTypeConverter();
		if (converter == null) {
			converter = bw;
		}
		//创建一个Bean定义属性值解析器，将Bean定义中的属性值解析为Bean实例对象的实际值
		BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

		// Create a deep copy, resolving any references for values.
		List<PropertyValue> deepCopy = new ArrayList<>(original.size());
		boolean resolveNecessary = false;
		for (PropertyValue pv : original) {
		//属性值不需要转换
			if (pv.isConverted()) {
				deepCopy.add(pv);
			}
			//需要转换
			else {
				String propertyName = pv.getName();
				//原始的属性值
				Object originalValue = pv.getValue();
				//转换属性值
				Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
				Object convertedValue = resolvedValue;
				//属性值是否可以转换
				boolean convertible = bw.isWritableProperty(propertyName) &&
						!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
				if (convertible) {
				//使用用户自定义的类型转换器转换属性值
					convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
				}
				//存储属性转换后的值，避免每次属性注入时的转换工作
				if (resolvedValue == originalValue) {
					if (convertible) {
					//设置属性转换后的值
						pv.setConvertedValue(convertedValue);
					}
					deepCopy.add(pv);
				}
				//属性是可转换的，且属性原始值是字符串类型的，属性的原始类型值不是动态生成的字符串，属性的原始值不是集合或者数组类型的
				else if (convertible && originalValue instanceof TypedStringValue &&
						!((TypedStringValue) originalValue).isDynamic() &&
						!(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
					pv.setConvertedValue(convertedValue);
					//重新封装属性值
					deepCopy.add(pv);
				}
				else {
					resolveNecessary = true;
					deepCopy.add(new PropertyValue(pv, convertedValue));
				}
			}
		}
		if (mpvs != null && !resolveNecessary) {
		//标记属性值已经转换过
			mpvs.setConverted();
		}

		// 进行属性依赖注入
		try {
			bw.setPropertyValues(new MutablePropertyValues(deepCopy));
		}
		catch (BeansException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Error setting property values", ex);
		}
	}

属性的注入过程分两种：

  1. 属性值类型不需要强制转换时，不需要解析属性值，直接注入
  2. 属性值类型需要强制转换时，首先解析属性值，将解析后的属性值进行依赖注入

解析属性依赖注入规则

对属性值的解析是在BeanDefinitionValueResolver类的resolveValueIfNecessary()方法中进行的，源码如下：

public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
		//解析引用类型的属性
		if (value instanceof RuntimeBeanReference) {
			RuntimeBeanReference ref = (RuntimeBeanReference) value;
			//调用引用类型属性的解析方法
			return resolveReference(argName, ref);
		}
		//对引用容器中另一个Bean名称的属性进行解析
		else if (value instanceof RuntimeBeanNameReference) {
			String refName = ((RuntimeBeanNameReference) value).getBeanName();
			refName = String.valueOf(doEvaluate(refName));
			//从容器中获取指定名称的Bean
			if (!this.beanFactory.containsBean(refName)) {
				throw new BeanDefinitionStoreException(
						"Invalid bean name '" + refName + "' in bean reference for " + argName);
			}
			return refName;
		}//对Bean类型属性的解析，主要指Bean中的内部类
		else if (value instanceof BeanDefinitionHolder) {
			// Resolve BeanDefinitionHolder: contains BeanDefinition with name and aliases.
			BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;
			//调用Bean类型属性的解析方法
			return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
		}
		else if (value instanceof BeanDefinition) {
			// Resolve plain BeanDefinition, without contained name: use dummy name.
			BeanDefinition bd = (BeanDefinition) value;
			String innerBeanName = "(inner bean)" + BeanFactoryUtils.GENERATED_BEAN_NAME_SEPARATOR +
					ObjectUtils.getIdentityHexString(bd);
			return resolveInnerBean(argName, innerBeanName, bd);
		}
		//对集合数组类型的属性进行解析
		else if (value instanceof ManagedArray) {
			// May need to resolve contained runtime references.
			ManagedArray array = (ManagedArray) value;
			//获取数组的类型
			Class<?> elementType = array.resolvedElementType;
			if (elementType == null) {
			//获取数组元素的类型
				String elementTypeName = array.getElementTypeName();
				if (StringUtils.hasText(elementTypeName)) {
					try {
					//使用反射机制创建指定类型的对象
						elementType = ClassUtils.forName(elementTypeName, this.beanFactory.getBeanClassLoader());
						array.resolvedElementType = elementType;
					}
					catch (Throwable ex) {
						// Improve the message by showing the context.
						throw new BeanCreationException(
								this.beanDefinition.getResourceDescription(), this.beanName,
								"Error resolving array type for " + argName, ex);
					}
				}
				//没有获取到数组的类型，也没有获取到数组元素的类型，则直接设置数组的类型为Object
				else {
					elementType = Object.class;
				}
			}
			//创建指定类型的数组
			return resolveManagedArray(argName, (List<?>) value, elementType);
		}
		//解析List类型的属性值
		else if (value instanceof ManagedList) {
			// May need to resolve contained runtime references.
			return resolveManagedList(argName, (List<?>) value);
		}
		//解析Set类型的属性值
		else if (value instanceof ManagedSet) {
			// May need to resolve contained runtime references.
			return resolveManagedSet(argName, (Set<?>) value);
		}
		//解析Map类型的属性值
		else if (value instanceof ManagedMap) {
			// May need to resolve contained runtime references.
			return resolveManagedMap(argName, (Map<?, ?>) value);
		}
		//解析props类型的属性值
		else if (value instanceof ManagedProperties) {
			Properties original = (Properties) value;
			Properties copy = new Properties();
			original.forEach((propKey, propValue) -> {
				if (propKey instanceof TypedStringValue) {
					propKey = evaluate((TypedStringValue) propKey);
				}
				if (propValue instanceof TypedStringValue) {
					propValue = evaluate((TypedStringValue) propValue);
				}
				if (propKey == null || propValue == null) {
					throw new BeanCreationException(
							this.beanDefinition.getResourceDescription(), this.beanName,
							"Error converting Properties key/value pair for " + argName + ": resolved to null");
				}
				copy.put(propKey, propValue);
			});
			return copy;
		}
		//解析字符串类型的属性值
		else if (value instanceof TypedStringValue) {
			// Convert value to target type here.
			TypedStringValue typedStringValue = (TypedStringValue) value;
			Object valueObject = evaluate(typedStringValue);
			try {
			//获取属性的目标类型
				Class<?> resolvedTargetType = resolveTargetType(typedStringValue);
				if (resolvedTargetType != null) {
				//对目标类型的属性进行解析
					return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
				}
				else {
					return valueObject;
				}
			}
			catch (Throwable ex) {
				// Improve the message by showing the context.
				throw new BeanCreationException(
						this.beanDefinition.getResourceDescription(), this.beanName,
						"Error converting typed String value for " + argName, ex);
			}
		}
		else if (value instanceof NullBean) {
			return null;
		}
		else {
			return evaluate(value);
		}
	}

//解析引用类型的属性值
private Object resolveReference(Object argName, RuntimeBeanReference ref) {
		try {
			Object bean;
			//获取引用的Bean名称
			String refName = ref.getBeanName();
			refName = String.valueOf(doEvaluate(refName));
			//如果引用的对象在父类容器中，则从父类容器中获取指定的引用对象
			if (ref.isToParent()) {
				if (this.beanFactory.getParentBeanFactory() == null) {
					throw new BeanCreationException(
							this.beanDefinition.getResourceDescription(), this.beanName,
							"Can't resolve reference to bean '" + refName +
									"' in parent factory: no parent factory available");
				}
				bean = this.beanFactory.getParentBeanFactory().getBean(refName);
			}
			//从当前容器中获取指定的引用对象，如果指定的引用对象没有被实例化，则会递归触发引用对象的初始化和依赖注入
			else {
				bean = this.beanFactory.getBean(refName);
				//当前实例化对象依赖的引用对象
				this.beanFactory.registerDependentBean(refName, this.beanName);
			}
			if (bean instanceof NullBean) {
				bean = null;
			}
			return bean;
		}
		catch (BeansException ex) {
			throw new BeanCreationException(
					this.beanDefinition.getResourceDescription(), this.beanName,
					"Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
		}
	}

//解析Array类型的属性值
private Object resolveManagedArray(Object argName, List<?> ml, Class<?> elementType) {
//创建一个指定类型的数组
		Object resolved = Array.newInstance(elementType, ml.size());
		for (int i = 0; i < ml.size(); i++) {
		//递归解析Array的每一个元素，并将解析后的值设置到resolved数组中，索引为i
			Array.set(resolved, i, resolveValueIfNecessary(new KeyedArgName(argName, i), ml.get(i)));
		}
		return resolved;
	}

注入赋值

注入赋值是通过setPropertyValues()方法实现的，由AbstractPropertyAccessor的实现类AbstractNestablePropertyAccessor实现，源码如下：

protected void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
		if (tokens.keys != null) {
			processKeyedProperty(tokens, pv);
		}
		else {
			processLocalProperty(tokens, pv);
		}
	}


private void processKeyedProperty(PropertyTokenHolder tokens, PropertyValue pv) {
//调用属性的getter方法获取属性值
		Object propValue = getPropertyHoldingValue(tokens);
		PropertyHandler ph = getLocalPropertyHandler(tokens.actualName);
		if (ph == null) {
			throw new InvalidPropertyException(
					getRootClass(), this.nestedPath + tokens.actualName, "No property handler found");
		}
		Assert.state(tokens.keys != null, "No token keys");
		String lastKey = tokens.keys[tokens.keys.length - 1];
		//注入array类型的值
		if (propValue.getClass().isArray()) {
			Class<?> requiredType = propValue.getClass().getComponentType();
			int arrayIndex = Integer.parseInt(lastKey);
			Object oldValue = null;
			try {
				if (isExtractOldValueForEditor() && arrayIndex < Array.getLength(propValue)) {
					oldValue = Array.get(propValue, arrayIndex);
				}
				Object convertedValue = convertIfNecessary(tokens.canonicalName, oldValue, pv.getValue(),
						requiredType, ph.nested(tokens.keys.length));
				int length = Array.getLength(propValue);
				if (arrayIndex >= length && arrayIndex < this.autoGrowCollectionLimit) {
					Class<?> componentType = propValue.getClass().getComponentType();
					Object newArray = Array.newInstance(componentType, arrayIndex + 1);
					System.arraycopy(propValue, 0, newArray, 0, length);
					setPropertyValue(tokens.actualName, newArray);
					propValue = getPropertyValue(tokens.actualName);
				}
				Array.set(propValue, arrayIndex, convertedValue);
			}
			catch (IndexOutOfBoundsException ex) {
				throw new InvalidPropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
						"Invalid array index in property path '" + tokens.canonicalName + "'", ex);
			}
		}
		//注入list类型的属性值
		else if (propValue instanceof List) {
			Class<?> requiredType = ph.getCollectionType(tokens.keys.length);
			List<Object> list = (List<Object>) propValue;
			int index = Integer.parseInt(lastKey);
			Object oldValue = null;
			if (isExtractOldValueForEditor() && index < list.size()) {
				oldValue = list.get(index);
			}
			Object convertedValue = convertIfNecessary(tokens.canonicalName, oldValue, pv.getValue(),
					requiredType, ph.nested(tokens.keys.length));
			int size = list.size();
			//如果list的长度大于属性值的长度，则将多余的元素赋值为null
			if (index >= size && index < this.autoGrowCollectionLimit) {
				for (int i = size; i < index; i++) {
					try {
						list.add(null);
					}
					catch (NullPointerException ex) {
						throw new InvalidPropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
								"Cannot set element with index " + index + " in List of size " +
								size + ", accessed using property path '" + tokens.canonicalName +
								"': List does not support filling up gaps with null elements");
					}
				}
				list.add(convertedValue);
			}
			else {
				try {
					list.set(index, convertedValue);
				}
				catch (IndexOutOfBoundsException ex) {
					throw new InvalidPropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
							"Invalid list index in property path '" + tokens.canonicalName + "'", ex);
				}
			}
		}
		//注入map类型的属性值
		else if (propValue instanceof Map) {
		//获取map集合key的类型
			Class<?> mapKeyType = ph.getMapKeyType(tokens.keys.length);
			//获取map集合value的类型
			Class<?> mapValueType = ph.getMapValueType(tokens.keys.length);
			Map<Object, Object> map = (Map<Object, Object>) propValue;
			// IMPORTANT: Do not pass full property name in here - property editors
			// must not kick in for map keys but rather only for map values.
			TypeDescriptor typeDescriptor = TypeDescriptor.valueOf(mapKeyType);
			//解析map类型的属性key值
			Object convertedMapKey = convertIfNecessary(null, null, lastKey, mapKeyType, typeDescriptor);
			Object oldValue = null;
			if (isExtractOldValueForEditor()) {
				oldValue = map.get(convertedMapKey);
			}
			//解析map类型的属性value值
			Object convertedMapValue = convertIfNecessary(tokens.canonicalName, oldValue, pv.getValue(),
					mapValueType, ph.nested(tokens.keys.length));
			//将解析后的key value值赋值给map
			map.put(convertedMapKey, convertedMapValue);
		}

		else {
			throw new InvalidPropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
					"Property referenced in indexed property path '" + tokens.canonicalName +
					"' is neither an array nor a List nor a Map; returned value was [" + propValue + "]");
		}
	}


private Object getPropertyHoldingValue(PropertyTokenHolder tokens) {
		// Apply indexes and map keys: fetch value for all keys but the last one.
		Assert.state(tokens.keys != null, "No token keys");
		PropertyTokenHolder getterTokens = new PropertyTokenHolder(tokens.actualName);
		getterTokens.canonicalName = tokens.canonicalName;
		getterTokens.keys = new String[tokens.keys.length - 1];
		System.arraycopy(tokens.keys, 0, getterTokens.keys, 0, tokens.keys.length - 1);

		Object propValue;
		try {
		//获取属性值
			propValue = getPropertyValue(getterTokens);
		}
		catch (NotReadablePropertyException ex) {
			throw new NotWritablePropertyException(getRootClass(), this.nestedPath + tokens.canonicalName,
					"Cannot access indexed value in property referenced " +
					"in indexed property path '" + tokens.canonicalName + "'", ex);
		}

		if (propValue == null) {
			// null map value case
			if (isAutoGrowNestedPaths()) {
				int lastKeyIndex = tokens.canonicalName.lastIndexOf('[');
				getterTokens.canonicalName = tokens.canonicalName.substring(0, lastKeyIndex);
				propValue = setDefaultValue(getterTokens);
			}
			else {
				throw new NullValueInNestedPathException(getRootClass(), this.nestedPath + tokens.canonicalName,
						"Cannot access indexed value in property referenced " +
						"in indexed property path '" + tokens.canonicalName + "': returned null");
			}
		}
		return propValue;
	}

Spring IoC容器将属性值注入到Bean实例对象可以分为两种：

  1. 对于集合类型的属性，将属性值解析为目标类型的集合后直接赋值给属性
  2. 对于非集合类型的属性，使用反射机制，通过属性的getter方法获取指定属性注入前的值，同时调用属性的setter方法为属性设置注入后的值

至此Spring IoC容器的依赖注入就完成了。

延时加载

IoC容器初始化就是对Bean定义资源的定位、载入、注册，此时容器对Bean的依赖注入并没有发生，依赖注入是在应用程序第一次向容器索取Bean时通过getBean()方法完成的。当定义了lazy-init=false属性时，容器会在初始化时，对所配置的Bean预实例化，Bean的依赖注入在容器初始化时就完成了。

refresh()方法

IoC容器读入定位的Bean定义资源是从refresh()方法开始的，在refresh()中ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();启动Bean定义资源的载入和注册过程。finishBeanFactoryInitialization()方法是对注册后的Bean定义中的预实例化的Bean进行处理的地方。

使用finishBeanFactoryInitialization()处理预实例化的Bean

finishBeanFactoryInitialization()方法对配置了预实例化的Bean进行预初始化。源码如下：

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// Initialize conversion service for this context.
		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);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// 为了使类型匹配，停止使用临时的类加载器
		beanFactory.setTempClassLoader(null);

		// 缓存容器中所有注册的BeanDefinition元数据，防止被修改
		beanFactory.freezeConfiguration();

		// 对配置了lazy-init属性的单例模式的Bean进行预实例化
		beanFactory.preInstantiateSingletons();
	}

ConfigurableListableBeanFactory是个接口，preInstantiateSingletons()方法由其子类DefaultListableBeanFactory提供。

对配置了lazy-init属性的单例模式的Bean进行预实例化

源码如下：

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

		//获取指定名称的Bean定义
		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		for (String beanName : beanNames) {
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			//Bean不是抽象的，是单例模式的，且lazy-init属性配置为false
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
			//如果Bean是创建容器的Bean
				if (isFactoryBean(beanName)) {
				//FACTORY_BEAN_PREFIX="&"，当Bean名称前加"&"时，获取的是容器本身，而不是容器产生的Bean，调用getBean()方法触发Bean实例化和依赖注入
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						FactoryBean<?> factory = (FactoryBean<?>) bean;
						//标识是否需要预实例化
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged(
									(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
						//调用getBean方法，触发Bean实例化和依赖注入
							getBean(beanName);
						}
					}
				}
				else {
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		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();
				}
			}
		}
	}

关于FactoryBean和BeanFactory

BeanFactory：Bean工厂，是一个工厂，Spring IoC容器最顶层接口就是FactoryBean，其作用是管理Bean，即定位、实例化、配置应用程序中的对象及建立这些对象之间的依赖。
FactoryBean:工厂Bean，是一个Bean，其作用是产生其他Bean实例，在通常模式情况下，Bean无需自己实现工厂模式，Spring容器担任工厂的角色，在少数情况下，容器中的Bean本身就是工厂，其作用是产生其他Bean。用户使用容器时，可以用转义符"&"获取FactoryBean本身，以区别FactoryBean本身和其产生的实例对象。

FactoryBean源码：

public interface FactoryBean<T> {
	//获取容器管理的对象实例
	@Nullable
	T getObject() throws Exception;
	//获取Bean工厂创建的对象的类型
	@Nullable
	Class<T> getObjectType();
	//Bean工厂创建的对象是否是单例模式的，如果是，则整个容器中只有一个实例对象，每次请求都返回同一个实例对象
	default boolean isSingleton() {
		return true;
	}
}

AbstractBeanFactory的getBean()方法

在getBean()方法触发容器实例化Bean时会调用AbstractBeanFactory的doGetBean()方法，源码如下：

protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {
			...
			//当前容器的父容器存在，且当前容器中不存在指定名称的Bean
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// 解析指定Bean名称的原始名称
				String nameToLookup = originalBeanName(name);
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
							nameToLookup, requiredType, args, typeCheckOnly);
				}
				else if (args != null) {
					// 委派父容器根据指定名称和显示的参数查找
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					// 委派父容器根据指定名称和类型查找
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}
		...
		return (T) bean;


//获取指定Bean的实例对象，主要完成FactoryBean的相关处理
protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

		//容器已经的到了Bean实例对象，这个实例对象可能是一个普通的Bean，也可能是一个工厂Bean，如果是工厂Bean，则使用它创建一个Bean实例对象
		//如果调用本身就是想获得一个容器的引用，则返回这个工厂Bean实例对象
		//如果指定名称是容器的解引用且Bean实例也不是创建Bean实例对象的工厂Bean
		if (BeanFactoryUtils.isFactoryDereference(name)) {
			if (beanInstance instanceof NullBean) {
				return beanInstance;
			}
			if (!(beanInstance instanceof FactoryBean)) {
				throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
			}
		}

		// 如果Bean实例不是工厂Bean，或者指定名称是容器的解引用
		//调用者获取对容器的引用时，直接返回当前的Bean实例
		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}

		//处理指定名称不是容器的解引用，或者根据名称获取的Bean实例对象是一个工厂Bean
		//使用工厂Bean创建一个Bean的实例对象
		Object object = null;
		if (mbd == null) {
		//从Bean工厂缓存中获取指定名称的Bean实例对象
			object = getCachedObjectForFactoryBean(beanName);
		}
		//让Bean工厂生产指定名称的Bean实例对象
		if (object == null) {
			// 如果从Bean工厂生产的Bean是单例模式的，则缓存
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			// 从容器中获取指定名称的Bean定义，如果继承了基类，则合并基类的相关属性
			if (mbd == null && containsBeanDefinition(beanName)) {
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			//如果从容器中得到了Bean定义信息，且Bean定义信息不是虚构的，则让工厂Bean生产Bean实例对象按
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			//调用FactoryBeanRegistrySupport类的getObjectFromFactoryBean()方法实现工厂Bean生产Bean实例对象的过程
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}

FactoryBeanRegistrySupport生产Bean实例对象

FactoryBeanRegistrySupport类中生产Bean实例对象的主要源码如下：

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
		//Bean工厂是单例模式，并且Bean工厂缓存中存在指定名称的Bean实例对象
		if (factory.isSingleton() && containsSingleton(beanName)) {
			synchronized (getSingletonMutex()) {
			//直接从Bean工厂的缓存中获取指定名称的Bean实例对象
				Object object = this.factoryBeanObjectCache.get(beanName);
				//如果Bean工厂的缓存中不存在指定名称的Bean实例对象，则生产该对象
				if (object == null) {
					object = doGetObjectFromFactoryBean(factory, beanName);
					
					Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
					if (alreadyThere != null) {
						object = alreadyThere;
					}
					else {
						if (shouldPostProcess) {
							if (isSingletonCurrentlyInCreation(beanName)) {
								// Temporarily return non-post-processed object, not storing it yet..
								return object;
							}
							beforeSingletonCreation(beanName);
							try {
							//将生产的实例对象添加到Bean工厂的缓存中
								object = postProcessObjectFromFactoryBean(object, beanName);
							}
							catch (Throwable ex) {
								throw new BeanCreationException(beanName,
										"Post-processing of FactoryBean's singleton object failed", ex);
							}
							finally {
								afterSingletonCreation(beanName);
							}
						}
						if (containsSingleton(beanName)) {
							this.factoryBeanObjectCache.put(beanName, object);
						}
					}
				}
				return object;
			}
		}
		else {//调用Bean工厂获取对象的方法生产指定Bean的实例对象
			Object object = doGetObjectFromFactoryBean(factory, beanName);
			if (shouldPostProcess) {
				try {
					object = postProcessObjectFromFactoryBean(object, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
				}
			}
			return object;
		}
	}

//调用Bean工厂的方法生产指定Bean的实例对象
private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
		Object object;
		try {
			if (System.getSecurityManager() != null) {
				AccessControlContext acc = getAccessControlContext();
				try {
					object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
			//调用BeanFactory接口实现类的创建对象方法
				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);
		}

		// 创建出来的实例对象为null，或者因为单例对象正在创建儿返回null
		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;
	}

autowiring

Spring IoC容器提供两种管理Bean依赖关系的方式：

  1. 显示管理：通过BeanDefiniton的属性值和构造方法实现Bean依赖关系的管理。
  2. autowiring：在配置好autowiring属性后，IoC容器会自动使用反射查找属性的类型和名称，然后基于属性的类型和名称来自动匹配容器中的Bean，从而自动完成依赖注入。

自动装配发生在容器对Bean依赖注入的过程中。

AbstractAutoWireCapableBeanFactory对Bean实例对象进行属性依赖注入

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		...
		//获取容器在解析Bean定义时为BeanDefiniton设置的属性值
		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		//处理依赖注入，首先处理autowiring自动装配的依赖注入
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			// 根据Bean名称进行autowiring自动装配处理
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// 根据类型进行autowiring自动装配处理
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}

		//对非autowiring的属性进行依赖注入处理
		...
	}

Spring IoC 容器根据Bean名称或者类型进行autowiring自动属性依赖注入

根据类型进行自动依赖注入的源码如下：

protected void autowireByType(
			String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
			/获取用户定义的类型转换器
		TypeConverter converter = getCustomTypeConverter();
		if (converter == null) {
			converter = bw;
		}
		//存放解析要注入的属性
		Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
		//对Bean对象中非简单属性进行处理
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		for (String propertyName : propertyNames) {
			try {
			//获取指定属性名称的属性描述器
				PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
				// 不对Object类型的属性进行autowiring自动依赖注入
				if (Object.class != pd.getPropertyType()) {
				//获取属性的赋值方法
					MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
					// 检查指定类型是否可以被转换成目标对象的类型
					boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
					//创建一个要被注入的依赖描述
					DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
					//根据容器的Bean定义解析依赖关系，返回所有要被注入的Bean对象
					Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
					if (autowiredArgument != null) {
					//将属性赋值为所引用的对象
						pvs.add(propertyName, autowiredArgument);
					}
					for (String autowiredBeanName : autowiredBeanNames) {
					//为指定名称属性注册依赖Bean名称，进行属性的依赖注入
						registerDependentBean(autowiredBeanName, beanName);
						if (logger.isDebugEnabled()) {
							logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +
									propertyName + "' to bean named '" + autowiredBeanName + "'");
						}
					}
					//释放已自动注入的属性
					autowiredBeanNames.clear();
				}
			}
			catch (BeansException ex) {
				throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
			}
		}
	}

通过源码分析知道真正实现属性注入的是DefaultSingletonBeanRegistry类的registerDependentBean()方法

DefaultSingletonBeanRegistry的registerDependentBean()方法实现属性依赖注入

//为指定的Bean注入依赖的Bean
public void registerDependentBean(String beanName, String dependentBeanName) {
//处理Bean名称，将别名转换为规范的Bean名称
		String canonicalName = canonicalName(beanName);

		synchronized (this.dependentBeanMap) {
		//在容器中通过“Bean名称-全部依赖Bean名称集合”查找指定Bean的依赖Bean
		//获取指定名称Bean的所有依赖Bean名称
			Set<String> dependentBeans =
					this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
			if (!dependentBeans.add(dependentBeanName)) {
				return;
			}
		}

		//在容器通过“Bean名称-指定名称Bean的依赖Bean名称集合”查找指定名称Bean的依赖Bean
		synchronized (this.dependenciesForBeanMap) {
			Set<String> dependenciesForBean =
					this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
					//在容器中通过“Bean名称-指定Bean的依赖Bean名称集合”添加Bean的依赖信息，即，将Bean所依赖的Bean添加到容器的集合中
			dependenciesForBean.add(canonicalName);
		}
	}

autowiring的实现过程如下：

  1. 对Bean的属性调用getBean()方法，完成依赖Bean的初始化和依赖注入。
  2. 将依赖Bean的属性引用设置到被依赖Bean的属性上。
  3. 将依赖Bean的名称和被依赖Bean的名称存储到IoC容器中。

自动注入虽然很方便但是Bean之间的依赖关系在配置文件中无法很清楚的看出来，给维护造成困难。

qq_41194872
关注
专栏目录
spring5-samples:《Spring5核心原理与30个类手写实战》随书代码示例工程
05-14
《Spring5核心原理与30个类手写实战》 4个月销量破万，连续占据畅销榜 京东购买链接： 当当购买链接： 倾注十年Spring研究精华与见解 ★本书几乎涵盖在Spring应用中可能遇到的所有问题，核心原理（IoC、DI、AOP、MVC）、高仿手写、数据访问等 ★深度解析Spring 5的原理与新特性，从环境准备、顶层结构设计、数据访问等方面一步步推导出Spring设计原理 ★通过本书你可以： --看源码不再晕车，轻松找到入口。 --系统学习设计思想，提高解决问题的效率。 --培养架构思维能力，自驱学习能力。 --用30个类提炼出Spring核心的精华思想，并保证功能可用。 --从不一样的角度分析Spring经典高频面试题。 --了解Spring 5 的新特性。 --为深入了解Spring Boot做铺垫。 关于我 为什么说我来自文艺界？ 　　我自幼爱好书法和美术，长了一双能书会画的手，
spring5-di-demo：Spring 5依赖注入演示
02-20
Spring 5是其最新的版本，带来了诸多改进和新特性，其中依赖注入（Dependency Injection，简称DI）是其核心设计模式之一。本篇文章将深入探讨Spring 5中的依赖注入机制，帮助初学者更好地理解和应用这一强大的功能。...
spring5整理:(一)Ioc和DI
fenfeng2012
10-28 649
目录  一.基础 二.Spring Ioc管理bean的原理: 三.getBean方法的三种签名 四.创建bean时机 五.bean实例化的方式： 六.bean作用域： 七.bean初始化和销毁 八.bean实例化过程  一.基础 正控：若调用者需要使用某个对象，其自身就得负责该对象及该对象所依赖对象的创建和组装 反控：调用得只管理从Spring容器中获取需要使用的对象，不关...
spring5整理:(二)DI注解
fenfeng2012
10-29 479
目录 一.Autowited注解 二.Resource 三.@Value注解 一.Autowited注解 spring规范提供 1.可以让spring自动的把属性需要的对像找出来，并注入到对像 2.可以贴字段或者setter方法上面 3.可以同时注入多个对象 @Autowired public void setter(SomeBean b1,SomeBean b2){ } 4...
Spring DI 详解
weixin_39663138的博客
11-06 305
前言 大多数面向对象编程语言，在调用一个类的时候，先要实例化这个类，生成一个对象。 如果现有一个类，过程中要调用到很多其它类，甚至这里的其它类，也要“依赖”于更多其它的类，那么可以想象需要进行多少次实例化，这就是“依赖”的意思。这些对象彼此之间高度耦合，难以复用和测试。 在Spring中，对象无需自己查找或创建与其所关联的其他对象，相反，容器负责把需要相互协作的对象引用赋予各个对象，即依赖注入(D...
IOC与DI系列：5 DI 的过程
纵横千里 捭阖四方 的专栏
04-07 878
0.发生注入的时间 当Spring Ioc装载完Bean之后，Ioc容器已经管理类Bean定义的相关数据，但是此时Ioc容器还没有对所管理的Bean进行依赖注入，依赖注入在以下两种情况下发生： 1.用户第一调用getBean()方法时，Ioc容器触发依赖注入。 2.当用户在配置文件中将元素配置了lazy-init=false属性，即让容器在解析注册Bean定义时进行预实例化，触发依赖注入。 1.寻找入口 BeanFactory接口定义了Spring Ioc容器的基本功能规范，是Spring IoC容器所应遵
spring5-di-demo:拿4
03-27
本文将围绕"spring5-di-demo:拿4"这一项目，深入探讨Spring框架5中的依赖注入机制及其应用场景。 一、Spring框架5简介 Spring框架5是Java开发中的一种轻量级框架，它提供了许多关键特性，如面向切面编程（AOP）、...
SpringIOC DI循环依赖实例详解
08-24
SpringIOC DI 循环依赖实例详解 SpringIOC 是一个基于依赖注入（Dependency Injection，简称 DI）的容器，用于管理 Bean 的生命周期。 DI 循环依赖是指在 Bean 初始化过程中出现的循环依赖问题，即一个 Bean 依赖于...
java Spring DI依赖注入.rar
01-30
Java Spring 框架是企业级Java应用开发的首选框架之一，其核心特性之一就是依赖注入（Dependency Injection，简称DI）。依赖注入是一种设计模式，它允许我们解耦组件，提高代码的可测试性和可维护性。Spring框架通过...
Spring-DI时序图.png
05-14
Spring Ioc DI 时序图分享给大家，希望对大家看源码有所帮助，不足之处欢迎批评指正，可以在下方留言
SPRING 技术内幕 PDF（高清版）
02-28
Spring技术内幕—深入解析Spring架构与设计原理（Java社区和Spring社区一致鼎力推荐！） 著 译 者：计文柯
Spring5核心原理与30个手写类实战-时序图.zip
09-26
GitHub图片打不开太慢了
Spring 5 DI 相关内容 5.1 setter 注入 5.1.2 注入引用数据类型 & 5.1.3 注入简单数据类型
谢谢你们的关注
10-10 338
Spring 5 DI 相关内容 5.1 setter 注入 5.1.2 注入引用数据类型 & 5.1.3 注入简单数据类型
Spring 5 DI 相关内容 5.3 自动配置 5.3.4 完成自动装配的配置
最新发布
谢谢你们的关注
10-10 238
Spring 5 DI 相关内容 5.3 自动配置 5.3.4 完成自动装配的配置
Spring 5 DI 相关内容 5.2 构造器 注入 5.2.5 构造器注入的一些问题
谢谢你们的关注
10-10 273
Spring 5 DI 相关内容 5.2 构造器 注入 5.2.5 构造器注入的一些问题
spring 5源码解析-1 IOC-DI
韩小文的博客
05-07 349
spring 5源码解析-1 IOC-DI Spring5 框架使用说明文档： https://docs.spring.io/spring/docs/5.0.8.RELEASE/spring-framework-reference/ 源码获取地址： https://github.com/spring-projects/spring-framework github-wiki 介绍： https:...
spring5(IoC和DI)
m0_37835906的博客
10-31 191
Spring5(IoC和DI) Spring的出现是为了简化应用开发，可以让更少的代码实现更多的功能。它是一个轻量级的DI/Ioc和AOP容器的开源框架，致力于构建轻量级JavaEE应用。其本身不仅涵盖了传统开发，还拓展到移动端，大数据等领域具体可查看https://spring.io/proj...
spring 5企业级开发实战pdf_干货！深入剖析Spring核心组件原理，由实战开发，助你吃透微服务...
weixin_39624461的博客
12-03 336
前言我们现在开发应用的方式和1年前、5年前、10年前都是不同的，更别提15年前了，当时RodJohnson的图书 Expert One-on-One J2EE Design and Development 介绍了Spring框架的初始形态。当时，最常见的应用形式是基于浏览器的Web应用，后端由关系型数据库作为支撑。尽管这种形式的开发依然有它的价值，Spring也为这种应用提供了良好的支持，但是我们...
Spring5 - 核心原理
热门推荐
小工匠
09-05 1万+
文章目录核心原理解析 核心原理解析 周末梳理了下Spring Framework的核心原理， 详细请参考： 在Processon上，直达地址： https://www.processon.com/view/link/61345766f346fb07155ec9ad
Spring5入门与实践：IoC、AOP与DI详解
3. **基于XML的DI使用**：依赖注入（Dependency Injection，DI）是Spring的重要特性之一，在XML配置中，开发者可以声明组件的依赖关系，由Spring在运行时自动注入。 4. **基于注解的IoC实现**：随着Spring的发展，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值