spring5源码-基于XML的依赖注入

ゝ一纸荒年。 2021-12-10 12:21 257阅读 0赞

转载https://blog.csdn.net/huyang0304/article/details/82958594

总结：  
获取bean时候，先从缓存中拿bean，否则创建createBean  
先实例化createBeanInstance，然后初始化populateBean

## 1、依赖注入发生的时间 ##

当SpringIOC容器完成了Bean定义资源的定位、载入和解析注册以后，IOC容器中已经管理类Bean定义的相关数据，但是此时IOC容器还没有对所管理的Bean进行依赖注入，依赖注入在以下两种情况发生：

(1).用户第一次通过getBean方法向IOC容索要Bean时，IOC容器触发依赖注入。

(2).当用户在Bean定义资源中为元素配置了lazy-init属性，即让容器在解析注册Bean定义时进行预实例化，触发依赖注入。

BeanFactory接口定义了SpringIOC容器的基本功能规范，是SpringIOC容器所应遵守的最底层和最基本的编程规范。BeanFactory接口中定义了几个getBean方法，就是用户向IOC容器索取管理的Bean的方法，我们通过分析其子类的具体实现，理解SpringIOC容器在用户索取Bean时如何完成依赖注入。

## 2、AbstractBeanFactory通过getBean向IOC容器获取被管理的Bean ##

AbstractBeanFactory的getBean相关方法的源码如下：

public Object getBean(String name) throws BeansException {
    		return doGetBean(name, null, null, false);
    	}
    
    	/**
    	 * Return an instance, which may be shared or independent, of the specified bean.
    	 * @param name the name of the bean to retrieve
    	 * @param requiredType the required type of the bean to retrieve
    	 * @param args arguments to use when creating a bean instance using explicit arguments
    	 * (only applied when creating a new instance as opposed to retrieving an existing one)
    	 * @param typeCheckOnly whether the instance is obtained for a type check,
    	 * not for actual use
    	 * @return an instance of the bean
    	 * @throws BeansException if the bean could not be created
    	 */
    	@SuppressWarnings("unchecked")
    	protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
    			@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    
    		final String beanName = transformedBeanName(name);
    		Object bean;
    
    		// Eagerly check singleton cache for manually registered singletons.
    		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 = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    		}
    
    		else {
    			// Fail if we're already creating this bean instance:
    			// We're assumably within a circular reference.
    			if (isPrototypeCurrentlyInCreation(beanName)) {
    				throw new BeanCurrentlyInCreationException(beanName);
    			}
    
    			// Check if bean definition exists in this factory.
    			BeanFactory parentBeanFactory = getParentBeanFactory();
    			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    				// Not found -> check parent.
    				String nameToLookup = originalBeanName(name);
    				if (parentBeanFactory instanceof AbstractBeanFactory) {
    					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
    							nameToLookup, requiredType, args, typeCheckOnly);
    				}
    				else if (args != null) {
    					// Delegation to parent with explicit args.
    					return (T) parentBeanFactory.getBean(nameToLookup, args);
    				}
    				else {
    					// No args -> delegate to standard getBean method.
    					return parentBeanFactory.getBean(nameToLookup, requiredType);
    				}
    			}
    
    			if (!typeCheckOnly) {
    				markBeanAsCreated(beanName);
    			}
    
    			try {
    				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    				checkMergedBeanDefinition(mbd, beanName, args);
    
    				// Guarantee initialization of beans that the current bean depends on.
    				String[] dependsOn = mbd.getDependsOn();
    				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 + "'");
    						}
    						registerDependentBean(dep, beanName);
    						try {
    							getBean(dep);
    						}
    						catch (NoSuchBeanDefinitionException ex) {
    							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
    						}
    					}
    				}
    
    				// Create bean instance.
    				if (mbd.isSingleton()) {
    					sharedInstance = getSingleton(beanName, () -> {
    						try {
    							return createBean(beanName, mbd, args);
    						}
    						catch (BeansException ex) {
    							// Explicitly remove instance from singleton cache: It might have been put there
    							// eagerly by the creation process, to allow for circular reference resolution.
    							// Also remove any beans that received a temporary reference to the bean.
    							destroySingleton(beanName);
    							throw ex;
    						}
    					});
    					bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    				}
    
    				else if (mbd.isPrototype()) {
    					// It's a prototype -> create a new instance.
    					Object prototypeInstance = null;
    					try {
    						beforePrototypeCreation(beanName);
    						prototypeInstance = createBean(beanName, mbd, args);
    					}
    					finally {
    						afterPrototypeCreation(beanName);
    					}
    					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
    				}
    
    				else {
    					String scopeName = mbd.getScope();
    					final Scope scope = this.scopes.get(scopeName);
    					if (scope == null) {
    						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
    					}
    					try {
    						Object scopedInstance = scope.get(beanName, () -> {
    							beforePrototypeCreation(beanName);
    							try {
    								return createBean(beanName, mbd, args);
    							}
    							finally {
    								afterPrototypeCreation(beanName);
    							}
    						});
    						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
    					}
    					catch (IllegalStateException ex) {
    						throw new BeanCreationException(beanName,
    								"Scope '" + scopeName + "' is not active for the current thread; consider " +
    								"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
    								ex);
    					}
    				}
    			}
    			catch (BeansException ex) {
    				cleanupAfterBeanCreationFailure(beanName);
    				throw ex;
    			}
    		}
    
    		// Check if required type matches the type of the actual bean instance.
    		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;
    	}

