Spring源码分析（三）@Autowired依赖注入源码分析

class="com.my.ioc.pojo.People" autowire="byType"/>

class="com.my.ioc.pojo.factorybean.Bird" />

@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
// InjectionMetadata 中保存了所有被@Autowired注解标注的属性/方法 并封装成一个个的InjectedElement
// 在postProcessMergedBeanDefinition 方法里已经得到放到缓存中了
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
//按注入点进行注入
metadata.inject(bean, beanName, pvs);
}
catch (BeanCreationException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
return pvs;
}

private InjectionMetadata findAutowiringMetadata(String beanName, Class clazz, @Nullable PropertyValues pvs) {
// Fall back to class name as cache key, for backwards compatibility with custom callers.
// 把beanName作为缓存的key
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
// Quick check on the concurrent map first, with minimal locking.
InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
synchronized (this.injectionMetadataCache) {
metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
if (metadata != null) {
metadata.clear(pvs);
}
//寻找当前class的注入点，把所有注入点整合为一个InjectionMetadata
metadata = buildAutowiringMetadata(clazz);
//放入缓存中
this.injectionMetadataCache.put(cacheKey, metadata);
}
}
}
return metadata;
}

private InjectionMetadata buildAutowiringMetadata(final Class clazz) {
// 判断是不是候选者类，比如说类名是以 java.开头的则不是候选者类 Order的实现类也不是候选者类
// 但是如果this.autowiredAnnotationTypes 中有以java.开头的注解就返回true了
if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
return InjectionMetadata.EMPTY;
}
List elements = new ArrayList<>();
Class targetClass = clazz;
do {
final List currElements = new ArrayList<>();
// 遍历属性，看是否有@Autowired @Value @Inject注解
ReflectionUtils.doWithLocalFields(targetClass, field -> {
MergedAnnotation ann = findAutowiredAnnotation(field);
//如果存在上面中的一个
if (ann != null) {
// 如果字段是静态的，则直接进行返回，不进行注入
if (Modifier.isStatic(field.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static fields: " + field);
}
return;
}
// 是否required
boolean required = determineRequiredStatus(ann);
// 生成一个注入点AutowiredFieldElement
currElements.add(new AutowiredFieldElement(field, required));
}
});
//遍历所有的方法 看是否有@Autowired @Value @Inject注解
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
// 这是找字节码中被桥接后的方法
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
MergedAnnotation ann = findAutowiredAnnotation(bridgedMethod);
if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
//静态方法不能用来注入属性
if (Modifier.isStatic(method.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static methods: " + method);
}
return;
}
//方法参数为0 不能用来注入属性
if (method.getParameterCount() == 0) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation should only be used on methods with parameters: " +
method);
}
}
boolean required = determineRequiredStatus(ann);
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
currElements.add(new AutowiredMethodElement(method, required, pd));
}
});
elements.addAll(0, currElements);
// 是会去找父类 进行递归操作
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
return InjectionMetadata.forElements(elements, clazz);
}

public static boolean isCandidateClass(Class clazz, Collectionextends Annotation>> annotationTypes) {
for (Classextends Annotation> annotationType : annotationTypes) {
if (isCandidateClass(clazz, annotationType)) {
return true;
}
}
return false;
}

public static boolean isCandidateClass(Class clazz, String annotationName) {
// 注解有java开头的注解就算是候选者，但是一般不会有，除非自己添加
if (annotationName.startsWith("java.")) {
return true;
}
// 如果clazz是以java.开头或Order的子类，也不算是候选者
if (AnnotationsScanner.hasPlainJavaAnnotationsOnly(clazz)) {
return false;
}
return true;
}

static boolean hasPlainJavaAnnotationsOnly(Class type) {
return (type.getName().startsWith("java.") || type == Ordered.class);
}

@Nullable
private MergedAnnotation findAutowiredAnnotation(AccessibleObject ao) {
// 查看当前字段上是否存在@Autowired @Value @Inject注解 存在其中一个则返回，表示可以注入
MergedAnnotations annotatiOns= MergedAnnotations.from(ao);
// autowiredAnnotationTypes 是一个LinkHashSet 所以会按照顺序去判断当前字段中是否有Autowired注解，如果有则返回，
//如果没有则Autowired注解 则判断是否有value注解 再判断是否有Inject注解
for (Classextends Annotation> type : this.autowiredAnnotationTypes) {
MergedAnnotation annotation = annotations.get(type);
if (annotation.isPresent()) {
return annotation;
}
}
return null;
}

public static InjectionMetadata forElements(Collection elements, Class clazz) {
return (elements.isEmpty() ? InjectionMetadata.EMPTY : new InjectionMetadata(clazz, elements));
}

