Spring源码系列(二)--bean组件的源码分析

时间  2020-06-27
标签 spring 源码 系列 bean 组件 分析 栏目 Spring 繁體版
原文   原文链接

简介

spring-bean 组件是 Spring IoC 的核心，咱们可使用它的 beanFactory 来获取所需的对象，对象的实例化、属性装配和初始化等均可以交给 spring 来管理。 本文将从DefaultListableBeanFactory.getBean(Class)方法开始分析获取 bean 的过程，主要内容以下，因为篇幅较长，能够根据须要选择阅读：html

  1. beanFactory 的设计
  2. 多个 beanName 的处理
  3. 获取单例 bean
  4. 建立单例 bean
  5. bean 的实例化
  6. bean 的属性装配
  7. bean 的初始化（省略）

spring-bean 的源码比较多，有些不影响总体分析思路的代码会被省略掉（代码中会注明），另外，想要分析全部的代码可能不大现实，因此，针对部份内容，我会点到为止，例如，本文只分析单例 bean 而不分析多例 bean。java

前篇回顾

上篇博客Spring源码系列(一)--详细介绍bean组件介绍了 bean 组件的一些重要理论概念，并经过例子演示如何使用 bean 组件。这里回顾下，这几个概念很是重要，是 bean 组件的理论基础：git

  1. 实例化、属性装配和初始化的概念。 实例化指建立出一个新的对象；属性装配指给对象的成员属性赋值； 初始化指调用对象的初始化方法。
  2. 什么是 bean：某个类的实例或描述对象，被注册到了 Spring IoC 容器，这时经过 Spring IoC 容器获取的这个类的对象就是 bean。
  3. 什么是 beanFactory：一个工厂，用于注册 bean 和获取 bean。
  4. 什么是 beanDefinition：一个描述对象，用来描述 bean 的实例化、属性装配、初始化等信息。

beanFactory的设计

从客户端来看，一个完整的 beanFactory 工厂包含如下基本功能:github

  1. 注册别名。对应下图的AliasRegistry接口。
  2. 注册单例对象。对应下图的SingletonBeanRegistry接口。
  3. 注册BeanDefinition对象。对应下图的BeanDefinitionRegistry接口。
  4. 获取 bean。对应下图的BeanFactory接口。

在 spring-bean 组件中，DefaultListableBeanFactory就是一个完整的 beanFactory 工厂，也能够说是一个 IoC 容器。spring

BeanFactoryUML_01

BeanFactory还有几个扩展接口，用的比较多的多是ConfigurableBeanFactory和AutowireCapableBeanFactory：数组

  1. HierarchicalBeanFactory用于提供父子工厂的支持。例如，当前 beanFactory 找不到 bean 时，会尝试从 parent beanFactory 中获取。
  2. ConfigurableBeanFactory用于提供配置 beanFactory 的支持。例如，注册BeanPostProcessor、注册 TypeConverter、注册OrderComparator等。
  3. ListableBeanFactory用于提供批量获取 bean 的支持（不包含父工厂的 bean）。例如，咱们能够根据类型获取 beanName-bean 的 map。
  4. AutowireCapableBeanFactory用于提供实例化、属性装配、初始化等一系列管理 bean 生命周期的支持。 例如，该接口包含了 createBean、autowireBean、initializeBean、destroyBean 等方法。

当咱们注册 bean 时，根据注册方式的不一样，bean 的注册信息会被放入两个不一样的地方。缓存

class DefaultSingletonBeanRegistry {
	// beanName=singletonObject键值对
    // 除了registerSingleton的会放在这里，registerBeanDefinition生成的单例bean实例也会放在这里
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
}
class DefaultListableBeanFactory {
	// beanName=beanDefination键值对
	private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
}

接下来开始分析源码，注册 bean 比较简单，这里就不看了，咱们直接看 getBean(Class) 的代码。多线程

从getBean(requiredType)方法开始

进入到 DefaultListableBeanFactory.getBean(Class)方法，并逐渐展开。在DefaultListableBeanFactory.resolveBean(ResolvableType, Object[], boolean)方法中，若是当前 beanFactory 中获取不到这个 bean，将尝试从 parent beanFactory 中获取，这也说明了一点：父子 beanFactory 中容许存在相同 beanName 的 bean，只是获取时当前 beanFactory 的优先级更高一些。app

public <T> T getBean(Class<T> requiredType) throws BeansException {
        // 适配入参
        // 能够看到，咱们获取bean时还能够指定构造参数
		return getBean(requiredType, (Object[]) null);
	}
	public <T> T getBean(Class<T> requiredType, @Nullable Object... args) throws BeansException {
		Assert.notNull(requiredType, "Required type must not be null");
        // 继续适配入参
        // 这里的第三个参数表示，若是指定类型对应的beanName不惟一时，true为返回null, false为抛出异常
		Object resolved = resolveBean(ResolvableType.forRawClass(requiredType), args, false);
        // 若是获取不到这个bean，抛出异常
		if (resolved == null) {
			throw new NoSuchBeanDefinitionException(requiredType);
		}
		return (T) resolved;
	}
	private <T> T resolveBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) {
        // 这里的NamedBeanHolder就是简单的对bean实例封装了一层，不用太关注
		NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args, nonUniqueAsNull);
        // 若是获取获得bean实例，则返回
		if (namedBean != null) {
			return namedBean.getBeanInstance();
		}
        // 若是没有，尝试从parent beanFactory中获取
        // 这部分代码省略······
		return null;
	}