获取Bean方法的分析，我们可以看到在Spring中，如果Bean定义的单例模式(Singleton)，则容器在创建之前先从缓存中查找，以确保整个容器中只存在一个实例对象。如果Bean定义的是原型模式(Prototype)，则容器每次都会创建一个新的实例对象。除此之外，Bean定义还可以扩展为指定其生命周期范围。

上面的源码只是定义了根据Bean定义的模式，采取的不同创建Bean实例对象的策略，具体的Bean实例对象的创建过程由实现了ObejctFactory接口的匿名内部类的createBean方法完成，ObejctFactory使用委派模式，具体的Bean实例创建过程交由其实现类AbstractAutowireCapableBeanFactory完成，我们继续分析AbstractAutowireCapableBeanFactory的createBean方法的源码，理解其创建Bean实例的具体实现过程。

DefaultSingletonBeanRegistry

/**
    	 * Return the (raw) singleton object registered under the given name,
    	 * creating and registering a new one if none registered yet.
    	 * @param beanName the name of the bean
    	 * @param singletonFactory the ObjectFactory to lazily create the singleton
    	 * with, if necessary
    	 * @return the registered singleton object
    	 */
    	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    		Assert.notNull(beanName, "Bean name must not be null");
    		synchronized (this.singletonObjects) {
    			Object singletonObject = this.singletonObjects.get(beanName);
    			if (singletonObject == null) {
    				if (this.singletonsCurrentlyInDestruction) {
    					throw new BeanCreationNotAllowedException(beanName,
    							"Singleton bean creation not allowed while singletons of this factory are in destruction " +
    							"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
    				}
    				if (logger.isDebugEnabled()) {
    					logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
    				}
    				beforeSingletonCreation(beanName);
    				boolean newSingleton = false;
    				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
    				if (recordSuppressedExceptions) {
    					this.suppressedExceptions = new LinkedHashSet<>();
    				}
    				try {
    					singletonObject = singletonFactory.getObject();
    					newSingleton = true;
    				}
    				catch (IllegalStateException ex) {
    					// Has the singleton object implicitly appeared in the meantime ->
    					// if yes, proceed with it since the exception indicates that state.
    					singletonObject = this.singletonObjects.get(beanName);
    					if (singletonObject == null) {
    						throw ex;
    					}
    				}
    				catch (BeanCreationException ex) {
    					if (recordSuppressedExceptions) {
    						for (Exception suppressedException : this.suppressedExceptions) {
    							ex.addRelatedCause(suppressedException);
    						}
    					}
    					throw ex;
    				}
    				finally {
    					if (recordSuppressedExceptions) {
    						this.suppressedExceptions = null;
    					}
    					afterSingletonCreation(beanName);
    				}
    				if (newSingleton) {
    					addSingleton(beanName, singletonObject);
    				}
    			}
    			return singletonObject;
    		}
    	}

