Spring源码分析（二）BeanFactory

基础容器

创建基础容器

  对于基础容器，一般使用DefaultListableBeanFactory来作为容器类型。

public class DefaultListableBeanFactory {
	// 构造函数主要忽略了一些自动注入类型
	// 实际上这里只调用了super()方法，在其父类AbstractAutowireCapableBeanFactory的构造函数中调用了这些忽略函数
	// 之所以在父类中进行忽略，是因为这些忽略操作发生在对象的属性注入阶段，而对象的属性注入实际上是父类就具备的功能
	public DefaultListableBeanFactory() {
		ignoreDependencyInterface(BeanNameAware.class);
		ignoreDependencyInterface(BeanFactoryAware.class);
		ignoreDependencyInterface(BeanClassLoaderAware.class);
	}
}

重要属性

public class DefaultListableBeanFactory {
	// 依赖注入过程中，用于优先级比较
	private Comparator<Object> dependencyComparator;
	// 用于依赖注入过程中解决候选问题
	private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();
	// 根据类型依赖注入时，首先从这里获取依赖的属性值
	private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);
	
	// 根据构造器实例化Bean时所使用的策略（解决方法覆盖MethodOverrides问题，CglibSubclassingInstantiationStrategy使用了代理方法）
	private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();

	/************* 继承自AbstractBeanFactory ****************/
	// 用来完成SpEL功能
	private BeanExpressionResolver beanExpressionResolver;
	// 进行字符串处理，最常用的是占位符的替换
	private final List<StringValueResolver> embeddedValueResolvers = new CopyOnWriteArrayList<>();
	
	// 用于将一个类型的对象转换为另一个类型的对象，此处的typeConverter可由用户定义，在Spring中该成员优先级很高
	// 只有在该typeConverter为null的时候，才会使用SimpleTypeConverter或者BeanWrapperImpl来完成TypeConverter功能
	private TypeConverter typeConverter;
	private ConversionService conversionService;
	private final Set<PropertyEditorRegistrar> propertyEditorRegistrars = new LinkedHashSet<>(4);
	// 注意，这里value值是个PropertyEditor子类型的Class对象，因为PropertyEditor并非线程安全的，所以在使用时才实例化
	private final Map<Class<?>, Class<? extends PropertyEditor>> customEditors = new HashMap<>(4);	
}

类型转换

  PropertyEditor可以完成字符串与普通对象的相互转换，它通过setAsText(…)来设置字符串，并通过getValue()来获取转换后的对象，同样可以通过setValue(…)来设置对象，并通过getAsText()来获取转换后的字符串，由此可见PropertyEditor并非是线程安全的（自定义PropertyEditor可以直接继承其实现类PropertyEditorSupport，然后根据转换方向，只需要重写setAsText(…)或getAsText()即可）。PropertyEditorRegistry用来注册与获取PropertyEditor（相当于key是Class类型，value是PropertyEditor类型的Map，可根据希望得到的类型，找到相应的PropertyEditor），其实现类PropertyEditorRegistrySupport不但实现了PropertyEditorRegistry功能，还包含了一个ConversionService成员（下文提到）。除了可以通过PropertyEditorRegistry直接注册PropertyEditor外，还存在PropertyEditorRegistrar接口，它提供了可以批量注册PropertyEditor的方法。

/**
 * 注册PropertyEditor，将它与一个Class或者String绑定
 */
public interface PropertyEditorRegistry {
	void registerCustomEditor(Class<?> requiredType, PropertyEditor propertyEditor);
	void registerCustomEditor(Class<?> requiredType, String propertyPath, PropertyEditor propertyEditor);
	PropertyEditor findCustomEditor(Class<?> requiredType, String propertyPath);
}

public interface PropertyEditorRegistrar {
	// 该方法的实现类可以在registry中注册多个
	void registerCustomEditors(PropertyEditorRegistry registry);
}

  Converter可以将特定类型的源对象转换为另一个特定类型的目标对象。ConverterFactory是一个工厂，通过它能获取到Converter对象，但同一个工厂获取的Converter对象只能将特定类型的源对象转换为另一个特定类型或其子类型的目标对象。GenericConverter最为通用，可以将多种类型转换为另外的类型，但同一个GenericConverter到底支持哪些（源类型<->目标类型）对是明确的。ConverterRegistry接口提供了注册Converter、ConverterFactory以及GenericConverter的方法。
  ConversionService接口的功能看起来很像GenericConverter，用于将一个类型的对象转换为另一个类型的对象，但由其名便可知，这是提供的一个服务，简单的说，ConversionService对外提供API，而GenericConverter提供的是SPI来被实现。
  GenericConversionService是ConversionService的实现类，不仅如此，它还实现了ConverterRegistry接口，在注册Converter与ConverterFactory时，将其适配为GenericConverter进行注册（把Converter与ConverterFactory看作是特殊的GenericConverter），当使用ConversionService进行类型转换时，实际上就是从注册的GenericConverter中找到能够进行转换的GenericConverter来进行转换。

public interface Converter<S, T> {
	T convert(S source);
}

public interface ConverterFactory<S, R> {
	<T extends R> Converter<S, T> getConverter(Class<T> targetType);
}

public interface GenericConverter {
	// 查看当前GenericConverter所支持的（源类型\<-\>目标类型）对，一个ConvertiblePair包含一个源类型，一个目标类型
	Set<ConvertiblePair> getConvertibleTypes();
	// 转换
	Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType);
}	

public interface ConverterRegistry {
	void addConverter(Converter<?, ?> converter);
	void addConverterFactory(ConverterFactory<?, ?> factory);
	void addConverter(GenericConverter converter);
	<S, T> void addConverter(Class<S> sourceType, Class<T> targetType, Converter<? super S, ? extends T> converter);
	void removeConvertible(Class<?> sourceType, Class<?> targetType);
}

// 类型转换对外提供的统一的API
public interface ConversionService {
	boolean canConvert(@Nullable Class<?> sourceType, Class<?> targetType);
	boolean canConvert(@Nullable TypeDescriptor sourceType, TypeDescriptor targetType);
	<T> T convert(@Nullable Object source, Class<T> targetType);
	Object convert(@Nullable Object source, @Nullable TypeDescriptor sourceType, TypeDescriptor targetType);
}

  TypeConverter提供了一系列重载的convertIfNecessary(…)方法，用于将一个对象转换为指定类型的对象。通常情况下，TypeConverter负责对外提供转换接口，真正的转换是由PropertyEditor与ConversionService来完成。TypeConverterSupport是TypeConverter的一个抽象实现，它的类型转换实际上是委托TypeConverterDelegate来完成的。
  TypeConverterDelegate包含了一个PropertyEditorRegistrySupport成员（TypeConverterSupport本身就是PropertyEditorRegistrySupport的子类，当TypeConverterSupport委托TypeConverterDelegate进行转换时，自己就是TypeConverterDelegate的PropertyEditorRegistrySupport成员），它会先使用PropertyEditorRegistrySupport的PropertyEditor进行转换，如果无法转换再使用PropertyEditorRegistrySupport的ConversionService进行转换。
  在Spring中，主要使用到的TypeConverterSupport的子类有SimpleTypeConverter与BeanWrapperImpl，他们作为PropertyEditorRegistrySupport的子类，默认注册的PropertyEditor与ConversionService就是由AbstractBeanFactory的propertyEditorRegistrars、customEditors以及conversionService成员提供。
  AbstractBeanFactory提供了一个getCustomTypeConverter()方法，用于直接返回this.typeConverter，可能返回null，AbstractBeanFactory同时还提供了getTypeConverter()方法，如果this.typeConverter不为null就返回this.typeConverter，否则就new一个SimpleTypeConverter。

public abstract class AbstractBeanFactory {
	protected TypeConverter getCustomTypeConverter() {
		return this.typeConverter;
	}

	public TypeConverter getTypeConverter() {
		TypeConverter customConverter = getCustomTypeConverter();
		if (customConverter != null) {
			return customConverter;
		} else {
			// 每次获取typeConverter需要new一个新的实例是为了解决PropertyEditor的线程安全问题
			SimpleTypeConverter typeConverter = new SimpleTypeConverter();
			typeConverter.setConversionService(getConversionService());
			// 将propertyEditorRegistrars、customEditors两个成员中的Editors注册进去
			registerCustomEditors(typeConverter);
			return typeConverter;
		}
	}
}	

public interface TypeConverter {
	<T> T convertIfNecessary(Object value, Class<T> requiredType);
	<T> T convertIfNecessary(Object value, Class<T> requiredType, MethodParameter methodParam);
	<T> T convertIfNecessary(Object value, Class<T> requiredType, Field field);
	<T> T convertIfNecessary(Object value, Class<T> requiredType, TypeDescriptor typeDescriptor);

}