存在多个beanName怎么办

经过 beanType 来获取 bean，可能会存在一个类型关联了多个 beanName 的状况，使用例子中咱们说过，能够经过指定 beanDefination 的 isPrimary = true 或者注册比较器的方式来解决。接下来咱们看下具体的处理过程。post

进入到DefaultListableBeanFactory.resolveNamedBean(ResolvableType, Object[], boolean)方法。若是指定类型匹配到了多个 beanName，会进行如下处理：

  1. 若是存在经过registerSingleton注册的 beanName，或者经过registerBeanDefinition注册且 autowireCandidate = true 的 beanName，则仅保留它们，并剔除其余的 beanName；
  2. 若是仍是存在多个 beanName，检查是否存在惟一一个经过registerBeanDefinition且isPrimary = true的（存在多个会报错），存在的话将它做为匹配到的惟一 beanName；
  3. 若是仍是存在多个 beanName，经过咱们注册的OrderComparator来肯定优先值最小的做为惟一 beanName，注意，经过registerSingleton注册的和经过registerBeanDefinition注册的，比较的对象是不同的；
  4. 若是仍是存在多个 beanName，根据 nonUniqueAsNull，为 true 是返回 null，为 false 抛出NoUniqueBeanDefinitionException异常。
private <T> NamedBeanHolder<T> resolveNamedBean(
			ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) throws BeansException {

		Assert.notNull(requiredType, "Required type must not be null");
        // 获取指定类型的全部beanName，可能匹配到多个
		String[] candidateNames = getBeanNamesForType(requiredType);
        
		// 若是指定类型匹配到了多个beanName，进行如下操做：
        // 若是存在经过registerSingleton注册的beanName，或者经过registerBeanDefinition注册且 autowireCandidate = true的beanName，则仅保留它们，并剔除其余的beanName；
		if (candidateNames.length > 1) {
			List<String> autowireCandidates = new ArrayList<>(candidateNames.length);
			for (String beanName : candidateNames) {
				if (!containsBeanDefinition(beanName) || getBeanDefinition(beanName).isAutowireCandidate()) {
					autowireCandidates.add(beanName);
				}
			}
			if (!autowireCandidates.isEmpty()) {
				candidateNames = StringUtils.toStringArray(autowireCandidates);
			}
		}
        
		// 若是只剩下一个beanName，那就根据beanName和beanType获取bean
		if (candidateNames.length == 1) {
			String beanName = candidateNames[0];
			return new NamedBeanHolder<>(beanName, (T) getBean(beanName, requiredType.toClass(), args));
		}
        
        // 若是存在多个，则还要进一步处理
		else if (candidateNames.length > 1) {
			Map<String, Object> candidates = new LinkedHashMap<>(candidateNames.length);
            // 遍历候选的beanName
			for (String beanName : candidateNames) {
                // 若是该beanName是经过registerSingleton注册的，且传入构造参数为空
                // 则获取该bean实例，并放入candidates
				if (containsSingleton(beanName) && args == null) {
					Object beanInstance = getBean(beanName);
					candidates.put(beanName, (beanInstance instanceof NullBean ? null : beanInstance));
				}
				else {
                    // 其余状况下，则获取该beanName对应的类型，并放入candidates
                    // 注意，这里的类型不必定是咱们入参指定的类型，例如，若是我指定的是UserServiceFactoryBean.class，这里返回的倒是UserService.class
					candidates.put(beanName, getType(beanName));
				}
			}
            // 若是里面存在惟一一个经过registerBeanDefinition注册的且isPrimary=true（存在多个会报错），则将它做为匹配到的惟一beanName
			String candidateName = determinePrimaryCandidate(candidates, requiredType.toClass());
            // 若是仍是肯定不了，则经过咱们注册的OrderComparator来判断candidates中value的优先数，挑选优先数最小的value对应的key做为惟一的beanName
			if (candidateName == null) {
				candidateName = determineHighestPriorityCandidate(candidates, requiredType.toClass());
			}
			if (candidateName != null) {
				Object beanInstance = candidates.get(candidateName);
                // 若是candidates中的value自己就是一个bean实例，那么直接返回就行了
                // 若是不是，则根据beanName和beanType获取bean
				if (beanInstance == null || beanInstance instanceof Class) {
					beanInstance = getBean(candidateName, requiredType.toClass(), args);
				}
				return new NamedBeanHolder<>(candidateName, (T) beanInstance);
			}
            // 若是仍是肯定不了惟一beanName，且设置了nonUniqueAsNull=false（默认为false），则会抛错
			if (!nonUniqueAsNull) {
				throw new NoUniqueBeanDefinitionException(requiredType, candidates.keySet());
			}
		}
		
		return null;
	}

根据beanName和beanType获取bean