## 3、AbstractAutowireCapableBeanFactory创建Bean实例对象 ##

AbstractAutowireCapableBeanFactory

/**
    	 * Central method of this class: creates a bean instance,
    	 * populates the bean instance, applies post-processors, etc.
    	 * @see #doCreateBean
    	 */
    	@Override
    	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;
    
    		// Make sure bean class is actually resolved at this point, and
    		// clone the bean definition in case of a dynamically resolved Class
    		// which cannot be stored in the shared merged bean definition.
    		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 {
    			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
    			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 {
    			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(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    			throws BeanCreationException {
    
    		// Instantiate the bean.
    		BeanWrapper instanceWrapper = null;
    		if (mbd.isSingleton()) {
    			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    		}
    		if (instanceWrapper == null) {
    			instanceWrapper = createBeanInstance(beanName, mbd, args);
    		}
    		final Object bean = instanceWrapper.getWrappedInstance();
    		Class<?> beanType = instanceWrapper.getWrappedClass();
    		if (beanType != NullBean.class) {
    			mbd.resolvedTargetType = beanType;
    		}
    
    		// Allow post-processors to modify the merged bean definition.
    		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;
    			}
    		}
    
    		// Eagerly cache singletons to be able to resolve circular references
    		// even when triggered by lifecycle interfaces like BeanFactoryAware.
    		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));
    		}
    
    		// Initialize the bean instance.
    		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);
    			}
    		}
    
    		if (earlySingletonExposure) {
    			Object earlySingletonReference = getSingleton(beanName, false);
    			if (earlySingletonReference != null) {
    				if (exposedObject == bean) {
    					exposedObject = earlySingletonReference;
    				}
    				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
    					String[] dependentBeans = getDependentBeans(beanName);
    					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
    					for (String dependentBean : dependentBeans) {
    						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 " +
    								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
    					}
    				}
    			}
    		}
    
    		// Register bean as disposable.
    		try {
    			registerDisposableBeanIfNecessary(beanName, bean, mbd);
    		}
    		catch (BeanDefinitionValidationException ex) {
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    		}
    
    		return exposedObject;
    	}

通过对方法源码的分析，我们看到具体的依赖注入实现在以下两个方法中：

(1).createBeanInstance：生成Bean所包含的java对象实例。

(2).populateBean：对Bean属性的依赖注入进行处理。

## 4、createBeanInstance方法创建Bean的java实例对象 ##

AbstractAutowireCapableBeanFactory