@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
// InjectionMetadata 中保存了所有被@Autowired注解标注的属性/方法 并封装成一个个的InjectedElement
// 在postProcessMergedBeanDefinition 方法里已经得到放到缓存中了
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
//按注入点进行注入
metadata.inject(bean, beanName, pvs);
}
catch (BeanCreationException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
return pvs;
}

public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Collection checkedElements = this.checkedElements;
Collection elementsToIterate =
(checkedElements != null ? checkedElements : this.injectedElements);
if (!elementsToIterate.isEmpty()) {
//遍历每个能够注入的属性 进行注入
for (InjectedElement element : elementsToIterate) {
if (logger.isTraceEnabled()) {
logger.trace("Processing injected element of bean ‘" + beanName + "‘: " + element);
}
// element可能是Method 也可能是Field 会走不同的子类 AutowiredFieldElement AutowiredMethodElement 都在AutowiredAnnotationBeanPostProcessor 内部

element.inject(target, beanName, pvs);
}
}
}

@Override
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Field field = (Field) this.member;
Object value;
if (this.cached) {
// 当前注入点已经注入过了 有缓存了 则利用缓存this.cachedFieldValue找到对应的bean
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
}
else {
//spring在真正查找属性对应的对象之前 会先将该属性的描述封装成一个DependencyDescriptor 里面存了Field
DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
desc.setContainingClass(bean.getClass());
Set autowiredBeanNames = new LinkedHashSet<>(1);
Assert.state(beanFactory != null, "No BeanFactory available");
TypeConverter typeConverter = beanFactory.getTypeConverter();
try {
// 根据field去寻找合适的bean
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
}
synchronized (this) {
if (!this.cached) {
if (value != null || this.required) {
this.cachedFieldValue = desc;
registerDependentBeans(beanName, autowiredBeanNames);
if (autowiredBeanNames.size() == 1) {
String autowiredBeanName = autowiredBeanNames.iterator().next();
if (beanFactory.containsBean(autowiredBeanName) &&
beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
this.cachedFieldValue = new ShortcutDependencyDescriptor(
desc, autowiredBeanName, field.getType());
}
}
}
else {
this.cachedFieldValue = null;
}
this.cached = true;
}
}
}
if (value != null) {
// 这里才是真正的赋值操作
ReflectionUtils.makeAccessible(field);
field.set(bean, value);
}
}
}

//只负责找对象返回出去，赋值时在外面进行的，比如如果时@Value(xxx) 就把xxx返回出去
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
// DependencyDescriptor 表示一个依赖，可以是一个字段，可以是一个属性字段，可能是一个构造方法参数，可能是一个set方法参数
//根据descriptor去BeanFactory中找到bean
descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
//如果依赖类型是Optional
if (Optional.class == descriptor.getDependencyType()) {
// 注入的时候就是 Optional orderservice; 这个方法内部调用的也是doResolveDependency方法只是把返回结果封装成了Optional. orderservice.get()才能得到里面的实例
return createOptionalDependency(descriptor, requestingBeanName);
}
else if (ObjectFactory.class == descriptor.getDependencyType() ||
ObjectProvider.class == descriptor.getDependencyType()) {
return new DependencyObjectProvider(descriptor, requestingBeanName);
}
else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
}
else {
//在使用@Autowired 注解时 也可以使用@Lazy注解，到时候注入的会是一个代理对象
Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
descriptor, requestingBeanName);
if (result == null) {
//通过解析descriptor找到bean对象
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}
return result;
}
}