进入AbstractBeanFactory.getBean(String, Class<T>, Object...)。这个方法里包括四个步骤：

  1. 转义name。主要指的是当 name 是别名或者是 “&” + factory beanName 形式时进行转义；
  2. 若是是单例 bean 且构造参数为空，则会从 singletonObjects 中获取已生成的 bean，或者从 earlySingletonObjects/singletonFactories 中获取已经实例化但可能还没装配或初始化的 bean。若是获取到的不是 null，直接返回对应的 bean 实例；
  3. 若是当前 beanFactory 没有指定的 beanName，则会去 parent beanFactory 中获取；
  4. 若是当前 bean 须要依赖其余 bean，则会先获取依赖的 bean；
  5. 根据 scope 选择生成单例 bean 仍是多例 bean；
  6. 进行类型检查，若是获取的 bean 不匹配，会先用咱们注册的类型转换器转换，若是仍是不匹配就抛出BeanNotOfRequiredTypeException。
public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args)
			throws BeansException {
		// 适配入参
        // 这里最后一个参数指获取的bean是否纯粹用于类型检查，若是是的话，beanFactory不会标记这个bean正在生成中，仅对单例bean有用
		return doGetBean(name, requiredType, args, false);
	}
	@SuppressWarnings("unchecked")
	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
		// 转义咱们传入的name，这里包括两个内容：
        // 1. 若是是别名，须要转换为别名对象的beanName;
        // 2. 若是是“&”+factoryBeanName,则须要去掉前面的“&”
		final String beanName = transformedBeanName(name);
		Object bean;

		// 获取单例
        // 注意，这里获取到的有多是已经初始化，也有多是还没初始化，甚至还没装配的bean
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			// 省略日志部分······
            
            // 获取bean，由于sharedInstance有多是factoryBean，若是咱们要的是factoryBean对应的bean，则还要getObject
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// 若是当前线程已经在生成beanName对应的bean，就会抛错
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// 若是当前beanFactory没有指定的beanName，则会去parent beanFactory中获取
            // 这部分省略······
			
			// 这里标记指定bean正在建立中，通常对单例bean才有意义
			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			try {
                // 获取指定beanName对应的RootBeanDefinition对象
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                // 检查RootBeanDefinition，目前就是检查是否对应的类型为抽象类，是的话抛错
				checkMergedBeanDefinition(mbd, beanName, args);

				// 若是当前bean须要依赖其余bean，则会先获取依赖的bean
				// 这部分省略······

				// 建立单例bean
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
                            // 进入建立bean或factoryBean
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							destroySingleton(beanName);
							throw ex;
						}
					});
                    // 获取bean实例
					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				// 建立多例bean
				else if (mbd.isPrototype()) {
					Object prototypeInstance = null;
					try {
                        // 标记当前线程正在建立这个bean
						beforePrototypeCreation(beanName);
                        // 进入建立bean或factoryBean
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
                        // 去掉当前线程中这个bean正在建立的标记
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}
				// 接下来这种通常是自定义Scope的状况，这里省略不讨论
				else {
					// ·······
				}
			}
			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) {
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
		}
		return (T) bean;
	}

因为单例 bean 和多例 bean 的建立差很少，本文只选择单例的来分析。

获取单例bean

进入DefaultSingletonBeanRegistry.getSingleton(String, ObjectFactory)。这个方法包括几个过程，主要就是处理一些多线程问题：

  1. 获取指定 beanName 的 bean，若是已经存在，就不去建立，这时为了处理多线程同时建立 bean 的问题；
  2. 若是当前 bean 已经在建立中，会抛出 BeanCurrentlyInCreationException，建立单例 bean 以前是有加锁的，按理不会出现这种状况；
  3. 建立单例 bean；
  4. 若是建立成功，将 bean 实例加入 singletonObjects，而且删除掉 singletonFactories 和 earlySingletonObjects 中对应的键值对。
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "Bean name must not be null");
        // 这里我不是很理解，为何使用singletonObjects做为锁
        // 由于从earlySingletonObjects/singletonFactories中获取已经实例化但可能还没装配或初始化的 bean时，用的锁也是singletonObjects，这样的话，提早暴露的机制好像就废掉了啊？？？TODO
		synchronized (this.singletonObjects) {
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) {
                // 若是当前beanFactory的单例正在销毁，则不容许建立单例
				if (this.singletonsCurrentlyInDestruction) {
					// 省略抛错······
				}
				
				// 判断当前bean是否是已经在建立中，是的话抛出BeanCurrentlyInCreationException
                // 因为加了锁，这种状况应该是不会发生的
				beforeSingletonCreation(beanName);
				boolean newSingleton = false;
                
                // 省略部分代码······
                
				try {
                    // 这里的执行的是createBean方法
					singletonObject = singletonFactory.getObject();
					newSingleton = true;
				}
                // 这种状况我不是很理解，singletonObjects的操做不该该被锁住了吗？TODO
				catch (IllegalStateException ex) {
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
						throw ex;
					}
				}
                // 若是抛出的是BeanCreationException，
				catch (BeanCreationException ex) {
                    // 省略部分代码······
                        
					throw ex;
				}
				finally {
                    // 省略部分代码······
                    
                    // 若是当前bean不处于建立状态中，会抛出IllegalStateException
					afterSingletonCreation(beanName);
				}
            	// 若是建立成功，将bean实例加入singletonObjects，而且删除掉singletonFactories和earlySingletonObjects中对应的键值对
				if (newSingleton) {
					addSingleton(beanName, singletonObject);
				}
			}
			return singletonObject;
		}
	}