/**
    	 * Create a new instance for the specified bean, using an appropriate instantiation strategy:
    	 * factory method, constructor autowiring, or simple instantiation.
    	 * @param beanName the name of the bean
    	 * @param mbd the bean definition for the bean
    	 * @param args explicit arguments to use for constructor or factory method invocation
    	 * @return a BeanWrapper for the new instance
    	 * @see #obtainFromSupplier
    	 * @see #instantiateUsingFactoryMethod
    	 * @see #autowireConstructor
    	 * @see #instantiateBean
    	 */
    	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    		// Make sure bean class is actually resolved at this point.
    		Class<?> beanClass = resolveBeanClass(mbd, beanName);
    
    		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);
    		}
    
    		// Shortcut when re-creating the same bean...
    		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);
    			}
    		}
    
    		// Candidate constructors for autowiring?
    		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
    				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
    			return autowireConstructor(beanName, mbd, ctors, args);
    		}
    
    		// No special handling: simply use no-arg constructor.
    		return instantiateBean(beanName, mbd);
    	}
    
    
    	/**
    	 * Instantiate the given bean using its default constructor.
    	 * @param beanName the name of the bean
    	 * @param mbd the bean definition for the bean
    	 * @return a BeanWrapper for the new instance
    	 */
    	protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
    		try {
    			Object beanInstance;
    			final BeanFactory parent = this;
    			if (System.getSecurityManager() != null) {
    				beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
    						getInstantiationStrategy().instantiate(mbd, beanName, parent),
    						getAccessControlContext());
    			}
    			else {
    				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
    			}
    			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
    			initBeanWrapper(bw);
    			return bw;
    		}
    		catch (Throwable ex) {
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
    		}
    	}

经过对上面的代码分析，我们可以看出，对使用工厂方法和自动装配特性的Bean的实例化相当比较清楚，调用相应的工厂方法或者参数匹配的构造方法即可完成实例化对象的工作，但是对于我们最常使用的默认无参构造方法就需要使用相应的初始化策略(JDK的反射机制或者CGLIB)来进行初始化了，在方法getInstantiationStrategy().instantiate()中就具体实现类使用初始策略实例化对象。

## 5、SimpleInstantiationStrategy类使用默认的无参构造方法创建Bean实例化对象 ##

SimpleInstantiationStrategy

@Override
    	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();
    					if (clazz.isInterface()) {
    						throw new BeanInstantiationException(clazz, "Specified class is an interface");
    					}
    					try {
    						if (System.getSecurityManager() != null) {
    							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);
    					}
    				}
    			}
    			return BeanUtils.instantiateClass(constructorToUse);
    		}
    		else {
    			// Must generate CGLIB subclass.
    			return instantiateWithMethodInjection(bd, beanName, owner);
    		}
    	}

通过上面的代码分析，我们看到了如果Bean有方法被覆盖了，则使用JDK的反射机制进行实例化，否则，使用CGLIB进行实例化。

BeanUtils

/**
    	 * Convenience method to instantiate a class using the given constructor.
    	 * <p>Note that this method tries to set the constructor accessible if given a
    	 * non-accessible (that is, non-public) constructor, and supports Kotlin classes
    	 * with optional parameters and default values.
    	 * @param ctor the constructor to instantiate
    	 * @param args the constructor arguments to apply (use {@code null} for an unspecified
    	 * parameter if needed for Kotlin classes with optional parameters and default values)
    	 * @return the new instance
    	 * @throws BeanInstantiationException if the bean cannot be instantiated
    	 * @see Constructor#newInstance
    	 */
    	public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
    		Assert.notNull(ctor, "Constructor must not be null");
    		try {
    			ReflectionUtils.makeAccessible(ctor);
    			return (KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ?
    					KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args));
    		}
    		catch (InstantiationException ex) {
    			throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
    		}
    		catch (IllegalAccessException ex) {
    			throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
    		}
    		catch (IllegalArgumentException ex) {
    			throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
    		}
    		catch (InvocationTargetException ex) {
    			throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
    		}
    	}

CglibSubclassingInstantiationStrategy