字符串处理

// 这是一个函数式接口，将一个字符串处理为另一个字符串
// AbstractApplicationContext的refresh()中创建了一个StringValueResolver注册到AbstractBeanFactory
// 该StringValueResolver就是直接调用getEnvironment().resolvePlaceholders(...)进行处理，实际上是属性替换${}占位符
public interface StringValueResolver {
	String resolveStringValue(String strVal);
}

public abstract class AbstractBeanFactory {
	// 注册的所有StringValueResolver对字符串进行链式处理
	public String resolveEmbeddedValue(@Nullable String value) {
		if (value == null) {
			return null;
		}
		String result = value;
		for (StringValueResolver resolver : this.embeddedValueResolvers) {
			result = resolver.resolveStringValue(result);
			if (result == null) {
				return null;
			}
		}
		return result;
	}

	protected Object evaluateBeanDefinitionString(@Nullable String value, @Nullable BeanDefinition beanDefinition) {
		if (this.beanExpressionResolver == null) {
			return value;
		}

		Scope scope = null;
		if (beanDefinition != null) {
			String scopeName = beanDefinition.getScope();
			if (scopeName != null) {
				scope = getRegisteredScope(scopeName);
			}
		}
		
		return this.beanExpressionResolver.evaluate(value, new BeanExpressionContext(this, scope));
	}
}	

// 实现了StringValueResolver接口，它调用beanFactory中注册的StringValueResolver进行字符串处理并进行SpEL处理，对外提供完整的功能
// 我们不应该将一个EmbeddedValueResolver注册到StringValueResolver，因为那样会进行循环调用
// EmbeddedValueResolverAware注入的实际上就是一个新建的EmbeddedValueResolver实例
public class EmbeddedValueResolver implements StringValueResolver {
	public EmbeddedValueResolver(ConfigurableBeanFactory beanFactory) {
		this.exprContext = new BeanExpressionContext(beanFactory, null);
		this.exprResolver = beanFactory.getBeanExpressionResolver();
	}

	public String resolveStringValue(String strVal) {
		String value = this.exprContext.getBeanFactory().resolveEmbeddedValue(strVal);
		if (this.exprResolver != null && value != null) {
			Object evaluated = this.exprResolver.evaluate(value, this.exprContext);
			value = (evaluated != null ? evaluated.toString() : null);
		}
		return value;
	}
}

类型依赖解析

  无论是BeanFactory的自动装配，还是扩展的@Autowired注解，在根据类型注入时，最终都是调用了DefaultListableBeanFactory的resolveDependency(…)方法来获取依赖属性值。而在解析过程中，DefaultListableBeanFactory的成员变量autowireCandidateResolver（AutowireCandidateResolver类型）起到了至关重要的作用，通过设置该属性的值可以改变解析的细节。

AutowireCandidateResolver

  AutowireCandidateResolver（接口定义功能）-> SimpleAutowireCandidateResolver（最基本的实现）-> GenericTypeAwareAutowireCandidateResolver（泛型匹配） -> QualifierAnnotationAutowireCandidateResolver（Qualifier筛选与@Value功能）-> ContextAnnotationAutowireCandidateResolver（@Lazy代理实现懒注入）
  SimpleAutowireCandidateResolver对AutowireCandidateResolver接口的实现方法与接口的默认方法完全相同，个人认为是因为早版本的Java接口不支持默认方法，所以SimpleAutowireCandidateResolver是接口的默认实现，后来Java支持了默认方法，就直接对AutowireCandidateResolver接口提供了默认方法。
  DependencyDescriptor用来描述需要注入的域或者方法参数（当某个方法需要注入时，如果有多个参数，那么会有多个DependencyDescriptor），自动装配时就是方法参数，@Autowired注解就看注解的位置，注解在域上时就是域，注解在方法上就是方法参数。

public interface AutowireCandidateResolver {
	// 判断一个BeanDefinition是否能够作为候选
	// 依赖注入的类型可能没有对应的BeanDefinition，而是来自于单例注册中心，那么根据单例类型构造一个BeanDefinition然后调用该方法做检查
	// 通常会贪婪地检查非候选（也就是说如果父类检查到了不是候选，那么子类就没有必要进一步检查了）
	default boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
		// 只有BeanDefinition的autowireCandidate属性为true时才能作为候选
		return bdHolder.getBeanDefinition().isAutowireCandidate();
	}

	// 需要依赖注入的属性是否是必须的，通常会贪婪地检查非必须（也就说如果父类检查到了非必须，子类就无需进行进一步检查了）
	default boolean isRequired(DependencyDescriptor descriptor) {
		// ependencyDescriptor的isRequired()会先检查它的required属性，如果为false就直接返回false了
		// 通常required属性为true，这时会进一步校验该域或参数是否Optional类型或被@Nullable修饰，如果是就非必须
		return descriptor.isRequired();
	}

	default boolean hasQualifier(DependencyDescriptor descriptor) {
		return false;
	}
	
	// 如果建议值不为null，那么不会从候选中去获取，也就是说该方法的返回值优先级高
	// 由参数可知，建议值应该根据DependencyDescriptor得到，而不应该与BeanFactory有联系，如根据@Value获取建议值
	default Object getSuggestedValue(DependencyDescriptor descriptor) {
		return null;
	}

	// 属性的懒注入，可用来解决循环依赖问题
	default Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, @Nullable String beanName) {
		return null;
	}
}

public class GenericTypeAwareAutowireCandidateResolver {
	// 如果父类都没有校验通过，那么就直接返回校验不通过，也就是说，相比父类，当前类的校验更加严格
	public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
		if (!super.isAutowireCandidate(bdHolder, descriptor)) {
			return false;
		}
		// 校验泛型是否匹配
		return checkGenericTypeMatch(bdHolder, descriptor);
	}
}	

public class QualifierAnnotationAutowireCandidateResolver {
	public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
		// 如果父类都认为不是候选了，那么就没有必要做后面的校验了
		boolean match = super.isAutowireCandidate(bdHolder, descriptor);
		if (match) {
			// 首先解释下qualifier注解，它包含多种类型的注解，可自定义添加，默认有两个（spring定义的Qualifier与java定义的Qualifier）
			// 如果存在qualifier注解且其值与BeanDefinitionHolder的Id以及别名都不同则不是候选
			match = checkQualifiers(bdHolder, descriptor.getAnnotations());
			if (match) {
				// 如果是构造器参数或返回值为void的方法参数，那么还会校验方法上的注解
				MethodParameter methodParam = descriptor.getMethodParameter();
				if (methodParam != null) {
					Method method = methodParam.getMethod();
					if (method == null || void.class == method.getReturnType()) {
						match = checkQualifiers(bdHolder, methodParam.getMethodAnnotations());
					}
				}
			}
		}
		return match;
	}

	public boolean isRequired(DependencyDescriptor descriptor) {
		if (!super.isRequired(descriptor)) {
			return false;
		}
		// 如果存在Autowired注解且其required值为false时才是非必须
		Autowired autowired = descriptor.getAnnotation(Autowired.class);
		return (autowired == null || autowired.required());
	}

	// 获取@Value的value属性的值，值不会进行任何正则或者环境变量的替换处理
	public Object getSuggestedValue(DependencyDescriptor descriptor) {
		// 获取@Value注解的值，这里是原始值，并没有进行字符串处理
		Object value = findValue(descriptor.getAnnotations());
		if (value == null) {
			// 如果获取不到方法参数的@Value注解，就获取方法上的@Value注解
			// 这说明，如果某个需要依赖注入的方法有多个参数，他们对应多个DependencyDescriptor，每个参数对应的都是同一个方法上@Value的值
			MethodParameter methodParam = descriptor.getMethodParameter();
			if (methodParam != null) {
				value = findValue(methodParam.getMethodAnnotations());
			}
		}
		return value;
	}
}

public class ContextAnnotationAutowireCandidateResolver {
	// 如果需要懒依赖，返回一个代理对象来实现懒依赖功能，否则返回null
	public Object getLazyResolutionProxyIfNecessary(DependencyDescriptor descriptor, @Nullable String beanName) {
		return (isLazy(descriptor) ? buildLazyResolutionProxy(descriptor, beanName) : null);
	}
	
	// 判断依赖注入是不是懒注入
	protected boolean isLazy(DependencyDescriptor descriptor) {
		// 获取属性或者方法参数上的@Lazy注解，如果注解存在且其值为true，那么就是懒注入
		for (Annotation ann : descriptor.getAnnotations()) {
			Lazy lazy = AnnotationUtils.getAnnotation(ann, Lazy.class);
			if (lazy != null && lazy.value()) {
				return true;
			}
		}
		
		// 如果返回值不是null，说明是参数而非属性，那么判断相应的方法或构造器上的@Lazy注解
		MethodParameter methodParam = descriptor.getMethodParameter();
		if (methodParam != null) {
			Method method = methodParam.getMethod();
			// 只有构造器或者返回值为void的方法才会检查是否是懒注入
			if (method == null || void.class == method.getReturnType()) {
				Lazy lazy = AnnotationUtils.getAnnotation(methodParam.getAnnotatedElement(), Lazy.class);
				if (lazy != null && lazy.value()) {
					return true;
				}
			}
		}
		
		return false;
	}