以上方法中，若是获取不到已生成的单例 bean，则会开始建立 bean。

建立单例bean

进入AbstractAutowireCapableBeanFactory.createBean(String, RootBeanDefinition, Object[])。这个方法包括如下过程：

  1. 解析 beanType，而且再次包装RootBeanDefinition；
  2. 执行咱们注册的InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法，若是返回了非空对象，则将其返回。也就是说咱们能够在该方法中自定义完成 bean 的实例化、装配和初始化。
  3. 建立 bean。
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		RootBeanDefinition mbdToUse = mbd;

		// 解析当前RootBeanDefinition对应生成的bean类型，并进行再次包装
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		// 省略部分代码······

		try {
			// 执行咱们注册的InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法。也就是说咱们能够在该方法中自定义完成 bean 的实例化、装配和初始化。
			Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            // 若是该方法返回bean，那就直接返回
			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);
			return beanInstance;
		}
		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
		}
	}

进入AbstractAutowireCapableBeanFactory.doCreateBean(String, RootBeanDefinition, Object[])。这个方法主要包含如下过程：

  1. 实例化 bean；
  2. 执行咱们注册的MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法；
  3. 若是是单例，将还没装配和初始化的 bean 先暴露出去，即放在singletonFactories中，若是其余线程进来获取，能够将这个 bean 或 factoryBean 返回，而不须要等待；
  4. 属性装配；
  5. 初始化；
  6. 将生成的 bean 放入 disposableBeans 中。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		BeanWrapper instanceWrapper = null;
        // 实例化
        // 若是是单例，尝试从factoryBeanInstanceCache中获取
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
        // 实例化bean
		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// 执行咱们注册的MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法
		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先暴露出去，即放在singletonFactories中
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isTraceEnabled()) {
				logger.trace("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}
        
		Object exposedObject = bean;
		try {
            // 属性装配
			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);
			}
		}

		// 省略部分代码······

		// 将生成的bean或factoryBean放入disposableBeans中
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

接下来将展开 bean 的实例化、属性装配和初始化。其中，实例化和属性装配的代码比较复杂，咱们重点分析，至于初始化部分，则留给读者自行阅读。

实例化

进入AbstractAutowireCapableBeanFactory.createBeanInstance(String, RootBeanDefinition, Object[])。这个方法主要过程以下：

  1. 解析 beanType，并对 beanType 进行一些必要的检查；
  2. 经过咱们设置的 InstanceSupplier 或 FactoryMethod 来直接获取 bean，若是有的话，直接返回该对象；
  3. 若是构造参数为空，则能够复用已经解析好的构造对象（若是有的话）；
  4. 执行咱们注册的SmartInstantiationAwareBeanPostProcessor的determineCandidateConstructors获取构造对象数组；
  5. 若是获得的数组不是空，或者 beanDefination 的装配模式为构造注入，或者 beanDefination 包含构造参数，或者咱们传入的构造参数非空，则进入实例化 bean
  6. 其余状况，使用无参构造来实例化。
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		// 解析bean类型
		Class<?> beanClass = resolveBeanClass(mbd, beanName);
		
        // 若是bean类型不是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());
		}
		
        // 经过RootBeanDefinition中定义的Supplier来获取实例化bean
		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}
		// 经过RootBeanDefinition中定义FactoryMethod来实例化bean
		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) {
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				return instantiateBean(beanName, mbd);
			}
		}

		// 执行咱们注册的SmartInstantiationAwareBeanPostProcessor的determineCandidateConstructors获取Constructor对象数组（若是有的话）
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        // 若是获得的数组不是空，或者beanDefination的装配模式为构造注入，或者beanDefination包含构造参数，或者咱们传入的构造参数非空，则进入实例化bean或factoryBean
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			return autowireConstructor(beanName, mbd, ctors, args);
		}
		
		// 省略部分代码······

		// 使用无参构造实例化bean或factoryBean
		return instantiateBean(beanName, mbd);
	}

实例化的方法包括有参构造实例化和无参构造实例化两种，本文只讨论有参构造实例化的状况。

ConstructorArgumentValues和ArgumentsHolder

在继续分析以前，有必要了解下ConstructorArgumentValues和ArgumentsHolder这两个类。

首先，ConstructorArgumentValues用于定义构造方法的参数列表的值。spring 中，ConstructorArgumentValues通常被定义在 BeanDefinition对象中，它影响着 bean 的实例化，是 bean 实例化时选择构造对象的依据。

public class ConstructorArgumentValues {
	// 索引+参数值
    // 例如，对应new User(int age, String name, String address)的构造方法，能够包含元素：0=new ValueHolder(18),2=new ValueHolder("北京")
	private final Map<Integer, ValueHolder> indexedArgumentValues = new LinkedHashMap<>();
	// 通用参数值
    // 例如，对应new User(int age, String name, String address)的构造方法，若是indexedArgumentValues中不包含name的值，则能够在genericArgumentValues中查找，咱们只须要添加元素：new ValueHolder("zzs001", String.class)
	private final List<ValueHolder> genericArgumentValues = new ArrayList<>();
    