@Override
    	protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
    		return instantiateWithMethodInjection(bd, beanName, owner, null);
    	}
    
    	@Override
    	protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
    			@Nullable Constructor<?> ctor, @Nullable Object... args) {
    
    		// Must generate CGLIB subclass...
    		return new CglibSubclassCreator(bd, owner).instantiate(ctor, args);
    	}
    
    
    	/**
    	 * An inner class created for historical reasons to avoid external CGLIB dependency
    	 * in Spring versions earlier than 3.2.
    	 */
    	private static class CglibSubclassCreator {
    
    		private static final Class<?>[] CALLBACK_TYPES = new Class<?>[]
    				{NoOp.class, LookupOverrideMethodInterceptor.class, ReplaceOverrideMethodInterceptor.class};
    
    		private final RootBeanDefinition beanDefinition;
    
    		private final BeanFactory owner;
    
    		CglibSubclassCreator(RootBeanDefinition beanDefinition, BeanFactory owner) {
    			this.beanDefinition = beanDefinition;
    			this.owner = owner;
    		}
    
    		/**
    		 * Create a new instance of a dynamically generated subclass implementing the
    		 * required lookups.
    		 * @param ctor constructor to use. If this is {@code null}, use the
    		 * no-arg constructor (no parameterization, or Setter Injection)
    		 * @param args arguments to use for the constructor.
    		 * Ignored if the {@code ctor} parameter is {@code null}.
    		 * @return new instance of the dynamically generated subclass
    		 */
    		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;
    		}
    
    		/**
    		 * Create an enhanced subclass of the bean class for the provided bean
    		 * definition, using CGLIB.
    		 */
    		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();
    		}
    	}

## 6、populateBean方法对Bean属性的依赖注入 ##

在第3步的分析中我们已经了解到Bean的依赖注入分为以下两个过程：

(1).createBeanInstance：生成Bean所包含的Java对象实例。

(2).populateBean：对Bean属性的依赖注入进行处理。

上面我们已经分析了容器初始化生成Bean所包含的Java实例对象的过程，现在我们继续分析生成对象后，SpringIOC容器是如何将Bean的属性依赖关系注入Bean实例对象中并设置好的，属性依赖注入的代码如下  
AbstractAutowireCapableBeanFactory

/**
    	 * Populate the bean instance in the given BeanWrapper with the property values
    	 * from the bean definition.
    	 * @param beanName the name of the bean
    	 * @param mbd the bean definition for the bean
    	 * @param bw the BeanWrapper with bean instance
    	 */
    	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.
    		boolean continueWithPropertyPopulation = true;
    
    		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
    			for (BeanPostProcessor bp : getBeanPostProcessors()) {
    				if (bp instanceof InstantiationAwareBeanPostProcessor) {
    					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
    					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
    						continueWithPropertyPopulation = false;
    						break;
    					}
    				}
    			}
    		}
    
    		if (!continueWithPropertyPopulation) {
    			return;
    		}
    
    		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
    
    		if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
    			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
    			// Add property values based on autowire by name if applicable.
    			if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
    				autowireByName(beanName, mbd, bw, newPvs);
    			}
    			// Add property values based on autowire by type if applicable.
    			if (mbd.getResolvedAutowireMode() == 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);
    		}
    	}
    
    
    	/**
    	 * Apply the given property values, resolving any runtime references
    	 * to other beans in this bean factory. Must use deep copy, so we
    	 * don't permanently modify this property.
    	 * @param beanName the bean name passed for better exception information
    	 * @param mbd the merged bean definition
    	 * @param bw the BeanWrapper wrapping the target object
    	 * @param pvs the new property values
    	 */
    	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;
    		}
    		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);
    				}
    				// Possibly store converted value in merged bean definition,
    				// in order to avoid re-conversion for every created bean instance.
    				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();
    		}
    
    		// Set our (possibly massaged) deep copy.
    		try {
    			bw.setPropertyValues(new MutablePropertyValues(deepCopy));
    		}
    		catch (BeansException ex) {
    			throw new BeanCreationException(
    					mbd.getResourceDescription(), beanName, "Error setting property values", ex);
    		}
    	}

分析上述代码，我们可以看出，对属性的注入过程分以下两种情况：

(1).属性值类型不需要转换时，不需要解析属性值，直接准备进行依赖注入。

(2).属性值需要进行类型转换时，如对其他对象的引用等，首先需要解析属性值，然后对解析后的属性值进行依赖注入。

