Spring IoC源码：createBean（中）
文章目录
- Spring源码系列：
- 前言
- 正文
-
- 方法1：applyMergedBeanDefinitionPostProcessors
- 方法2：addSingletonFactory
- 方法3：populateBean
- 方法4：autowireByName
- 方法5：unsatisfiedNonSimpleProperties
- 方法6：containsBean
- 方法7：autowireByType
- 方法8：resolveDependency
- 方法9：doResolveDependency
- 方法10：findAutowireCandidates
- 方法11：addCandidateEntry
- 方法12：getType
- 方法13：determineAutowireCandidate
- 方法14：determinePrimaryCandidate
- 方法15：determineHighestPriorityCandidate
- 方法16：applyPropertyValues
- 方法17：resolveValueIfNecessary
- 总结
Spring源码系列：
Spring IOC源码：简单易懂的Spring IOC 思路介绍
Spring IOC源码：核心流程介绍
Spring IOC源码：ApplicationContext刷新前准备工作
Spring IOC源码：obtainFreshBeanFactory 详解（上）
Spring IOC源码：obtainFreshBeanFactory 详解（中）
Spring IOC源码：obtainFreshBeanFactory 详解（下）
Spring IOC源码：＜context:component-scan＞源码详解
Spring IOC源码：invokeBeanFactoryPostProcessors 后置处理器详解
Spring IOC源码：registerBeanPostProcessors 详解
Spring IOC源码：实例化前的准备工作
Spring IOC源码：finishBeanFactoryInitialization详解
Spring IoC源码：getBean 详解
Spring IoC源码：createBean（ 上）
Spring IoC源码：createBean（ 中）
Spring IoC源码：createBean（ 下）
Spring IoC源码：finishRefresh 完成刷新详解
前言
上篇文章讲解了Bean的实例化过程，包含构造器的选择、参数的创建等，本篇继续创建createBean的剩余流程，包括Bean实例化后的初始化属性注入工作，以及BeanPostProcessor的执行过程。
正文
上篇文章讲解了createBeanInstance(beanName, mbd, args)方法的流程，这节继续讲解后续内容。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
//如果是单例并且是FactoryBean则尝试移除
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//创建Bean实例，通过策略进行创建，如果选择有参构造或无参构造
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//获取当前实例对象
final Object bean = instanceWrapper.getWrappedInstance();
//当前实例的Calss对象
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
//设置当前bean定义信息的目标类型
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//执行MergedBeanDefinitionPostProcessor类型后置处理器的postProcessMergedBeanDefinition方法，
//如@Autowire注解，就是通过该后置处理器进行解析
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.
//如果是单例，允许循环依赖，并且beanName正在创建中
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//包装成FactoryObject对象，并添加到三级缓存中
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//初始化过程，进行属性注入。该过程递归创建其依赖的属性。如果A中有B，B中有C，则创建B跟C。
populateBean(beanName, mbd, instanceWrapper);
//该过程执行后置处理器的before方法，bean的init方法，后置处理器的after方法，可能会生成新的bean对象
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
//从缓存中获取，因为上面我们将其添加到三级缓存中，从三级缓存中获取会调用FactoryObject对象的getObject方法，可能会触发AOP代理。返回代理对象
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
//如果bean对象还是原来的，则将三级缓存中获取的对象赋值过去
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
//如果exposedObject在initializeBean方法中被增强 && 不允许在循环引用的情况下使用注入原始bean实例
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
// 获取依赖当前beanName的所有bean名称
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
//尝试移除这些bean的实例，因为这些bean依赖的bean已经被增强了，他们依赖的bean相当于脏数据
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 {
//注册用于销毁的bean，执行销毁操作的有三种：自定义destroy方法、DisposableBean接口、DestructionAwareBeanPostProcessor
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName)，见方法1详解
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))，见方法2详解
populateBean(beanName, mbd, instanceWrapper)，见方法3详解
方法1：applyMergedBeanDefinitionPostProcessors
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
//执行类型为MergedBeanDefinitionPostProcessor的后置处理器，@Autowire注解就是在这块解析的
if (bp instanceof MergedBeanDefinitionPostProcessor) {
MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
}
}
}
方法2：addSingletonFactory
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
//如果一级缓存中不存在该对象
if (!this.singletonObjects.containsKey(beanName)) {
//往三级缓存中存入类型为ObjectFactory的工厂对象
this.singletonFactories.put(beanName, singletonFactory);
//移除二级缓存
this.earlySingletonObjects.remove(beanName);
//将beanName添加到注册缓存中
this.registeredSingletons.add(beanName);
}
}
}
三级缓存中我们存入的是工厂对象，我们知道工厂对象要获取实例是通过getObject()方法返回实例的，这里传进来是一个匿名内部类，其getObject()方法实现如代码块所示：
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
//判断是否有InstantiationAwareBeanPostProcessors类型的后置处理器
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
//执行类型为SmartInstantiationAwareBeanPostProcessor的后置处理器
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
//返回实例
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
我们在创建完对象是往三级缓存中存入工厂对象的，以上执行后置处理器的过程返回的对象可能是代理后的对象，这样当我有被其它Bean所引用时，会执行getSingleton()方法,从三级缓存中获取对象并将其添加到二级缓存中，移除三级缓存，这样就能保证被注入的Bean是一个代理后的对象，这是解决循环依赖重要的步骤。
方法3：populateBean
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
//如果是创建的为空，则判断是否有属性需要注入，有则抛异常
if (bw == null) {
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
// Skip property population phase for null instance.
return;
}
}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
//标识是否继续属性填充标识
boolean continueWithPropertyPopulation = true;
//如果不是合成的&&有注册InstantiationAwareBeanPostProcessors
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
//遍历执行InstantiationAwareBeanPostProcessors的postProcessAfterInstantiation方法
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
//如果经过后置处理器处理后，则跳过后续的步骤
if (!continueWithPropertyPopulation) {
return;
}
//获取bean定义信息中的属性值，如autowireByName(beanName, mbd, bw, newPvs)，见方法4详解
autowireByType(beanName, mbd, bw, newPvs)，见方法7详解
applyPropertyValues(beanName, mbd, bw, pvs)，见方法8详解
applyPropertyValues(beanName, mbd, bw, pvs)，见方法16详解
方法4：autowireByName
protected void autowireByName(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
/过滤掉某些属性类型，返回需要注入的属性名称集
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
//遍历注入
for (String propertyName : propertyNames) {
//判断容器中是否存在该属性名称对应的bean
if (containsBean(propertyName)) {
//获取实例化Bean
Object bean = getBean(propertyName);
//添加到需要注入的属性值
pvs.add(propertyName, bean);
//注册依赖关系
registerDependentBean(propertyName, beanName);
if (logger.isTraceEnabled()) {
logger.trace("Added autowiring by name from bean name '" + beanName +
"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
"' by name: no matching bean found");
}
}
}
}
unsatisfiedNonSimpleProperties(mbd, bw)，见方法5详解
containsBean(propertyName)，见方法6详解
方法5：unsatisfiedNonSimpleProperties
protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
Set<String> result = new TreeSet<>();
//获取当前需要注入的参数值集
PropertyValues pvs = mbd.getPropertyValues();
//获取 bean的属性描述信息
PropertyDescriptor[] pds = bw.getPropertyDescriptors();
for (PropertyDescriptor pd : pds) {
//如果有set方法&&不是排除的依赖&&不存在已解析的集合中&&不是简单的属性，如Number、DATE、基本数据类型等
if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
!BeanUtils.isSimpleProperty(pd.getPropertyType())) {
result.add(pd.getName());
}
}
return StringUtils.toStringArray(result);
}
方法6：containsBean
public boolean containsBean(String name) {
//根据别名获取真正的beanName
String beanName = transformedBeanName(name);
//判断三级缓存中是否存在或Bean定义缓存中是否存在该定义
if (containsSingleton(beanName) || containsBeanDefinition(beanName)) {
//name不带&符号，并且判断是否是工厂Bean
return (!BeanFactoryUtils.isFactoryDereference(name) || isFactoryBean(name));
}
// Not found -> check parent.
//查询不到获取父类工厂，并在父工厂中进行查找
BeanFactory parentBeanFactory = getParentBeanFactory();
return (parentBeanFactory != null && parentBeanFactory.containsBean(originalBeanName(name)));
}
方法7：autowireByType
protected void autowireByType(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
//获取类型转换器
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
//过滤掉一些特定的属性类型，返回需要注入的集合
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
try {
//获取属性描述信息
PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
// Don't try autowiring by type for type Object: never makes sense,
// even if it technically is a unsatisfied, non-simple property.
//如果不是Object类型则不处理
if (Object.class != pd.getPropertyType()) {
//获取该属性的set方法参数信息
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
// Do not allow eager init for type matching in case of a prioritized post-processor.
boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
//将set方法信息封装成DependencyDescriptor 对象
DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
//解析当前属性所匹配的bean实例，并把解析到的bean实例的beanName存储在autowiredBeanNames中
Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
if (autowiredArgument != null) {
//添加到需要注入的属性值集合中
pvs.add(propertyName, autowiredArgument);
}
for (String autowiredBeanName : autowiredBeanNames) {
//注册依赖关系
registerDependentBean(autowiredBeanName, beanName);
if (logger.isTraceEnabled()) {
logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +
propertyName + "' to bean named '" + autowiredBeanName + "'");
}
}
autowiredBeanNames.clear();
}
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
}
}
}
resolveDependency(desc, beanName, autowiredBeanNames, converter)，见方法8详解
方法8：resolveDependency
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
//初始化参数名称查询器
descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
//判断依赖类型是否为Optional
if (Optional.class == descriptor.getDependencyType()) {
return createOptionalDependency(descriptor, requestingBeanName);
}
//判断依赖类型是否为ObjectFactory
else if (ObjectFactory.class == descriptor.getDependencyType() ||
ObjectProvider.class == descriptor.getDependencyType()) {
return new DependencyObjectProvider(descriptor, requestingBeanName);
}
//判断依赖类型是否为javaxInjectProviderClass
else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
}
else {
//获取懒加载代理对象
Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
descriptor, requestingBeanName);
if (result == null) {
//解析所需依赖对象
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}
return result;
}
}
doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter)，见方法9详解
方法9：doResolveDependency
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
try {
//获取shortcut 对象
Object shortcut = descriptor.resolveShortcut(this);
if (shortcut != null) {
return shortcut;
}
//获取依赖类型
Class<?> type = descriptor.getDependencyType();
//获取指定值，如@qualifier就是在这里解析的
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());
try {
//对值进行转换
return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
}
catch (UnsupportedOperationException ex) {
// A custom TypeConverter which does not support TypeDescriptor resolution...
return (descriptor.getField() != null ?
converter.convertIfNecessary(value, type, descriptor.getField()) :
converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
}
}
//处理类型为多个的情况，如Array、Collection、MAP
Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
if (multipleBeans != null) {
return multipleBeans;
}
//从beanFactory中解析候选类，即允许被注入的bean
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
//查询不到时，判断是否有required标识，有则抛异常
if (matchingBeans.isEmpty()) {
if (isRequired(descriptor)) {
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
return null;
}
String autowiredBeanName;
Object instanceCandidate;
//如果按类型查找出多个bean
if (matchingBeans.size() > 1) {
//判断是否有primary标志，并返回符合条件的beanName
autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
if (autowiredBeanName == null) {
//有require标识，或者不是Collection等容器类型，则抛异常
if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
}
else {
// In case of an optional Collection/Map, silently ignore a non-unique case:
// possibly it was meant to be an empty collection of multiple regular beans
// (before 4.3 in particular when we didn't even look for collection beans).
return null;
}
}
//获取符合条件的实例
instanceCandidate = matchingBeans.get(autowiredBeanName);
}
else {
// We have exactly one match.
//只有一个的情况下则直接获取第一个值
Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
autowiredBeanName = entry.getKey();
instanceCandidate = entry.getValue();
}
//添加autowiredBeanName到autowiredBeanNames中
if (autowiredBeanNames != null) {
autowiredBeanNames.add(autowiredBeanName);
}
//如果类型为Class，则进行实例化
if (instanceCandidate instanceof Class) {
instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
}
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);
}
}
findAutowireCandidates(beanName, type, descriptor)，见方法10详解
determineAutowireCandidate(matchingBeans, descriptor)，见方法13详解
方法10：findAutowireCandidates
protected Map<String, Object> findAutowireCandidates(
@Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {
//从beanFactory工厂中通过类型获取对应的beanName
String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this, requiredType, true, descriptor.isEager());
Map<String, Object> result = new LinkedHashMap<>(candidateNames.length);
//遍历依赖缓存
for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
//获取key值
Class<?> autowiringType = classObjectEntry.getKey();
//判断类型是否所需类型
if (autowiringType.isAssignableFrom(requiredType)) {
//获取依赖value
Object autowiringValue = classObjectEntry.getValue();
//判断需要的类型跟当前获取的值autowiringValue 不是同个类型
//并且如果autowiringValue是工厂对象的话，则调用getObject方法获取
autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
//如果两个类型一致，则生成一个新的beanName，并放入map中
if (requiredType.isInstance(autowiringValue)) {
result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
break;
}
}
}
//遍历候选类集合
for (String candidate : candidateNames) {
//依赖所需对象不能是当前bean本身，如B中有属性B这种情况&&判断允许被其它bean注入
if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
//如果前面获取不到合适的类型
if (result.isEmpty()) {
//判断是否是容器类型，如Collection
boolean multiple = indicatesMultipleBeans(requiredType);
// Consider fallback matches if the first pass failed to find anything...
DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
//使用备用的依赖描述器再去获取一遍符合注入属性类型的beanName
for (String candidate : candidateNames) {
if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor) &&
(!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) {
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
//还是没有符合注入属性类型的beanName，又不是集合类型，考虑自引用，符合条件则将候选者添加到result中
if (result.isEmpty() && !multiple) {
// Consider self references as a final pass...
// but in the case of a dependency collection, not the very same bean itself.
for (String candidate : candidateNames) {
if (isSelfReference(beanName, candidate) &&
(!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&
isAutowireCandidate(candidate, fallbackDescriptor)) {
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
}
}
return result;
}
addCandidateEntry(result, candidate, descriptor, requiredType)，见方法11详解
方法11：addCandidateEntry
private void addCandidateEntry(Map<String, Object> candidates, String candidateName,
DependencyDescriptor descriptor, Class<?> requiredType) {
//如果是一个MultiElementDescriptor类型的
if (descriptor instanceof MultiElementDescriptor) {
//实例化
Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this);
if (!(beanInstance instanceof NullBean)) {
candidates.put(candidateName, beanInstance);
}
}
else if (containsSingleton(candidateName) || (descriptor instanceof StreamDependencyDescriptor &&
((StreamDependencyDescriptor) descriptor).isOrdered())) {
//实例化
Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this);
//加入缓存中
candidates.put(candidateName, (beanInstance instanceof NullBean ? null : beanInstance));
}
else {
//将candidateName跟candidateName的class对象存入缓存中
candidates.put(candidateName, getType(candidateName));
}
}
getType(candidateName)，见方法12详解
方法12：getType
public Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException {
String beanName = transformedBeanName(name);
// Check manually registered singletons.
//从一级缓存中获取对象
Object beanInstance = getSingleton(beanName, false);
if (beanInstance != null && beanInstance.getClass() != NullBean.class) {
//如果是FactoryBean ,则调用其getObjectType返回真正的实例class
if (beanInstance instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) {
return getTypeForFactoryBean((FactoryBean<?>) beanInstance);
}
else {
//返回class对象
return beanInstance.getClass();
}
}
// No singleton instance found -> check bean definition.
//前面如果查询不到，则获取父工厂进行查询
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// No bean definition found in this factory -> delegate to parent.
return parentBeanFactory.getType(originalBeanName(name));
}
//获取合并的Bean定义信息
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// Check decorated bean definition, if any: We assume it'll be easier
// to determine the decorated bean's type than the proxy's type.
//获取目标代理对象
BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
//判断name是否带有&前缀，如果不是工厂对象
if (dbd != null && !BeanFactoryUtils.isFactoryDereference(name)) {
RootBeanDefinition tbd = getMergedBeanDefinition(dbd.getBeanName(), dbd.getBeanDefinition(), mbd);
//获取beanName对应的class对象
Class<?> targetClass = predictBeanType(dbd.getBeanName(), tbd);
if (targetClass != null && !FactoryBean.class.isAssignableFrom(targetClass)) {
return targetClass;
}
}
//获取beanName对应的class对象
Class<?> beanClass = predictBeanType(beanName, mbd);
// Check bean class whether we're dealing with a FactoryBean.
//如果不为空&&类型为FactoryBean
if (beanClass != null && FactoryBean.class.isAssignableFrom(beanClass)) {
//name不带&符号，即不是获取工厂对象本身
if (!BeanFactoryUtils.isFactoryDereference(name)) {
// If it's a FactoryBean, we want to look at what it creates, not at the factory class.
//返回实际的对象class
return getTypeForFactoryBean(beanName, mbd, allowFactoryBeanInit).resolve();
}
else {
return beanClass;
}
}
else {
return (!BeanFactoryUtils.isFactoryDereference(name) ? beanClass : null);
}
}
方法13：determineAutowireCandidate
protected String determineAutowireCandidate(Map<String, Object> candidates, DependencyDescriptor descriptor) {
//获取需要注入依赖的类型
Class<?> requiredType = descriptor.getDependencyType();
//解析，筛选带有primary属性的beanName
String primaryCandidate = determinePrimaryCandidate(candidates, requiredType);
if (primaryCandidate != null) {
return primaryCandidate;
}
//如果被注入类有实现OrderComparator接口，则进行比较筛选出Priority，值越低优先级越高
String priorityCandidate = determineHighestPriorityCandidate(candidates, requiredType);
if (priorityCandidate != null) {
return priorityCandidate;
}
// Fallback
//遍历候选bean
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;
}
determinePrimaryCandidate(candidates, requiredType)，见方法14详解
determineHighestPriorityCandidate(candidates, requiredType)，见方法15详解
方法14：determinePrimaryCandidate
protected String determinePrimaryCandidate(Map<String, Object> candidates, Class<?> requiredType) {
String primaryBeanName = null;
for (Map.Entry<String, Object> entry : candidates.entrySet()) {
String candidateBeanName = entry.getKey();
Object beanInstance = entry.getValue();
//判断是否有Primary标识
if (isPrimary(candidateBeanName, beanInstance)) {
if (primaryBeanName != null) {
boolean candidateLocal = containsBeanDefinition(candidateBeanName);
boolean primaryLocal = containsBeanDefinition(primaryBeanName);
//如果存在两个依赖都有其Primary，则抛异常
if (candidateLocal && primaryLocal) {
throw new NoUniqueBeanDefinitionException(requiredType, candidates.size(),
"more than one 'primary' bean found among candidates: " + candidates.keySet());
}
else if (candidateLocal) {
//赋值
primaryBeanName = candidateBeanName;
}
}
else {
//赋值
primaryBeanName = candidateBeanName;
}
}
}
return primaryBeanName;
}
方法15：determineHighestPriorityCandidate
protected String determineHighestPriorityCandidate(Map<String, Object> candidates, Class<?> requiredType) {
//最高优先级的beanName
String highestPriorityBeanName = null;
//最高优先级值
Integer highestPriority = null;
//遍历
for (Map.Entry<String, Object> entry : candidates.entrySet()) {
String candidateBeanName = entry.getKey();
Object beanInstance = entry.getValue();
if (beanInstance != null) {
//获取优先级
Integer candidatePriority = getPriority(beanInstance);
if (candidatePriority != null) {
if (highestPriorityBeanName != null) {
//存在两个优先级一样则抛异常
if (candidatePriority.equals(highestPriority)) {
throw new NoUniqueBeanDefinitionException(requiredType, candidates.size(),
"Multiple beans found with the same priority ('" + highestPriority +
"') among candidates: " + candidates.keySet());
}
//比较，candidatePriority 值越低则优先级越高
else if (candidatePriority < highestPriority) {
highestPriorityBeanName = candidateBeanName;
highestPriority = candidatePriority;
}
}
else {
//第一次则直接赋值
highestPriorityBeanName = candidateBeanName;
highestPriority = candidatePriority;
}
}
}
}
return highestPriorityBeanName;
}
方法16：applyPropertyValues
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;
//如果参数MutablePropertyValues类型
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();
//判断值是否是AutowiredPropertyMarker类型
if (originalValue == AutowiredPropertyMarker.INSTANCE) {
//获取set方法
Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod();
if (writeMethod == null) {
throw new IllegalArgumentException("Autowire marker for property without write method: " + pv);
}
//将参数值封装成DependencyDescriptor
originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true);
}
//对值进行解析转换，如果类型是beanFactory工厂中的beanDefinition封装的信息时，则会进行实例化
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);
}
}
valueResolver.resolveValueIfNecessary(pv, originalValue)，见方法17详解
方法17：resolveValueIfNecessary
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类型，则调用getBean方法获取创建实例
RuntimeBeanReference ref = (RuntimeBeanReference) value;
return resolveReference(argName, ref);
}
else if (value instanceof RuntimeBeanNameReference) {
//获取依赖的beanName
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:包含带有名称和别名的BeanDefinition。
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，不包含名称:使用虚拟名称
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 DependencyDescriptor) {
Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
//创建实例，并解析出候选的bean信息
Object result = this.beanFactory.resolveDependency(
(DependencyDescriptor) value, this.beanName, autowiredBeanNames, this.typeConverter);
//实例化，并注册依赖关系
for (String autowiredBeanName : autowiredBeanNames) {
if (this.beanFactory.containsBean(autowiredBeanName)) {
this.beanFactory.registerDependentBean(autowiredBeanName, this.beanName);
}
}
return result;
}
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);
}
}
限于篇幅，本篇文章讲解到这，后续文章继续讲解populateBean及其createBean后续流程。
总结
本篇文章讲解了属性注入过程中所需参数的解析工作，一般我们可以在xml配置文件中指定其参数值，或通知设置autowire属性指定byType或byName，从beanFactory查找出所需注入对象，梳理一下流程。
1、获取BeanDefinition中已经解析的参数信息
2、判断是否有autowire属性，如果其指定值为byName，则通过其属性名称去缓存中获取实例，并封装到参数集合中。
3、如果autowire属性值为byType，则尝试通过需要注入的beanName从依赖缓存resolvableDependencies中获取，及从beanFactory工厂中获取类型为注入Bean类型的定义信息，返回beanName:class集合
4、如果候选的依赖有多个值，则遍历查询是否有primary属性，有则筛选对应的bean。如果都没有primary属性，则判断是否有实现OrderComparator接口，则进行比较筛选出Priority，值越低优先级越高。前面两者都不满足时，判断是否有候选的beanName值与要注入的属性的依赖名称一致，有则返回。没有筛选出则抛出异常
5、对筛选出来的候选类进行实例化，并封装到属性参数中
6、对所有的参数类型进行转换创建，如参数类型RuntimeBeanReference时，会调用getBean进行获取创建，最后通过反射的返回注入到Bean中。