    // 内部类，表明一个参数的值
    public static class ValueHolder implements BeanMetadataElement {

		@Nullable
		private Object value;

		@Nullable
		private String type;

		@Nullable
		private String name;

		@Nullable
		private Object source;

		private boolean converted = false;

}

ArgumentsHolder是ConstructorResolver的内部类，和ConstructorArgumentValues同样，它也是用来定义构造方法的参数列表的值，区别在于，ConstructorArgumentValues的值是“未解析的”，而ArgumentsHolder包含了“未解析”（preparedArguments）、“解析未完成”（rawArguments）和"解析完成"（arguments）三种值。

为何会这样呢？由于ConstructorArgumentValues中的参数值的类型不必定和构造方法中的匹配，包括两种状况：

  1. 类型不一样，但能够经过TypeConverter转换的类型。例如，在new User(int age, String name, Address address)的构造方法中，我能够在ConstructorArgumentValues添加2=new AddressVO()，这个时候只要 spring 能找到合适的转换器就能转换，这个转换过程为：“解析未完成”（rawArguments） --》 "解析完成"（arguments）。
  2. 类型不一样，参数的值指向其余 bean ，固然也能够是其余 spring 可识别的引用。例如，new User(int age, String name, Address address)的构造方法中，我能够在ConstructorArgumentValues添加2=new RootBeanDefinition(Address.class)，这个转换过程为：“未解析”（preparedArguments） --》“解析未完成”（rawArguments）。
private static class ArgumentsHolder {

    public final Object[] rawArguments;

    public final Object[] arguments;

    public final Object[] preparedArguments;