	// 构建懒依赖的代理对象，第一次访问代理对象时才会创建目标对象（通过doResolveDependency(...)方法）
	protected Object buildLazyResolutionProxy(final DependencyDescriptor descriptor, final @Nullable String beanName) {
		final DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) getBeanFactory();
		TargetSource ts = new TargetSource() {
			public Class<?> getTargetClass() {
				return descriptor.getDependencyType();
			}
			
			public Object getTarget() {
				Object target = beanFactory.doResolveDependency(descriptor, beanName, null, null);
				if (target == null) {
					Class<?> type = getTargetClass();
					if (Map.class == type) {
						return Collections.emptyMap();
					} else if (List.class == type) {
						return Collections.emptyList();
					} else if (Set.class == type || Collection.class == type) {
						return Collections.emptySet();
					}
					throw new NoSuchBeanDefinitionException(...);
				}
				return target;
			}
			
			...
		};
		
		// 通过ProxyFactory来构建懒依赖的代理
		ProxyFactory pf = new ProxyFactory();
		pf.setTargetSource(ts);
		Class<?> dependencyType = descriptor.getDependencyType();
		if (dependencyType.isInterface()) {
			pf.addInterface(dependencyType);
		}
		return pf.getProxy(beanFactory.getBeanClassLoader());
	}
}	

过程分析

public class DefaultListableBeanFactory {
	/**
	  * @param descriptor 表示注入点的域或方法参数
	  * @param requestingBeanName 被依赖注入的对象的beanName
	  * @param autowiredBeanNames 用于返回符合条件注入的Bean的ID
	  */
	public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
		// DependencyDescriptor通过ParameterNameDiscoverer来获取方法参数或构造器参数的参数
		descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
		if (Optional.class == descriptor.getDependencyType()) {
			// 首先会克隆一个DependencyDescriptor，并使其isRequired()方法返回false，说明可以得到null（实际上会被封装成值为null的Optional实例）
			// 直接调用了doResolveDependency(...)方法，只是获取的是泛型参数的类型，并将得到的结果封装为Optional类型（null也会封装）
			return createOptionalDependency(descriptor, requestingBeanName);
		} else if (ObjectFactory.class == descriptor.getDependencyType() || ObjectProvider.class == descriptor.getDependencyType()) {
			// ObjectProvider接口本身就继承自ObjectFactory接口，当需要注入的是这两种类型时，那么我们直接返回其实现类DependencyObjectProvider
			// 可以通过DependencyObjectProvider的getObject()或者getIfAvailable()方法来获取其泛型参数类型的依赖
			// getObject()不能返回null，getIfAvailable()可以，getIfAvailable()是在ObjectProvider中定义的，所以推荐使用功能更完善的ObjectProvider
			// 如果泛型参数类型是Optional类型，那么getObject()与getIfAvailable()直接调用createOptionalDependency(...)来获取依赖
			// 如果泛型参数类型不是Optional类型，getObject()与getIfAvailable()直接调用了doResolveDependency(...)来获取依赖
			// 这种方法注入依赖可以解决循环依赖问题，只有在需要时我们才通过getXxx()获取真正希望的依赖对象
			return new DependencyObjectProvider(descriptor, requestingBeanName);
		} else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
			// 默认javaxInjectProviderClass是javax.inject.Provider类型，其功能与ObjectFactory和ObjectProvider差不多
			// createDependencyProvider返回一个Jsr330Provider实例，它在DependencyObjectProvider的基础上实现了javax.inject.Provider接口
			// 而javax.inject.Provider的get()方法与getIfAvailable()差不多
			return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
		} else {
			// 如果是懒注入就获取懒注入的代理，否则返回null
			Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);
			if (result == null) {
				// 真正地解析依赖
				result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
			}
			return result;
		}
	}

	public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
		// DependencyDescriptor继承自InjectionPoint，表示一个依赖注入点，如域或参数
		// 这里在方法的开头将新的注入点发布并返回老的注入点，在方法的最后又设置回了老的注入点，这样在该方法的执行过程中，能够获取到当前注入点
		InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
		try {
			// 同一个DependencyDescriptor具有缓存beanName的能力，resolveShortcut(...)可以根据缓存的beanName直接获取到依赖对象
			// 没有缓存beanName时直接返回null，实际上，该方法并没有实现缓存的能力，而是直接返回null
			Object shortcut = descriptor.resolveShortcut(this);
			if (shortcut != null) {
				return shortcut;
			}

			Class<?> type = descriptor.getDependencyType();
			Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
			if (value != null) {
				// 如果获取的建议值是字符串，那么先对字符串进行字符串处理，再进行正则处理
				if (value instanceof String) {
					String strVal = resolveEmbeddedValue((String) value);
					BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
					value = evaluateBeanDefinitionString(strVal, bd);
				}
				// 将处理后的建议值转换为希望得到的类型
				TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
				return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
			}

			// 如果需要注入的是数组或集合等，那么会根据元素类型（集合是泛型参数类型）来调用findAutowireCandidates(...)获取候选作为元素
			// 数组和集合都会对元素排序，但Map不会，且Map的key是beanName，所以依赖注入Map时，Key必须是String类型，否则返回null
			// 如果需要注入的不是数组或集合等类型，或者一个候选元素都找不到，就返回null
			Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
			if (multipleBeans != null) {
				return multipleBeans;
			}

			// 找出所有的候选元素
			Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
			
			// 没有找到匹配的候选，如果被注入的属性不能为null就抛出异常，可以为null就返回null
			if (matchingBeans.isEmpty()) {
				// 直接调用了getAutowireCandidateResolver().isRequired(descriptor)
				if (isRequired(descriptor)) {
					raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
				}
				return null;
			}

			// 用来保存最终依赖注入的beanName和实例
			String autowiredBeanName;
			Object instanceCandidate;

			// 如果找到的候选元素大于1
			if (matchingBeans.size() > 1) {
				// 根据优先级决定候选
				autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
				if (autowiredBeanName == null) {
					if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
						// 如果必须有值或者不是数组集合等类型，那么交由DependencyDescriptor处理，DependencyDescriptor默认抛出异常
						return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
					} else {
						return null;
					}
				}
				instanceCandidate = matchingBeans.get(autowiredBeanName);
			} else {
				// 只有一个候选时直接使用
				Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
				autowiredBeanName = entry.getKey();
				instanceCandidate = entry.getValue();
			}

			// 回写数据，提供给当前函数的调用者
			if (autowiredBeanNames != null) {
				autowiredBeanNames.add(autowiredBeanName);
			}
			
			// 如果得到的候选时Class类型，那么需要进一步处理，默认直接根据beanName获取Bean
			if (instanceCandidate instanceof Class) {
				instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
			}

			// 如果实际依赖是NullBean类型，但要求必须有依赖注入，这时会抛出异常
			Object result = instanceCandidate;
			if (result instanceof NullBean) {
				if (isRequired(descriptor)) {
					raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
				}
				result = null;
			}
			
			// 如果得到的注入对象不符合希望注入的类型，那么抛出异常
			if (!ClassUtils.isAssignableValue(type, result)) {
				throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
			}
			
			return result;
		} finally {
			ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
		}
	}
	
	protected Map<String, Object> findAutowireCandidates(String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {
		Map<String, Object> result = new LinkedHashMap<>(candidateNames.length);
		
		// resolvableDependencies中注册了不同类型对应与哪些实例，如果希望得到的类型是注册类型的父类，那么注册的实例便可以成为候选
		// 最多只会从resolvableDependencies选出一个候选，而且回写到result中的key不是beanName
		for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
			Class<?> autowiringType = classObjectEntry.getKey();
			if (autowiringType.isAssignableFrom(requiredType)) {
				Object autowiringValue = classObjectEntry.getValue();
				// 如果autowiringValue是ObjectFactory类型且我们希望得到不是autowiringValue父类
				// 那么最终的注入值就是autowiringValue.getObject()
				autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
				if (requiredType.isInstance(autowiringValue)) {
					result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
					break;
				}
			}
		}
		
		// 从工厂中获取所有符合类型匹配的beanName（包括BeanDefinition与单例）
		String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this, requiredType, true, descriptor.isEager());
		for (String candidate : candidateNames) {
			// 只保留不是自引用和AutowireCandidateResolver.isAutowireCandidate(...)的结果
			if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
				// 根据候选beanName获取到Bean
				addCandidateEntry(result, candidate, descriptor, requiredType);
			}
		}
		
		// 如果候选是空的，那么放松筛选条件继续寻找候选
		if (result.isEmpty()) {
			// 希望得到的类型是否是数组、集合等类型，如果是数组或者集合等类型，后面其实是不会处理继续处理了
			boolean multiple = indicatesMultipleBeans(requiredType);
			
			// 得到新的DependencyDescriptor，与原DependencyDescriptor相比，只是在泛型依赖的时候放松了泛型检查
			DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
			
			// 不放松自引用，放松泛型检查
			for (String candidate : candidateNames) {
				if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor) &&
						(!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) {
					addCandidateEntry(result, candidate, descriptor, requiredType);
				}
			}
			
			// 如果依然为空，那么不但放松泛型检查，还要放松自引用的限制
			if (result.isEmpty() && !multiple) {
				for (String candidate : candidateNames) {
					if (isSelfReference(beanName, candidate) &&
							(!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&
							isAutowireCandidate(candidate, fallbackDescriptor)) {
						addCandidateEntry(result, candidate, descriptor, requiredType);
					}
				}
			}
		}
		
		return result;
	}

	protected String determineAutowireCandidate(Map<String, Object> candidates, DependencyDescriptor descriptor) {
		Class<?> requiredType = descriptor.getDependencyType();
		// 筛选BeanDefinition.primary为true的候选，如果有多个则抛出异常
		String primaryCandidate = determinePrimaryCandidate(candidates, requiredType);
		if (primaryCandidate != null) {
			return primaryCandidator;
		}
		
		// 根据dependencyCompare筛选出priority最高的候选，如果最高优先级的候选不止一个，抛出异常
		String priorityCandidate = determineHighestPriorityCandidate(candidates, requiredType);
		if (priorityCandidate != null) {
			return priorityCandidate;
		}
		
		// 如果primary与priority依然无法做出决策，那么根据注入点的成员或参数名，来进行按名匹配（也有可能按名也匹配不上）
		for (Map.Entry<String, Object> entry : candidates.entrySet()) {
			String candidateName = entry.getKey();
			Object beanInstance = entry.getValue();
			if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) ||
					matchesBeanName(candidateName, descriptor.getDependencyName())) {
				return candidateName;
			}
		}
		
		return null;
	}
}	