对属性值的解析是在BeanDefinitionValueResolver类中的resolveValueIfNecessary方法中进行的，对属性值的依赖注入是通过bw.setPropertyValues方法实现的，在分析属性值的依赖注入之前，我们先分析一下对属性值的解析过程。

## 7、BeanDefinitionValueResolver解析属性值 ##

BeanDefinitionValueResolver

/**
    	 * Given a PropertyValue, return a value, resolving any references to other
    	 * beans in the factory if necessary. The value could be:
    	 * <li>A BeanDefinition, which leads to the creation of a corresponding
    	 * new bean instance. Singleton flags and names of such "inner beans"
    	 * are always ignored: Inner beans are anonymous prototypes.
    	 * <li>A RuntimeBeanReference, which must be resolved.
    	 * <li>A ManagedList. This is a special collection that may contain
    	 * RuntimeBeanReferences or Collections that will need to be resolved.
    	 * <li>A ManagedSet. May also contain RuntimeBeanReferences or
    	 * Collections that will need to be resolved.
    	 * <li>A ManagedMap. In this case the value may be a RuntimeBeanReference
    	 * or Collection that will need to be resolved.
    	 * <li>An ordinary object or {@code null}, in which case it's left alone.
    	 * @param argName the name of the argument that the value is defined for
    	 * @param value the value object to resolve
    	 * @return the resolved object
    	 */
    	@Nullable
    	public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
    		// We must check each value to see whether it requires a runtime reference
    		// to another bean to be resolved.
    		if (value instanceof RuntimeBeanReference) {
    			RuntimeBeanReference ref = (RuntimeBeanReference) value;
    			return resolveReference(argName, ref);
    		}
    		else if (value instanceof RuntimeBeanNameReference) {
    			String refName = ((RuntimeBeanNameReference) value).getBeanName();
    			refName = String.valueOf(doEvaluate(refName));
    			if (!this.beanFactory.containsBean(refName)) {
    				throw new BeanDefinitionStoreException(
    						"Invalid bean name '" + refName + "' in bean reference for " + argName);
    			}
    			return refName;
    		}
    		else if (value instanceof BeanDefinitionHolder) {
    			// Resolve BeanDefinitionHolder: contains BeanDefinition with name and aliases.
    			BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;
    			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);
    					}
    				}
    				else {
    					elementType = Object.class;
    				}
    			}
    			return resolveManagedArray(argName, (List<?>) value, elementType);
    		}
    		else if (value instanceof ManagedList) {
    			// May need to resolve contained runtime references.
    			return resolveManagedList(argName, (List<?>) value);
    		}
    		else if (value instanceof ManagedSet) {
    			// May need to resolve contained runtime references.
    			return resolveManagedSet(argName, (Set<?>) value);
    		}
    		else if (value instanceof ManagedMap) {
    			// May need to resolve contained runtime references.
    			return resolveManagedMap(argName, (Map<?, ?>) value);
    		}
    		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);
    		}
    	}
    
    
    	/**
    	 * Resolve a reference to another bean in the factory.
    	 */
    	@Nullable
    	private Object resolveReference(Object argName, RuntimeBeanReference ref) {
    		try {
    			Object 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);
    		}
    	}
    
    
    	/**
    	 * For each element in the managed array, resolve reference if necessary.
    	 */
    	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.set(resolved, i,
    					resolveValueIfNecessary(new KeyedArgName(argName, i), ml.get(i)));
    		}
    		return resolved;
    	}

我们明白了Spring是如何将引用类型，内部类以及集合类型等属性进行解析的，属性值解析完成后就可以进行依赖注入了，依赖注入的过程就是Bean对象实例设置到它所依赖的Bean对象属性上去，在第6步中我们已经说过，依赖注入是通过bw.setPropertyValues方法实现的，该方法也使用了委托模式，在BeanWrapper接口中至少定义了方法声明，依赖注入的具体实现交由其实现类BeanWrapperImpl来完成，下面我们就分析依BeanWrapperImpl中赖注入相关的源码。