@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
try {
//1： 如果DepenDencyDescriptor是一个 ShortcutDependencyDescriptor
// 那么 会直接理解成beanName从beanfactoryz中拿到一个bean
//在利用@autowired注解来进行依赖注入时会利用shortcutDependencyDescriptor来进行依赖注入的缓存
//表示当解析完某个依赖信息后 会把依赖的bean的beanName缓存起来
Object shortcut = descriptor.resolveShortcut(this);
if (shortcut != null) {
return shortcut;
}
//获取descriptor具体的类型 某个Filed的类型 或者某个方法参数的类型
Class type = descriptor.getDependencyType();
// 2：如果descriptor上有@Value注解 获取@Value注解中所配置的值 这个resolver是 QualifierAnnotationAutowireCandidateResolver
// AutowireCandidateResolver autowireCandidateResolver = SimpleAutowireCandidateResolver.INSTANCE; 这是默认的resolver,它可以判断某个bean是不是一个自动注入的候选bean
// 比如： xml中定义的bean可以写个 autowire-candidate="false" 把bean排除 不是自动装配的bean
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
if (value != null) {
if (value instanceof String) {
// 先进行占位符的填充，解析$符号 $(xxx) spring会从环境变量中获取xxx对应的value进行填充
String strVal = resolveEmbeddedValue((String) value);
BeanDefinition bd = (beanName != null && containsBean(beanName) ?
getMergedBeanDefinition(beanName) : null);
// 解析Spring EL表达式 解析# 符号 （可以进行运算 可以写某个bean的名字）
value = evaluateBeanDefinitionString(strVal, bd);
}
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
try {
// 使用类型转换器，转换@Value得到的字符串到type类型
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()));
}
}
// 没有使用@Value注解
//3：要注入的类型是不是一个Map,collection
Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
if (multipleBeans != null) {
return multipleBeans;
}
//4： 表示会根据type去找bean,Map的key为beanName,Map 的value为对象 （注意可能是bean对象 也可能是某个bean的class对象，因为该方法只负责根据类型找到对应的bean,
// 如果该bean 还没有实例化，那么就返回bean对应的class对象
// 该方法也不负责实例化，只返回该bean对应的Class对象，表示这个Bean也是结果之一）
Map matchingBeans = findAutowireCandidates(beanName, type, descriptor);
// 如果根据类型没有找到bean 如果时必须的则抛出异常 如果不是必须的则直接返回 null
if (matchingBeans.isEmpty()) {
if (isRequired(descriptor)) {
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
return null;
}
String autowiredBeanName;
Object instanceCandidate;
//如果找到多个，根据其它参数确定一个返回 {@code @Primary} and {@code @Priority} (in that order)
if (matchingBeans.size() > 1) {
autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
if (autowiredBeanName == null) {
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 entry = matchingBeans.entrySet().iterator().next();
autowiredBeanName = entry.getKey();
instanceCandidate = entry.getValue();
}
if (autowiredBeanNames != null) {
autowiredBeanNames.add(autowiredBeanName);
}
//如果返回的是Class类型就从beanFactory中getBean
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);
}
}

// 根据requiredType 找到自动匹配的候选者bean
protected Map findAutowireCandidates(
@Nullable String beanName, Class requiredType, DependencyDescriptor descriptor) {
// Ancestors 是祖先的意思，这个方法是根据requiredType去当前以及祖先的beanFactory中找这个类型的beanName
String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this, requiredType, true, descriptor.isEager());
Map result = new LinkedHashMap<>(candidateNames.length);
// 先从 resolvableDependencies 中
for (Map.Entry, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
Class autowiringType = classObjectEntry.getKey();
// requiredType 是autowiringType的子类
//requiredType 类是不是继承或实现了autowiringType,autowiringType为父类或接口，子类对象可以赋值给父类属性
if (autowiringType.isAssignableFrom(requiredType)) {
// 是resolvableDependencies中子类所存的对象
Object autowiringValue = classObjectEntry.getValue();
autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
if (requiredType.isInstance(autowiringValue)) {
//把 resolvableDependencies中保存的对象作为当前属性的一个候选者
result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
break;
}
}
}
// 对候选者bean进行过滤，首先候选者不是自己，然后候选者是支持自动注入给其它beand的
for (String candidate : candidateNames) {
// isAutowireCandidate方法中会去判断候选者是否和descriptor匹配 并不是所有bean都是可以进行注入的
// 如果isAutowireCandidate返回的false，也是不会把它作为候选者beanName

if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
if (result.isEmpty()) {
boolean multiple = indicatesMultipleBeans(requiredType);
// Consider fallback matches if the first pass failed to find anything...
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) {
// 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;
}

@Nullable
protected String determineAutowireCandidate(Map candidates, DependencyDescriptor descriptor) {
Class requiredType = descriptor.getDependencyType();
// 取@Primary 的bean
String primaryCandidate = determinePrimaryCandidate(candidates, requiredType);
if (primaryCandidate != null) {
return primaryCandidate;
}
// 取优先级最高的bean,通过@Priority来定义优先级 数字越小 优先级越高
String priorityCandidate = determineHighestPriorityCandidate(candidates, requiredType);
if (priorityCandidate != null) {
return priorityCandidate;
}
// Fallback
// 如果根据上面的 @Primary @Priorityd都没找到，就根据属性名/方法参数名从map中获取一个候选beanName
for (Map.Entry entry : candidates.entrySet()) {
String candidateName = entry.getKey();
Object beanInstance = entry.getValue();
if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) ||
// 根据属性名/方法参数名确定，找到的candidateName 和当前descriptor.getDependencyName 相等就返回
matchesBeanName(candidateName, descriptor.getDependencyName())) {
return candidateName;
}
}
return null;
}

public class Father {
@Autowired
private T t;
public T getT() {
return t;
}
}

@Service
public class Son extends Father {
}

AnnotationConfigApplicationContext applicatiOnContext= new AnnotationConfigApplicationContext(BeanConfig.class);
System.out.println("======================");
Son son=(Son)applicationContext.getBean("son");
System.out.println(son.getT());