获取bean实例

核心方法

基本框架

  无论以何种方式从BeanFactory获取bean实例，最终都会通过AbstractBeanFactory.doGetBean(…)来获取。

public abstract class AbstractBeanFactory {
	protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly) {
		// 未经过类型转换的Bean引用
		Object bean;
		
		// 无论有多少个连续的&前缀，统统去掉，然后将name（可能是别名或者已经是ID）转换为ID
		final String beanName = transformedBeanName(name);
	
		// 根据ID获取已注册的单例对象（对于FactoryBean，得到的单例对象是FactoryBean对象本身）
		Object sharedInstance = getSingleton(beanName);		
		if (sharedInstance != null && args == null) { // 存在已注册的单例对象，无须再创建单例对象
			// 该方法用于解决FactoryBean问题，调用了父类实现的AbstractBeanFactory.getObjectForBeanInstance(...)方法
			// AbstractBeanFactory.getObjectForBeanInstance(...)方法后面有详解
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		} else { // 不存在已经实例化的单例
			// 如果原型Bean存在循环依赖，直接抛出异常
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}
	
			// 如果当前容器无法创建指定ID的Bean（未注册指定ID的BeanDefinition），且存在父容器，则委托父容器处理
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				String nameToLookup = originalBeanName(name); // 得到标准的ID或&ID形式（如果name前无&则获得ID，否则为&ID）
				if (parentBeanFactory instanceof AbstractBeanFactory) {
					return ((AbstractBeanFactory) parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
				} else if (args != null) {
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				} else if (requiredType != null) {
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				} else {
					return (T) parentBeanFactory.getBean(nameToLookup);
				}
			}

			// 根据ID获取到已合并的BeanDefinition
			// getMergedBeanDefinition(...)会根据继承关系，将指定beanName的BeanDefinition与其祖先（BeanDefinition的parent属性）BeanDefinition合并成一个等效的新BeanDefinition并缓存
			// getMergedLocalBeanDefinition(beanName)会先在缓存中找beanName对应的已经合成的BeanDefinition，如果未命中则调用getMergedBeanDefinition(...)
			// 实际上是先克隆一个parent的BeanDefinition，然后用当前BeanDefinition的非null属性去覆盖（对于集合属性是进行合并而非覆盖）
			final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);	
			// 如果mbd.abstractFlag为true会抛出异常，可见标记为abstractFlag的BeanDefinition无法创建对象，只能作为其他BeanDefinition的parent
			checkMergedBeanDefinition(mbd, beanName, args); 

			// 如果当前Bean依赖于其他Bean，则先创建其他Bean
			String[] dependsOn = mbd.getDependsOn();
			if (dependsOn != null) {
				for (String dep: dependsOn) {
					// 解决循环依赖
					if (isDependent(beanName, dep)) {
						throw new BeanCreationException(...);
					}
					registerDependentBean(dep, beanName);
				
					getBean(dep); 
				}
			}
		
			// 根据生命周期决定从缓存中取还是创建新的bean，各种生命周期的缓存方式不一样，但创建对象都是通过createBean(...)方法
			if (mbd.isSingleton()) { // 单例模式
				// 如果缓存中有ID为beanName的单例则直接返回，否则创建一个单例返回，并将单例缓存
				// getSingleton(...)的第二个参数为函数式接口ObjectFactory，供getSingleton(...)回调创建Bean，这里Lambda表达式代表了一个匿名内部类
				// 在创建bean前后分别调用了beforeSingletonCreation(beanName)与afterSingletonCreation(beanName)来标记当前bean正在创建以及创建完成
				sharedInstance = getSingleton(beanName, () -> {
						return createBean(beanName, mbd, args);
				});
				bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
			} else if (mbd.isPrototype()) {  // 原型模式
				// 创建出的Bean将不再由容器进行管理
				beforePrototypeCreation(beanName); // 标记当前bean正在被创建
				Object prototypeInstance = createBean(beanName, mbd, args);	
				afterPrototypeCreation(beanName); // 标记当前bean已经创建完成				
				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 + "'");
				}
			
				// 如果在生命周期内就直接返回，否则创建并缓存，缓存方案由Scope定义时实现
				Object scopedInstance = scope.get(beanName, () -> {
						return createBean(beanName, mbd, args);
				});
				bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
			}
		}

		// 如果加载的bean不是目标类型及其子类对象，尝试将bean转换为目标类型返回
		if (requiredType != null && !requiredType.isInstance(bean)) {
			T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
			if (convertedBean == null) {
				throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
			}
			return convertedBean;
		}
	
		// 如果加载的bean刚好是目标类型及其子类对象，直接强转后返回
		return (T) bean;
	}
}

创建Bean

public abstract class AbstractAutowireCapableBeanFactory {
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		RootBeanDefinition mbdToUse = mbd;
		
		// 将BeanDefinition的beanClass转换为Class对象，beanClass可能是String形式的全类名，也可能是Class对象
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass); // 保存为Class类型，避免下次继续将String转换为Class带来性能开销
		}

		// 检查方法覆盖是否合法（指定的类是否存在覆盖方法）
		mbdToUse.prepareMethodOverrides();

		// 实例化前处理，创建对象并进行初始化后处理得到的就是最终Bean
		// 先依次调用注册的InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(...)方法
		// 当某一次返回Bean不为null时，就停止继续调用，并对该bean进行初始化后处理
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
	
		return doCreateBean(beanName, mbdToUse, args);
	}

	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) {
		// 实例化
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			// 创建Bean实例
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// PostProcessor扩展接口，对MergedBeanDefinition进行处理，并确保每个MergedBeanDefinition最多只会进行一次处理
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				mbd.postProcessed = true;
			}
		}

		// 通过工厂方式提前发布单例Bean
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			// getEarlyBeanReference(...)会调用所有的SmartInstantiationAwareBeanPostProcessor.etEarlyBeanReference(...)
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}
		
		// 属性注入
		populateBean(beanName, mbd, instanceWrapper);
		
		// 初始化
		Object exposedObject = initializeBean(beanName, exposedObject, mbd);

		// 循环依赖与Bean代理处理
		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(...);
					}
				}
			}
		}

		// 注册销毁适配器，如果该Bean存在着销毁处理，那么该Bean就会进行销毁适配器的注册
		registerDisposableBeanIfNecessary(beanName, bean, mbd);

		return exposedObject;
	}
}

实例化