8、BeanWrapperImpl对Bean属性的依赖注入  
AbstractPropertyAccessor

@Override
    	public void setPropertyValues(PropertyValues pvs) throws BeansException {
    		setPropertyValues(pvs, false, false);
    	}
    
    	@Override
    	public void setPropertyValues(PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)
    			throws BeansException {
    
    		List<PropertyAccessException> propertyAccessExceptions = null;
    		List<PropertyValue> propertyValues = (pvs instanceof MutablePropertyValues ?
    				((MutablePropertyValues) pvs).getPropertyValueList() : Arrays.asList(pvs.getPropertyValues()));
    		for (PropertyValue pv : propertyValues) {
    			try {
    				// This method may throw any BeansException, which won't be caught
    				// here, if there is a critical failure such as no matching field.
    				// We can attempt to deal only with less serious exceptions.
    				setPropertyValue(pv);
    			}
    			catch (NotWritablePropertyException ex) {
    				if (!ignoreUnknown) {
    					throw ex;
    				}
    				// Otherwise, just ignore it and continue...
    			}
    			catch (NullValueInNestedPathException ex) {
    				if (!ignoreInvalid) {
    					throw ex;
    				}
    				// Otherwise, just ignore it and continue...
    			}
    			catch (PropertyAccessException ex) {
    				if (propertyAccessExceptions == null) {
    					propertyAccessExceptions = new ArrayList<>();
    				}
    				propertyAccessExceptions.add(ex);
    			}
    		}
    
    		// If we encountered individual exceptions, throw the composite exception.
    		if (propertyAccessExceptions != null) {
    			PropertyAccessException[] paeArray = propertyAccessExceptions.toArray(new PropertyAccessException[0]);
    			throw new PropertyBatchUpdateException(paeArray);
    		}
    	}
    
    	@Override
    	public void setPropertyValue(PropertyValue pv) throws BeansException {
    		setPropertyValue(pv.getName(), pv.getValue());
    	}

AbstractNestablePropertyAccessor

@Override
    	public void setPropertyValue(String propertyName, @Nullable Object value) throws BeansException {
    		AbstractNestablePropertyAccessor nestedPa;
    		try {
    			nestedPa = getPropertyAccessorForPropertyPath(propertyName);
    		}
    		catch (NotReadablePropertyException ex) {
    			throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,
    					"Nested property in path '" + propertyName + "' does not exist", ex);
    		}
    		PropertyTokenHolder tokens = getPropertyNameTokens(getFinalPath(nestedPa, propertyName));
    		nestedPa.setPropertyValue(tokens, new PropertyValue(propertyName, value));
    	}
    
    
    	protected void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {
    		if (tokens.keys != null) {
    			processKeyedProperty(tokens, pv);
    		}
    		else {
    			processLocalProperty(tokens, pv);
    		}
    	}
    
    
    	@SuppressWarnings("unchecked")
    	private void processKeyedProperty(PropertyTokenHolder tokens, PropertyValue pv) {
    		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];
    
    		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);
    			}
    		}
    
    		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();
    			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);
    				}
    			}
    		}
    
    		else if (propValue instanceof Map) {
    			Class<?> mapKeyType = ph.getMapKeyType(tokens.keys.length);
    			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);
    			Object convertedMapKey = convertIfNecessary(null, null, lastKey, mapKeyType, typeDescriptor);
    			Object oldValue = null;
    			if (isExtractOldValueForEditor()) {
    				oldValue = map.get(convertedMapKey);
    			}
    			// Pass full property name and old value in here, since we want full
    			// conversion ability for map values.
    			Object convertedMapValue = convertIfNecessary(tokens.canonicalName, oldValue, pv.getValue(),
    					mapValueType, ph.nested(tokens.keys.length));
    			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;
    	}