    public boolean resolveNecessary = false;

}

理解完这两个类以后，咱们继续分析实例化的源码。

有参构造实例化

进入到AbstractAutowireCapableBeanFactory.autowireConstructor(String, RootBeanDefinition, Constructor<?>[], Object[])方法。这里建立了一个ConstructorResolver对象并直接调用它的 autowireConstructor 方法。

protected BeanWrapper autowireConstructor(
			String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {

		return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
	}

进入ConstructorResolver.autowireConstructor(String, RootBeanDefinition, Constructor<?>[], Object[])。这个方法代码比较多，为了更好地理解，能够分红两种场景来看：

  1. 入参里显式指定构造参数。这种场景的参数值默认都是解析过的，因此不须要解析，该场景要求对应的构造对象的参数数量必须和指定的同样。
  2. BeanDefinition对象中指定ConstructorArgumentValues。这种场景的参数值须要通过两步转换，该场景要求对应的构造对象的参数数量不小于指定的数量。
public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
			@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {

		BeanWrapperImpl bw = new BeanWrapperImpl();
		this.beanFactory.initBeanWrapper(bw);
		
        // 定义最终用于实例化对象的构造器
		Constructor<?> constructorToUse = null;
        // 定义存放（“未解析”、“解析未完成”、“解析完成”）构造参数的对象
		ArgumentsHolder argsHolderToUse = null;
        // 定义最终用于实例化对象的构造参数
		Object[] argsToUse = null;
		
        // 入参显式声明了构造参数（场景一），则不须要解析参数列表值，但需解析构造对象
		if (explicitArgs != null) {
			argsToUse = explicitArgs;
		}
		else {
			Object[] argsToResolve = null;
            // BeanDefinition对象中指定ConstructorArgumentValues（场景二），若是参数列表值或构造对象已经解析，则不须要再解析
			synchronized (mbd.constructorArgumentLock) {
				constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
				if (constructorToUse != null && mbd.constructorArgumentsResolved) {
					// Found a cached constructor...
					argsToUse = mbd.resolvedConstructorArguments;
					if (argsToUse == null) {
						argsToResolve = mbd.preparedConstructorArguments;
					}
				}
			}
			if (argsToResolve != null) {
				argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve, true);
			}
		}
		
        // 进入解析参数列表值和构造对象
		if (constructorToUse == null || argsToUse == null) {
			// 若是入参里没有显式指定构造对象的数组，使用反射方式获取
			Constructor<?>[] candidates = chosenCtors;
			if (candidates == null) {
				Class<?> beanClass = mbd.getBeanClass();
				try {
                    // BeanDefinition中能够定义是否包括非public的方法
					candidates = (mbd.isNonPublicAccessAllowed() ?
							beanClass.getDeclaredConstructors() : beanClass.getConstructors());
				}
				catch (Throwable ex) {
					// 省略代码······
				}
			}
			
            // 若是数组中只有一个无参构造，且入参和BeanDefinition中都未指定参数列表值，则标记该BeanDefinition对象的构造参数已解析，并实例化bean
			if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
				// 省略代码······
			}

			// 判断是否须要解析构造
			boolean autowiring = (chosenCtors != null ||
					mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
            // 这里存放“解析未完成”的参数列表值
			ConstructorArgumentValues resolvedValues = null;
			
            // 获取要求构造参数的最小数量
			int minNrOfArgs;
            // 入参显式声明了构造参数（场景一），minNrOfArgs即为指定数组的长度
			if (explicitArgs != null) {
				minNrOfArgs = explicitArgs.length;
			}
			else {
                // BeanDefinition对象中指定ConstructorArgumentValues（场景二），则须要计算minNrOfArgs，并进行“未解析” --> “解析未完成”的转换
				ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
				resolvedValues = new ConstructorArgumentValues();
				minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
			}
			// 根据参数数量从小到大排列
			AutowireUtils.sortConstructors(candidates);
			int minTypeDiffWeight = Integer.MAX_VALUE;
			Set<Constructor<?>> ambiguousConstructors = null;
			LinkedList<UnsatisfiedDependencyException> causes = null;
			
            // 遍历候选的构造对象
			for (Constructor<?> candidate : candidates) {
				// 获取当前构造对象的参数数量
				int parameterCount = candidate.getParameterCount();
				//  若是上一个循环已经找到匹配的构造对象，则跳出循环1
				if (constructorToUse != null && argsToUse != null && argsToUse.length > parameterCount) {
					break;
				}
                
                // 若是当前构造对象的参数数量小于minNrOfArgs，则遍历下一个
                // 注意，入参里显式指定构造参数（场景一）要求对应的构造对象的参数数量必须和指定的同样。BeanDefinition对象中指定ConstructorArgumentValues（场景二）要求对应的构造对象的参数数量不小于指定的数量
				if (parameterCount < minNrOfArgs) {
					continue;
				}

				ArgumentsHolder argsHolder;
                // 获取当前构造对象的参数类型数组
				Class<?>[] paramTypes = candidate.getParameterTypes();
                // BeanDefinition对象中指定ConstructorArgumentValues（场景二）的状况
				if (resolvedValues != null) {
                    // 进行“解析未完成”->“解析完成”的转换
					try {
                        // 这里是为了处理JDK6的ConstructorProperties注解，其余状况都会返回null。
						String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, parameterCount);
						if (paramNames == null) {
							ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
							if (pnd != null) {
                                // 获取当前构造对象的参数名数组
								paramNames = pnd.getParameterNames(candidate);
							}
						}
                        // 建立ArgumentsHolder对象
						argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
								getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
					}
					catch (UnsatisfiedDependencyException ex) {
						// 省略代码······
						continue;
					}
				}
                // 入参里显式指定构造参数（场景一）的状况
				else {
                    // 若是当前构造参数的数量小于指定参数的数量，则继续循环
					if (parameterCount != explicitArgs.length) {
						continue;
					}
                    // 建立ArgumentsHolder对象，由于不须要解析参数，因此，这种状况raw、prepared、resolved都是同样的
					argsHolder = new ArgumentsHolder(explicitArgs);
				}
				// 计算指定参数和当前构造的参数类型的差别值
				int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
						argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
				// 差别值小于阈值
				if (typeDiffWeight < minTypeDiffWeight) {
					// 获得匹配的构造对象和构造参数
					constructorToUse = candidate;
					argsHolderToUse = argsHolder;
					argsToUse = argsHolder.arguments;
					minTypeDiffWeight = typeDiffWeight;
					ambiguousConstructors = null;
				}
                // 差别值大于阈值，这种不考虑
				else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
					// 省略代码······
				}
			}
			// 若是找不到合适的构造对象，则会抛错
			if (constructorToUse == null) {
				// 省略代码······
			}
			else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
				// 省略代码······
			}
			// BeanDefinition对象中指定ConstructorArgumentValues（场景二），为了复用解析好的构造和参数列表，须要标记当前BeanDefinition的构造参数已解析
			if (explicitArgs == null && argsHolderToUse != null) {
				argsHolderToUse.storeCache(mbd, constructorToUse);
			}
		}

		Assert.state(argsToUse != null, "Unresolved constructor arguments");
        // 接下来就是使用构造对象和参数来实例化对象，就不往下看了。
		bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
		return bw;
	}

实例化部分比较难，主要还得先理解一些抽象概念，例如：两个场景、参数的转换等。

属性装配