public abstract class AbstractAutowireCapableBeanFactory {	
	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
		Class<?> beanClass = resolveBeanClass(mbd, beanName);
		// 如果当前类不是由public修饰的，并且不允许非public类，直接抛出异常
		if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
			throw new BeanCreationException(...);
		}

		// 如果BeanDefinition的instanceSupplier成员不为null，那么通过instanceSupplier的get()方法创建实例
		Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
		if (instanceSupplier != null) {
			return obtainFromSupplier(instanceSupplier, beanName);
		}

		// 当mbd的factoryMethodName不为null时
		// 如果mbd的factoryBeanName不为null，根据factoryBeanName获取Bean工厂实例并调用其factoryMethodName方法创建目标实例
		// 否则mbd的beanClassName不为null时，调用beanClassName代表的类的factoryMethodName静态方法创建目标实例
		if (mbd.getFactoryMethodName() != null) {
			// 该方法与autowireConstructor(...)的实现思路基本相同（调用了ConstructorResolver.instantiateUsingFactoryMethod）
			return instantiateUsingFactoryMethod(beanName, mbd, args);
		}

		// 下面通过构造器实例化Bean

		// 当args（BeanFactory.getBean(...)的参数列表）为空时（实际使用过程中，几乎不会传入args参数）
		// 会根据BeanDefinition等解析出真正的构造函数及构造函数参数，由于解析过程耗时，所以在mbd中进行了缓存
		// 在args不为空时，会根据args的个数与类型解析得到构造函数（构造函数参数就是args），不会进行缓存
		// 不进行缓存是因为不同的args可能会对应多种构造器，除非mbd提供一个Map成员来根据参数类型保留相应的构造器
		boolean resolved = false;
		boolean autowireNecessary = false;
		if (args == null) {
			synchronized (mbd.constructorArgumentLock) {
				// mbd.resolvedConstructorOrFactoryMethod用于缓存构造器或者工厂方法
				// mbd.constructorArgumentsResolved用于表明参数构造器或者工厂方法的参数是否已经解析
				if (mbd.resolvedConstructorOrFactoryMethod != null) {
					resolved = true;
					autowireNecessary = mbd.constructorArgumentsResolved;
				}
			}
		}
		if (resolved) {
			if (autowireNecessary) {
				// 实际上调用了ConstructorResolver.autowireConstructor(...)
				return autowireConstructor(beanName, mbd, null, null);
			} else {
				// 直接采用策略模式调用了getInstantiationStrategy().instantiate(...)
				return instantiateBean(beanName, mbd);
			}
		}

		// 上面构造器实例化Bean都是通过缓存来进行以提升性能，如果忽略缓存，下面才是真正的实例化过程
		
		// 从构造器中筛选出候选构造器，这里提供了扩展
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// 这是spring5.1新加的代码，RootBeanDefinition的getPreferredConstructors()直接返回的null，所以这段代码目前无意义，应该是以后Spring新版本的扩展点
		ctors = mbd.getPreferredConstructors();
		if (ctors != null) {
			return autowireConstructor(beanName, mbd, ctors, null);
		}

		return instantiateBean(beanName, mbd);
	}
}

class ConstructorResolver {
	public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
		// Bean的封装类，当前只创建并初始化了封装类对象，在实例化Bean后再将其装进去
		BeanWrapperImpl bw = new BeanWrapperImpl();
		// 与SimpleTypeConverter类似的方式封装typeConvertor与propertyEditorRegistry
		this.beanFactory.initBeanWrapper(bw);
		
		... 从候选构造器中找出最合适的构造器与参数，实例化构造器参数的过程可能会发生构造器注入依赖 ...
		... 1. 如果没有传入候选构造器，那么就以mbd.getBeanClass(...)类的所有构造器作为候选构造器 ...
		... 2. 如果没有传入explicitArgs，那么就以BeanDefinition.constructorArgumentValues为构造参数 ...
		... 3. 根据构造参数从候选构造参数中决策出一个最终的构造器 ...
		... 如果explicitArgs为空且只有一个无参构造函数，那么无视BeanDefinition.constructorArgumentValues使用无参构造函数 ...
		... explicitArgs为空时会将构造函数及其使用的构造参数缓存在mbd中 ...

		// 通过策略模式调用this.beanFactory.getInstantiationStrategy().instantiate(...)创建Bean
		bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
		return bw;
	}

	// 通过工厂方法实例化，与autowireConstructor(...)思路差不多（一个是构造方法，一个是普通方法），不再详解
	public BeanWrapper instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
	...
	}
}

/**
  * 策略模式接口InstantiationStrategy定义了三个instantiate(...)重载方法，分别用于根据默认构造函数、有参构造函数以及工厂方法创建实例
  * SimpleInstantiationStrategy实现了InstantiationStrategy接口，当存在MethodOverrides时，无法处理，只得抛出异常
  * CglibSubclassingInstantiationStrategy继承SimpleInstantiationStrategy，通过使用CGLIB代理的方式来解决MethodOverrides问题
  */
public class CglibSubclassingInstantiationStrategy extends SimpleInstantiationStrategy {
	// 该方法是由SimpleInstantiationStrategy实现的InstantiationStrategy的接口，用来根据构造函数及其参数创建实例
	public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner, final Constructor<?> ctor, Object... args) {
		if (!bd.hasMethodOverrides()) {
			// 当不存在方法覆盖的时候，直接通过构造函数创建实例
			return BeanUtils.instantiateClass(ctor, args);
		} else {
			// 存在方法覆盖时，SimpleInstantiationStrategy无法解决此问题，因此SimpleInstantiationStrategy.instantiateWithMethodInjection(...)直接抛出了异常
			// 而CglibSubclassingInstantiationStrategy重写了该方法，它通过CGLIB代理的方式来解决方法覆盖问题
			return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
		}
	}
	
	// 该方法是由SimpleInstantiationStrategy实现的InstantiationStrategy的接口，用来根据默认构造函数创建实例
	public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
		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");
					}
					// 获取默认构造函数
					constructorToUse = clazz.getDeclaredConstructor();
					bd.resolvedConstructorOrFactoryMethod = constructorToUse;
				}
			}
			return BeanUtils.instantiateClass(constructorToUse);
		} else {
			// 存在方法覆盖时，SimpleInstantiationStrategy无法解决此问题，因此SimpleInstantiationStrategy.instantiateWithMethodInjection(...)直接抛出了异常
			// 而CglibSubclassingInstantiationStrategy重写了该方法，它通过CGLIB代理的方式来解决方法覆盖问题
			return instantiateWithMethodInjection(bd, beanName, owner);
		}
	}

	// 该方法是由SimpleInstantiationStrategy实现的InstantiationStrategy的接口，用来根据工厂方法创建实例
	public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
			@Nullable Object factoryBean, final Method factoryMethod, Object... args) {
		// 直接调用工厂方法
		ReflectionUtils.makeAccessible(factoryMethod);
		return factoryMethod.invoke(factoryBean, args);
	}

	// 该方法由SimpleInstantiationStrategy定义，用来解决创建具有方法覆盖的实例
	// SimpleInstantiationStrategy虽然定义了该方法，自己却不知道如何解决方法覆盖问题，所以直接抛出了异常，希望由子类去实现解决方案
	// CglibSubclassingInstantiationStrategy重写了该方法，它通过CGLIB代理的方式来实现方法覆盖
	protected Object instantiateWithMethodInjection(...) {
		... 由于本座对CGLIB也不太熟悉，故不多做介绍，猜测构建的代理对象应该具有如下特征 ...
		... 当通过代理对象调用未被覆盖的方法时，直接调用了被代理对象的相应方法 ...
		... 当通过代理对象调用被覆盖的方法时，调用了用来覆盖的相应方法 ...
	}
}

属性注入

public abstract class AbstractAutowireCapableBeanFactory {		
	// 属性注入
	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		// 如果前面实例化得到的对象是null，如果还有属性需要注入，那么抛异常（不应该往null中注入属性），无属性需要注入就不注入
		if (bw == null) {
			if (mbd.hasPropertyValues()) {
				throw new BeanCreationException(...);
			} else {
				return;
			}
		}

