Java Autowired注解深入分析

@RestController
public class HomeController {
    @Autowired
    private HomeService homeService;
    @RequestMapping("/index")
    public String index() {
        return homeService.testService();
    }
}

//接口
public interface HomeService {
    String testService();
}
//实现类
@Service
public class HomeServiceImpl implements HomeService{
    @Override
    public String testService(){
        return "I'm a test service";
    }
}

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		//遍历所有的beanPostProcessor,寻找bean中被Autowired注解修饰的成员变量
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}
		Object exposedObject = bean;
		try {
			//给bean填充其他bean。对应到我们的demo，就是给HomeController注入HomeService。
			populateBean(beanName, mbd, instanceWrapper);
		}
		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);
			}
		}
	}

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
		for (MergedBeanDefinitionPostProcessor processor : getBeanPostProcessorCache().mergedDefinition) {
			processor.postProcessMergedBeanDefinition(mbd, beanType, beanName);
		}
	}

@Override
	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
		InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
		metadata.checkConfigMembers(beanDefinition);
	}

private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
			ReflectionUtils.doWithLocalFields(targetClass, field -> {
			//寻找字段上有被Autowired注解修饰的字段
				MergedAnnotation<?> ann = findAutowiredAnnotation(field);
				if (ann != null) {
				//static修饰的静态字段不能进行注入
					if (Modifier.isStatic(field.getModifiers())) {
						if (logger.isInfoEnabled()) {
							logger.info("Autowired annotation is not supported on static fields: " + field);
						}
						return;
					}
					boolean required = determineRequiredStatus(ann);
					currElements.add(new AutowiredFieldElement(field, required));
				}
			});
		return InjectionMetadata.forElements(elements, clazz);
	}

@Override
	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
		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) {
		//构建缓存key
		String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
		//第一次执行，缓存中没有数据，先构建，然后放入缓存。第二次执行有数据，直接从缓存中获取
		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);
					}
					//第一次执行，缓存中不存在，先放入缓存。
					metadata = buildAutowiringMetadata(clazz);
					this.injectionMetadataCache.put(cacheKey, metadata);
				}
			}
		}
		return metadata;
	}

@Override
		protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
			Field field = (Field) this.member;
			else {
			//到Spring容器中寻找待注入的bean
				value = resolveFieldValue(field, bean, beanName);
			}
			//找到之后，反射注入
			if (value != null) {
				ReflectionUtils.makeAccessible(field);
				field.set(bean, value);
			}
		}