进入AbstractAutowireCapableBeanFactory.populateBean(String, RootBeanDefinition, BeanWrapper)。这个方法包括如下过程：

  1. 执行咱们注册的InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法，若是返回了 false，则不进行属性装配，直接返回；
  2. 获取 beanDefinition 中的PropertyValues对象，根据 beanDefinition 设置的注入类型，填充PropertyValues对象；
  3. 执行咱们注册的InstantiationAwareBeanPostProcessor的postProcessProperties方法，能够对PropertyValues对象进行修改;
  4. 依赖检查（若是设置了）；
  5. 进行属性装配。
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 {
				return;
			}
		}

		// 执行咱们注册的InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法，若是返回了false，则不进行属性装配，直接返回
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						return;
					}
				}
			}
		}
		
        // 获取BeanDefinition对象中的PropertyValues，包含了name=value的PropertyValue对象的列表
		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);
			// 按名字装配
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// 按类型装配
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}
		// beanFactory中是否注册了InstantiationAwareBeanPostProcessors
		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
        // BeanDefinition对象中是否设置了依赖检查
		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

		PropertyDescriptor[] filteredPds = null;
		if (hasInstAwareBpps) {
			if (pvs == null) {
                // 若是为空，再次从BeanDefinition对象中获取，TODO？
				pvs = mbd.getPropertyValues();
			}
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    // 执行咱们注册的InstantiationAwareBeanPostProcessor的postProcessProperties方法，能够对PropertyValues对象进行修改
					PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
					// 省略部分代码······
					pvs = pvsToUse;
				}
			}
		}
        // 若是BeanDefinition对象中设置了依赖检查，则须要检查依赖设置
		if (needsDepCheck) {
			if (filteredPds == null) {
				filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			}
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}

		if (pvs != null) {
            // 执行属性装配
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

这个方法中主要涉及autowireByName、autowireByType和applyPropertyValues三个方法，前两个暂时不展开，只讲最后一个方法。

几个重要的知识点

在分析applyPropertyValues方法以前，咱们须要知道一下几个知识点。这里以User这个类来展开例子。

public class User {
    
    private String name;
    
    private int age;
    
    private Address address;
    
    private List<String> hobbies;
}
class Address {
    private String region;
    private String desc;
}

propertyName的几种形式

当咱们给 beanDefinition设置属性值时，通常都会这样采用这样的赋值，这里成为“普通形式”。

rootBeanDefinition.getPropertyValues().add("name", "zzs001");
rootBeanDefinition.getPropertyValues().add("age", 18);
rootBeanDefinition.getPropertyValues().add("address", new Address("", ""));
rootBeanDefinition.getPropertyValues().add("hobbies", new ArrayList());

针对类型为 object、list、array、map 等成员属性，spring 还支持其余的赋值方式，以下，分别成为“嵌套对象形式”和“索引形式”：

// 嵌套对象形式
rootBeanDefinition.getPropertyValues().add("address.region", "");
rootBeanDefinition.getPropertyValues().add("address.desc", "");
// 索引形式
rootBeanDefinition.getPropertyValues().add("hobbies[0]", "");

正是因为 propertyName 引入了多种的形式，因此，本来简单的赋值行为被搞得很是复杂。例如，嵌套对象形式还能够是这样：foo.user.address.region，几乎能够一直嵌套下去。

PropertyAccessor

propertyAccessor 对象通常绑定了一个实例对象，经过PropertyAccessor接口的方法能够对对象的属性进行存取操做。属性装配中最终对成员属性赋值就是调用它的setPropertyValue方法。AbstractNestablePropertyAccessor中维护了一个 map，key 为当前绑定对象的属性名（不包含嵌套和索引），value 就是对于的PropertyAccessor对象。

public abstract class AbstractNestablePropertyAccessor extends AbstractPropertyAccessor {
    private Map<String, AbstractNestablePropertyAccessor> nestedPropertyAccessors;
}

在上面的例子中，

rootBeanDefinition.getPropertyValues().add("name", "zzs001");
rootBeanDefinition.getPropertyValues().add("age", 18);

这种形式共用一个绑定了User类型实例的PropertyAccessor对象。

// 嵌套对象形式
rootBeanDefinition.getPropertyValues().add("address.region", "");
rootBeanDefinition.getPropertyValues().add("address.desc", "");

这种形式共用一个绑定了Address类型实例的PropertyAccessor对象，该对象和"address"这个名字关联起来维护在 nestedPropertyAccessors 中。

// 索引形式
rootBeanDefinition.getPropertyValues().add("hobbies[0]", "");

这种形式也是一个绑定了User类型实例的PropertyAccessor对象，该对象和"hobbies"这个名字关联起来维护在 nestedPropertyAccessors 中。

PropertyTokenHolder

PropertyTokenHolder是AbstractNestablePropertyAccessor的内部类，它更多的是针对“索引形式”的 propertyName。例如，"hobbies[0]"对于的PropertyTokenHolder中，actualName = hobbies，canonicalName = [0]，keys = {0}。

protected static class PropertyTokenHolder {

		public PropertyTokenHolder(String name) {
			this.actualName = name;
			this.canonicalName = name;
		}

		public String actualName;

		public String canonicalName;

		@Nullable
		public String[] keys;
	}

接下来继续分析属性装配的代码。

applyPropertyValues

进入AbstractAutowireCapableBeanFactory.applyPropertyValues(String, BeanDefinition, BeanWrapper, PropertyValues)方法。和构造参数同样，设置成员属性的参数也须要通过“两次转换”，这里就不详细讲解。这个方法主要包括如下过程：

  1. 获取属性对象列表，若是这个列表的属性对象都已经完成“两次转换”，则直接装配属性；
  2. 遍历属性对象列表，分别进行两次转换，若是列表中没有相似BeanDefinition、BeanDefinitionHolder等的对象，则设置PropertyValues对象已经转换完成，下次调用这个方法不用再进行转换；
  3. 属性装配。
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
        // 若是没有须要注入的属性，直接返回
		if (pvs.isEmpty()) {
			return;
		}

		// 省略部分代码······

		MutablePropertyValues mpvs = null;
        
        // 获取属性对象列表
		List<PropertyValue> original;
		if (pvs instanceof MutablePropertyValues) {
			mpvs = (MutablePropertyValues) pvs;
            // 若是全部属性对象已经完成“两次转换”，则直接装配属性
			if (mpvs.isConverted()) {
				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;
		}
        // 建立第一次转换所用的解析器
		BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
		
        // 定义一个列表，用于存放完成“两次转换”的属性对象
		// 这注意，这里并无进行所谓的复制，不要被命名迷惑了
		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;
                // 若是当前属性为可写属性，且属性名不是相似于foo.bar或addresses[0]的形式，则须要进行第二次转换
				boolean convertible = bw.isWritableProperty(propertyName) &&
						!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
				if (convertible) {
					convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
				}
				// 若是转换后的属性对象和初始对象同样，通常指的是普通对象，而不是BeanDefinition、BeanDefinitionHolder等
				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));
				}
			}
		}
        // 若是不包含BeanDefinition、BeanDefinitionHolder等对象，则设置PropertyValues为已转换，这样下次调用这个方法，就不须要进行任何的转换了
		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);
		}
	}