		// 实例化后处理
		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);

		// 自动注入，将需要自动注入的成员变量放入pvs中
		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;
		}

		// 可以通过InstantiationAwareBeanPostProcessor扩展来修改pvs
		PropertyDescriptor[] filteredPds = null;
		if (hasInstantiationAwareBeanPostProcessors()) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
					if (pvsToUse == null) {
						if (filteredPds == null) {
							filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
						}
						pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvsToUse == null) {
							return;
						}
					}
					pvs = pvsToUse;
				}
			}
		}

		// 检查依赖注入属性的完整性，AbstractBeanDefinition默认值为DEPENDENCY_CHECK_NONE，不需要依赖注入检查
		if (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE) {
			if (filteredPds == null) {
				// 去除Bean中没有set方法的属性，去除Bean中被ignoredDependencyTypes忽略的属性，剩下的属性就是返回值
				filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			}

			// filteredPds中具有set方法的某些属性中，符合配置的某些属性是否都在pvs中了，如果不在那么依赖注入检查失败，会抛出异常
			// AbstractBeanDefinition.DEPENDENCY_CHECK_ALL检查所有属性
			// AbstractBeanDefinition.DEPENDENCY_CHECK_SIMPLE检查所有的简单类型及其数组类型属性
			// AbstractBeanDefinition.DEPENDENCY_CHECK_OBJECTS检查所有简单类型及其数组类型以外类型的属性
			// 简单类包含int等基本类以及其封装类型，还有Date、Class、URL等
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}

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

	// 根据属性名自动注入（将属性名与其值放入pvs中）
	protected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
		// 从Bean中决定可以自动注入的属性
		// 属性必须满足：具有set方法，不存在pvs中（自动注入的优先级低），不是简单类型或其数组，未被ignoredDependencyTypes排除
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		for (String propertyName : propertyNames) {
			// 如果Spring可以根据该属性名获取到Bean，那么该属性会自动注入
			if (containsBean(propertyName)) {
				Object bean = getBean(propertyName);
				pvs.add(propertyName, bean);
				registerDependentBean(propertyName, beanName);
			}
		}
	}

	// 根据属性类型自动注入（将属性名与其值放入pvs中）
	protected void autowireByType(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
		TypeConverter converter = getCustomTypeConverter();
		if (converter == null) {
			converter = bw;
		}

		// 用于缓存依赖Bean的容器
		Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
		// 从Bean中决定可以自动注入的属性
		String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
		for (String propertyName : propertyNames) {
			PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
			// Object类型的属性会忽略
			if (Object.class != pd.getPropertyType()) {
				MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
				boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
				//字段相关的信息包装类
				DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
				// 解析需要注入的值，本次解析中依赖的Bean的ID将被放置在autowiredBeanNames中
				Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
				if (autowiredArgument != null) {
					pvs.add(propertyName, autowiredArgument);
				}

				// 注册依赖关系供dependsOn依赖检查
				for (String autowiredBeanName : autowiredBeanNames) {
					registerDependentBean(autowiredBeanName, beanName);
				}
				autowiredBeanNames.clear();
			}
		}
	}
	
	// 解析pvs并进行真正的属性注入
	protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
		// pvs为空则不需要注入
		if (pvs.isEmpty()) {
			return;
		}

		// MutablePropertyValues与List<PropertyValue>都是PropertyValue的集合，但MutablePropertyValues可以标记是否已经转换过
		// 将PropertyValue的各种集合形式统一转换为List格式以便统一处理，而mpvs是否有值可以判断pvs是否是MutablePropertyValues类型
		MutablePropertyValues mpvs = null;
		List<PropertyValue> original;
		if (pvs instanceof MutablePropertyValues) {
			mpvs = (MutablePropertyValues) pvs;
			// 如果转换过不需要再浪费性能来转换，直接进行属性注入
			if (mpvs.isConverted()) {
				bw.setPropertyValues(mpvs);
				return;
			}
			original = mpvs.getPropertyValueList();
		} else {
			original = Arrays.asList(pvs.getPropertyValues());
		}

		// 作为TypeConverter，beanFactory的typeConverter成员的优先级高于BeanWrapper
		TypeConverter converter = getCustomTypeConverter();
		if (converter == null) {
			converter = bw;
		}
		// 主要用于对xml解析成的各类属性值（如TypeStringValued、RuntimeBeanReference等）进行处理
		BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

		// 用于保存所有处理后的PropertyValue
		List<PropertyValue> deepCopy = new ArrayList<>(original.size());
		for (PropertyValue pv : original) {
			// 如果当前pv已经处理过，无需继续处理
			if (pv.isConverted()) {
				deepCopy.add(pv);
			} else {
				String propertyName = pv.getName();
				Object originalValue = pv.getValue();
				// 用于将各类属性值转换为对象（如RuntimeBeanReference转换为Bean、TypeStringValued进行正则处理等）
				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);
				}
				
				deepCopy.add(new PropertyValue(pv, convertedValue));
			}
		}

		// 如果pvs是MutablePropertyValues类型，设置为已转换
		if (mpvs != null && !resolveNecessary) {
			mpvs.setConverted();
		}

		// 调用set方法真正的注入属性
		bw.setPropertyValues(new MutablePropertyValues(deepCopy));
	}
}

初始化

public abstract class AbstractAutowireCapableBeanFactory {	
	protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		// 如果当前Bean继承自BeanNameAware、BeanClassLoaderAware或BeanFactoryAware，会调用其接口方法
		invokeAwareMethods(beanName, bean);

		Object wrappedBean = bean;

		// 初始化前处理
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		// 调用初始化方法
		// 如果当前Bean是InitializingBean的实例，那么调用其实现InitializingBean的afterPropertiesSet()接口
		// 然后调用当前Bean中，名为BeanDefinition.initMethodName的方法（如果该方法名为afterPropertiesSet就不用重复调用了）
		invokeInitMethods(beanName, wrappedBean, mbd);
		
		// 初始化后处理
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}
}

销毁适配器注册

public abstract class AbstractAutowireCapableBeanFactory {		
	// 对象销毁时回调函数的注册
	protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
		if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
			if (mbd.isSingleton()) {
				// Bean工厂有一个Map用于保存各个单例Bean的销毁对象DisposableBeanAdapter（一个单例对象对应一个DisposableBeanAdapter）
				// 销毁对象DisposableBeanAdapter的destroy()会依次调用如下方法
				// 1、所有DestructionAwareBeanPostProcessor.postProcessBeforeDestruction(...)
				// 2、如果当前Bean继承自DisposableBean，那么调用其destroy()方法
				// 3、调用BeanDefinition.destroyMethodName所代表的方法
				// 在调用BeanFatroy.destroySingleton(...)销毁对象时，回调注册DisposableBeanAdapter的destroy()方法
				registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
			} else {
				Scope scope = this.scopes.get(mbd.getScope());
				if (scope == null) {
					throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
				}
				
				// 在Scope周期下注册Bean的销毁对象
				// 自定义Scope重写registerDestructionCallback方法时，一般可以在Scope表示的生命周期内定义一个Map用于保存该周期内Bean的DisposableBeanAdapter
				// 并非在Scope中定义Map，如请求生命周期应该在一个请求实例中添加一个Map来注册该请求生命周期的各个Bean的DisposableBeanAdapter
				// 在生命周期结束时，应该想办法回调注册的DisposableBeanAdapter，如请求销毁时、线程结束时
				scope.registerDestructionCallback(beanName,
						new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
			}
		}
	}
}

FactoryBean处理

public class AbstractBeanFactory {
	/**
      * 用于处理FactoryBean问题
      * name不以&开头说明不想获取FactoryBean对象本身，beanInstance是FactoryBean则返回beanInstance创建的对象，不是则返回beanInstance本身
      * 如果name以&开头说明想获取的就是FactoryBean对象本身，如果beanInstance是FactoryBean则返回beanInstance，不是则抛出异常
      */
	protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {			
		// 想获得FactoryBean本身时，如果当前beanInstance是FactoryBean类型，直接返回实例，否则抛出异常
		if (BeanFactoryUtils.isFactoryDereference(name)) { // 判断name是否以&开头
			if (beanInstance instanceof NullBean) {
				return beanInstance;
			}
			if (!(beanInstance instanceof FactoryBean)) {
				throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
			}
			if (mbd != null) {
				mbd.isFactoryBean = true;
			}
			return beanInstance;
		}

		// 此后内容并非是希望获取FactoryBean本身，而是希望通过FactoryBean创建对象
		
		// 如果当前beanInstance不是FactoryBean类型，直接返回beanInstance实例
		if (!(beanInstance instanceof FactoryBean)) {
			return beanInstance;
		}

		// 如果当前beanInstance是FactoryBean类型，通过FactoryBean获取最终Bean
		Object object = null;
		if (mbd != null) {
			mbd.isFactoryBean = true;
		} else {
			// 只会从FactoryBean框架的缓存取，只有FactoryBean本身是单例且其isSingleton()方法返回true时才会把创建的对象缓存
			// 如果此处能够取得最终Bean，那就说明FactoryBean本身是单例且其isSingleton()方法返回true且最终Bean已经创建并缓存
			object = getCachedObjectForFactoryBean(beanName);
		}
		
		if (object == null) {
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			if (mbd == null && containsBeanDefinition(beanName)) {
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			boolean synthetic = (mbd != null && mbd.isSynthetic()); 
			// 创建最终Bean并决定是否缓存，调用FactoryBeanRegistrySupport.getObjectFromFactoryBean(...)
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		
		return object;
	}
}

public abstract class FactoryBeanRegistrySupport {
	/**
	  * 通过FactoryBean获取Bean
	  * @param factory 如何创建Bean
	  * @param beanName
	  * @param shouldPostProcess 在完成创建之后是否执行初始化后处理
	  */
	protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
		// 只有FactoryBaen的isSingleton()方法返回true，并且FactoryBean本身也是单例的时候，才会从缓存获取FactoryBean生成的Bean
		// 否则直接调用factory.getObject()获取对象
		if (factory.isSingleton() && containsSingleton(beanName)) {
			synchronized (getSingletonMutex()) {
				// 从缓存获取Bean，如果不存在缓存，则通过FactoryBean的getObject()方法得到Bean并缓存
				Object object = this.factoryBeanObjectCache.get(beanName);
				if (object == null) {
					object = doGetObjectFromFactoryBean(factory, beanName); // 直接通过factory.getObject()获取对象
					Object alreadyThere = this.factoryBeanObjectCache.get(beanName); 
					if (alreadyThere != null) {
						object = alreadyThere;
					} else {
						if (shouldPostProcess) {
							// 解决循环依赖，将beanName加入正在创建的单例中
							beforeSingletonCreation(beanName);
							// 此方法是由FactoryBeanRegistry提供的在获取到bean之后进一步对bean进行处理的扩展接口
							// 实际上该方法直接调用了初始化后处理，所以FactoryBean本身会进行初始化后处理，其生产出Bean之后，Bean也会进行初始化后处理
							object = postProcessObjectFromFactoryBean(object, beanName);
							afterSingletonCreation(beanName);
						}
						
						// 进行缓存
						if (containsSingleton(beanName)) {
							this.factoryBeanObjectCache.put(beanName, object);
						}
					}
				}				
				return object;
			}
		} else {
			Object object = doGetObjectFromFactoryBean(factory, beanName);
			if (shouldPostProcess) {
				object = postProcessObjectFromFactoryBean(object, beanName);
			}			
			return object;
		}
	}
}	

封装方法

  容器并没有将核心方法doGetBean(…)提供给容器使用者，而是对外提供了封装接口getBean(…)来获取Bean实例。带有name属性的getBean(…)方法直接调用了doGetBean(…)方法，而不带name属性的getBean(…)方法，先会通过类型获取相应的name，然后再调用doGetBean(…)方法来获取Bean实例。

public class DefaultListableBeanFactory {
	/**
	  * 对外提供的根据类型获取Bean的方法
	  */
	public <T> T getBean(Class<T> requiredType, @Nullable Object... args) throws BeansException {
		// jre中的Class类的isAssignableFrom(Class<?> other)返回当前类是否是other的超类型或同一个类型，与运算符instanceof效果相同（当然instanceof使用方法是 对象 instanceof 类名）
		// spring中的ClassUtils类的isAssignable(Class<?> lhsType, Class<?> rhsType)返回lhsType是否是rhsType的超类或同一个类型或一个基本类型一个封装类型（如int与Integer）
		// 创建一个ResolvableType对象来封装Class对象，后面可以利用ResolvableType的isAssignableFrom(Class<?> other)（直接调用了ClassUtils.isAssignable(...)）来判断继承关系
		// resolveBean(...)方法真正实现了根据类型获取Bean，下面有解析
		Object resolved = resolveBean(ResolvableType.forRawClass(requiredType), args, false);
		
		// 必须要找到满足指定类型的Bean，否则会抛出异常
		if (resolved == null) {
			throw new NoSuchBeanDefinitionException(requiredType);
		}
		
		return (T) resolved;
	}

	/**
	  * 在获取Bean的过程中加入了父容器机制，只有在当前容器找不到符合指定类型的Bean时才会在父容器寻找
	  * 在当前容器和父容器都具有某个类型的bean时，并不会将全部bean拿出来做选择，只会把当前容器的bean拿出来做选择
	  */
	private <T> T resolveBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) {
		// resolveNamedBean(...)方法真正实现了根据类型获取Bean，下面有解析
		NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args, nonUniqueAsNull);
		if (namedBean != null) {
			return namedBean.getBeanInstance();
		}
		
		// 从当前容器无法获取到指定类型的Bean，则委托其父容器处理，如果没有父容器则返回null
		// 因为使用的基本都是DefaultListableBeanFactory容器，所以这是一个递归调用
		BeanFactory parent = getParentBeanFactory();
		if (parent instanceof DefaultListableBeanFactory) {
			return ((DefaultListableBeanFactory) parent).resolveBean(requiredType, args, nonUniqueAsNull);
		} else if (parent != null) {
			ObjectProvider<T> parentProvider = parent.getBeanProvider(requiredType);
			if (args != null) {
				return parentProvider.getObject(args);
			} else {
				return (nonUniqueAsNull ? parentProvider.getIfUnique() : parentProvider.getIfAvailable());
			}
		}		
		
		return null;
	}

	/**
	  * 对多个候选name进行挑选并得到最后的Bean
	  */
	private <T> NamedBeanHolder<T> resolveNamedBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) {
		// 根据类型从当前容器获取匹配类型的Bean的name（包括beanDefinition的name以及手动注册的单例name）作为候选name
		// 对于FactoryBean类型的BeanDefinition或单例，如果其getObjectType(...)满足type则返回name，如果FactoryBean本身满足类型匹配则返回&name
		// 判断类型匹配主要由spring中的ClassUtils类的isAssignable(Class<?> lhsType, Class<?> rhsType)完成
		String[] candidateNames = getBeanNamesForType(requiredType);

		// 如果候选name大于1，先剔除所有非AutowireCandidate的BeanDefinition（保留AutowireCandidate的BeanDefinition以及手动注册的单例name）
		// 如果剔除后候选name没有了，那就一个也不剔除，保持原来的候选name
		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);
			}
		}
		
		// 如果候选name只有一个了，那么就根据该name来获取Bean
		// 如果依然有多个候选name，那么就根据BeanDefinition的primary属性以及@Priority注解来做决策
		if (candidateNames.length == 1) {
			String beanName = candidateNames[0];
			return new NamedBeanHolder<>(beanName, (T) getBean(beanName, requiredType.toClass(), args));
		} else if (candidateNames.length > 1) { 
			// candidates保存name-单例对以及name-类型对象
			Map<String, Object> candidates = new LinkedHashMap<>(candidateNames.length);
			for (String beanName : candidateNames) {
				if (containsSingleton(beanName) && args == null) {
					Object beanInstance = getBean(beanName);
					candidates.put(beanName, (beanInstance instanceof NullBean ? null : beanInstance));
				} else {
					candidates.put(beanName, getType(beanName));
				}
			}

			// 从候选name中筛选出primary的候选name（BeanDefinition的primary属性为true），如果有多个primary的候选会抛异常
			String candidateName = determinePrimaryCandidate(candidates, requiredType.toClass());
			// 不存在primary的候选name时，选取priority值最大的候选，如果有多个最大值会抛异常
			if (candidateName == null) {
				// 根据beanFactory的dependencyComparator属性的来判断BeanDefinition的priority值
				// 默认情况dependencyComparator的值为null，所以无法判断priority的值
				// 当引入注解后，该值实际上是一个AnnotationAwareOrderComparator对象，它通过@Priority注解来判断priority值
				candidateName = determineHighestPriorityCandidate(candidates, requiredType.toClass());
			}

			// 如果找到唯一候选，获取其Bean
			if (candidateName != null) {
				Object beanInstance = candidates.get(candidateName);
				if (beanInstance == null || beanInstance instanceof Class) {
					beanInstance = getBean(candidateName, requiredType.toClass(), args);
				}
				return new NamedBeanHolder<>(candidateName, (T) beanInstance);
			}
			
			// 没有找到唯一匹配的Bean
			if (!nonUniqueAsNull) {
				throw new NoUniqueBeanDefinitionException(requiredType, candidates.keySet());
			}
		}

		// 未找到匹配的Bean
		return null;
	}
}	

循环依赖

DependsOn依赖

  DependsOn依赖发生在创建实例之前，它要求在创建某个Bean之前，必须先创建它depensOn的Beans，如果depensOn出现循环依赖，那么将无法实现这一目标（由于发生在创建实例之前，故无法提前发布Bean），故而DependsOn不允许出现循环依赖。