进入AbstractPropertyAccessor.setPropertyValues(PropertyValues)方法。这里遍历属性对象列表，逐个进赋值操做。

public void setPropertyValues(PropertyValues pvs) throws BeansException {
        // 入参适配
        // 后面两个参数分别表明：是否忽略NotWritablePropertyException异常、是否忽略NullValueInNestedPathException异常
		setPropertyValues(pvs, false, false);
	}
	public void setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)
			throws BeansException {

        // 获取属性对象列表
		List<PropertyValue> propertyValues = (pvs instanceof MutablePropertyValues ?
				((MutablePropertyValues) pvs).getPropertyValueList() : Arrays.asList(pvs.getPropertyValues()));
		for (PropertyValue pv : propertyValues) {
            	// 省略try-catch的代码和其余异常相关的代码······
				setPropertyValue(pv);
            }
	}

setPropertyValue

进入AbstractNestablePropertyAccessor.setPropertyValue(PropertyValue)。这个方法包括如下过程：

  1. 获取 propertyName 对应的PropertyAccessor对象，这里将解析“嵌套对象形式”的 propertyName；
  2. 建立PropertyTokenHolder对象，这里将解析“索引形式”的 propertyName；
  3. 使用PropertyAccessor对象进行赋值操做。
public void setPropertyValue(PropertyValue pv) throws BeansException {
        // 适配入参
		setPropertyValue(pv.getName(), pv.getValue());
	}	
	public void setPropertyValue(String propertyName, @Nullable Object value) throws BeansException {
		AbstractNestablePropertyAccessor nestedPa;
		try {
            // 获取propertyName对应的PropertyAccessor对象，这里将解析“嵌套对象形式”的propertyName
            // 若是缓存里有的话，将复用
			nestedPa = getPropertyAccessorForPropertyPath(propertyName);
		}
		catch (NotReadablePropertyException ex) {
			throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
					"Nested property in path '" + propertyName + "' does not exist", ex);
		}
        // 建立PropertyTokenHolder对象，这里将解析“索引形式”的propertyName
		PropertyTokenHolder tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
        // 使用PropertyAccessor对象进行赋值操做
		nestedPa.setPropertyValue(tokens, new PropertyValue(propertyName, value));
	}

进入AbstractNestablePropertyAccessor.setPropertyValue(PropertyTokenHolder, PropertyValue)方法。这里根据 propertyName 是否为“索引形式”调用不一样的方法。

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

这里咱们不看 propertyName 为“索引形式”的方法，只看processLocalProperty。

private void processLocalProperty(PropertyTokenHolder tokens, PropertyValue pv) {
        // 获取actualName对应的PropertyHandler对象，若是有缓存则复用
		PropertyHandler ph = getLocalPropertyHandler(tokens.actualName);
		if (ph == null || !ph.isWritable()) {
			// 省略部分代码······
		}

		Object oldValue = null;
		try {
			Object originalValue = pv.getValue();
			Object valueToApply = originalValue;
			if (!Boolean.FALSE.equals(pv.conversionNecessary)) {
                // 由于咱们的属性参数都是转换过的，因此这里再也不看转换的代码
				if (pv.isConverted()) {
					valueToApply = pv.getConvertedValue();
				}
				else {
					// 省略部分代码······
				}
				pv.getOriginalPropertyValue().conversionNecessary = (valueToApply != originalValue);
			}
            // 接下来就是经过反射方式给属性赋值，后续再展开
			ph.setValue(valueToApply);
		}
		catch (Exception ex) {
			// 省略部分代码······
        }
	}

属性装配的代码分析就点到为止吧。

最后补充

以上基本看完 spring-bean 的源码。针对 getBean 的过程，本文未展开的内容包括：

  1. 获取和建立多例 bean；
  2. 无参构造实例化；
  3. 属性装配中，属性值列表的填充（autowireByName和autowireByType）、属性名为索引形式的属性装配
  4. bean 的初始化。

感兴趣的读者能够自行分析。另外，以上内容若有错误，欢迎指正。

最后，感谢阅读。

相关源码请移步： spring-beans

本文为原创文章，转载请附上原文出处连接：http://www.javashuo.com/article/p-wyermzob-gw.html

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程