public abstract class AbstractBeanFactory {
	protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly) {
		... 
		
		String[] dependsOn = mbd.getDependsOn();
		if (dependsOn != null) {
			for (String dep: dependsOn) {
				// 循环依赖直接报错，根据dependentBeanMap中是否存在beanName与dep键值对来判断是否存在循环依赖
				if (isDependent(beanName, dep)) {
					throw new BeanCreationException(...);
				}
				// 将dep与beanName以键值对的方式放在dependentBeanMap中
				// 在依赖注入过程中也会进行依赖注册，所以如果某个Bean依赖注入过程中也依赖于当前Bean，那么这也是DependsOn循环依赖
				registerDependentBean(dep, beanName); 
			
				getBean(dep); 
			}
		}
		
		... 创建Bean对象 ...
	}	
}

  dependentBeanMap用于保存已存在的依赖关系，是全局的，并非ThreadLocal。DependsOn依赖虽然发生在创建对象的过程中（在创建Bean过程中会将依赖关系加入已存在的依赖中，但并不会进行依赖检查），但跟创建对象的关系不大，它就是表示一个Bean的创建必须先创建其depensOn的Beans。

原型模式

  Spring不允许原型模式的循环依赖，因为这是个无限循环。用于保存正在被创建对象的集合是TreadLoacal<Set>类型的，也就是说某个线程获取Bean的时候不会受到其他线程的影响。

public abstract class AbstractBeanFactory {
	protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly) {
		...
		
		// 检查当前原型对象是否正在被创建，如果正在被创建，就说明存在着循环依赖，直接抛出异常，不允许原型的循环依赖
		if (isPrototypeCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
	
		...
		
		// 标记当前Bean正在被创建
		// 实际上就是把当前beanName放在一个表示正在被创建Bean的Set中（保存正在被创建的原型beanName，而且是ThreadLocal的）
		beforePrototypeCreation(beanName); 
		// 此方法的执行过程中，当前beanName都处于被创建状态（存在于表示正在被创建Bean的Set中）
		// 只要在该方法执行过程中，创建Bean时的beanName存在于Set中就说明存在循环依赖
		Object prototypeInstance = createBean(beanName, mbd, args);	
		// 标记当前bean已经创建完成，其实就是把当前beanName从表示正在被创建Bean的Set中移除
		afterPrototypeCreation(beanName); 		
				
		...
	}
}	

单例模式

  单例模式主要通过提前发布Bean的方式实现循环依赖。循环依赖Bean的创建过程发生在同一个线程中，代码中的synchronized (this.singletonObjects)是为了让多线程在getBean(…)的过程中不要拿到提前发布的Bean（提前发布的Bean可能没有初始化），而同一个线程可重入synchronized 块。同一个beanName对应的单例Bean，可能是某个直接的对象，也可能是其代理，但每次获取的单例Bean或循环依赖注入的单例Bean默认必须是同一个对象会同一个代理。
  单例的循环依赖主要依靠Bean的提前发布来完成，当发生构造器循环注入时，Bean尚未完成实例化，无法提前发布（由代码可知，Bean的提前发布发生在实例化和属性注入之间），所以不允许构造器注入的循环依赖。
  通过提前发布Bean，在属性注入过程中可以实现循环依赖。但是，在发生循环依赖时，如果初始化前后处理过程中使用了代理，那么就会出现问题（一级缓存和二级缓存中缓存的是不同的单例Bean），所以这种情况下不允许循环依赖。
  在单例解决循环依赖的过程中用到了三级缓存，一级缓存用于保存已完全发布的单例Bean，是必不可少的，二级与三级缓存是否必要呢？三级缓存用于缓存工厂，为什么不直接调用工厂的方法，而要通过注册工厂然后获取工厂来回调的方式呢，那是因为工厂里的方法必须依赖后面才实例化出来的Bean，所以必须在实例化后才进行工厂注册。三级缓存并非直接存放提前发布的Bean，而是需要先获取工厂，然后进行一系列的处理才能获取Bean，为了提高效率，直接存储不完全发布Bean的二级缓存便出现了，同时，只有在循环依赖发生时才会把三级缓存提升到二级缓存，所以二级缓存是否有值也可以用来衡量是否存在着循环依赖（是否存在循环依赖的判断，在最后处理时发挥着重要作用）。

public abstract class AbstractBeanFactory {
	protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly) {
		...
		
		// getSingleton(beanName, true);
		Object sharedInstance = getSingleton(beanName);		
		if (sharedInstance == null) {
			sharedInstance = getSingleton(beanName, () -> {
				return createBean(beanName, mbd, args);	// 调用了doCreateBean(...)			
			});
		}

		...
	}

	// 三级缓存获取单例Bean
	// 一级缓存存放完全发布的单例，二级缓存存放提前发布的单例，为什么要做成三级缓存？可以通过二级缓存中有没有值来判断是否存在着循环依赖
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		// 直接从一级缓存中获取完全发布的单例Bean，singletonObjects用于保存完全发布的单例Bean
		Object singletonObject = this.singletonObjects.get(beanName);
		// 如果当前单例正在被创建
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			// 多线程要往下走必须等到单例Bean完全发布，所以就算从二级缓存中获取到的Bean也已经是完全发布的了
			// 循环依赖处于同一个线程，可以直接进入同步块，获取二级缓存得到不完全发布的单例Bean
			synchronized (this.singletonObjects) {
				// 从二级缓存中获取可能不完全发布的单例Bean，二级缓存的值只会来自于三级缓存，故而可以根据二级缓存中是否有值来判断是否存在循环依赖
				singletonObject = this.earlySingletonObjects.get(beanName);
				if (singletonObject == null && allowEarlyReference) {
					// 该工厂在实例化与属性注入之间进行注册
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						// 从三级缓存中获取Bean并放入二级缓存，同时移除三级缓存
						singletonObject = singletonFactory.getObject();
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName); // 三级缓存已经没有用了，既然有了二级缓存就不会再进入三级缓存
					}
				}
			}
		}
		
		// 返回的是完全发布或者不完全发布的单例Bean，返回null表示未曾创建也并非正在创建Bean，所以返回null之后就需要开始创建Bean了
		return singletonObject;
	}
	
	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		synchronized (this.singletonObjects) { 
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) { 
				// 此模块以外的部分与循环依赖无关，上面的synchronized块、取缓存、判断能否取到缓存都是为了解决多线程的单例创建问题（设计模式中典型的单例模式）
				
				// 在发生构造器注入（三级缓存发布之前的注入）的循环依赖过程中，会进入此处，直接抛出异常，说明不支持构造器注入的循环依赖
				if (this.singletonsCurrentlyInDestruction) {
					throw new BeanCreationNotAllowedException(...);
				}
				
				beforeSingletonCreation(beanName);	
				// 此时就是回调的createBean方法，前后分别标记该单例Bean正在创建和创建完成
				singletonObject = singletonFactory.getObject();
				afterSingletonCreation(beanName);
				// 将完全发布的单例Bean放入一级缓存（完全发布的单例Bean进行注册）
				addSingleton(beanName, singletonObject);
			}
			
			return singletonObject;
		}
	}

	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {
			
		... 实例化Bean（包括构造器注入依赖） ...
		
		// 在实例化与属性注入之间，提前发布单例Bean实例
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			// 三级缓存注册
			// getEarlyBeanReference(...)会调用所有的SmartInstantiationAwareBeanPostProcessor.etEarlyBeanReference(...)
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}
		
		// 属性注入过程中可能发生循环依赖
		populateBean(beanName, mbd, instanceWrapper);
		// 初始化过程中可能得到Bean的代理对象
		Object exposedObject = initializeBean(beanName, exposedObject, mbd);

		if (earlySingletonExposure) {
			// 由于单例对象此时并没有放入一级缓存，此处第二个参数又为false（不会从三级缓存中取），所以此处实际上是从二级缓存中取Bean
			// 如果从二级缓存中能够取到单例Bean，那么就说明存在循环依赖
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) { // 存在循环依赖			
				// 存在着循环依赖时要考虑到原Bean在不完全发布与完全发布过程中被分别代理的情况（不存在循环依赖就不存在分开代理的情况）
				// 虽然完全发布的Bean和不完全发布的Bean存在着初始化与未初始化的问题，但他们必须是同一个对象（可能是原对象的同一个代理）
			
				// 初始化没有引入代理，那么就直接使用提前发布的Bean作为完全发布的Bean（提前发布的Bean可能是个代理对象，这样完全发布的就是代理对象，而被代理对象也已经完成了初始化）
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				} else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					// 初始化引入了代理，后面的代码也没有看懂，反正默认情况下会抛出异常，因为完全发布和不完全发布的单例Bean是不同的对象
					// 如果非要允许这种不同单例Bean的发布，可以将BeanFactory的allowRawInjectionDespiteWrapping设置为true
					// 这样就允许循环注入的Bean与直接获取的Bean是不同对象
					
					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(...);
					}
				}
			}
		}

		...

		return exposedObject;
	}
}