介绍
@Autowired是最常见的自动注入注解，可以对成员变量、方法和构造函数进行标注，来完成自动装配的工作。
简单示例
@Component
public class MyService {
@Autowired
UserService userService;
}
MyService 中自动注入UserService
原理介绍
对象实例化后填充属性过程中，通过后置处理器AutowiredAnnotationBeanPostProcessor取出@Autowired注解的属性，getBean获取注入的bean，通过反射将属性设置进去。
源码解析
AutowiredAnnotationBeanPostProcessor是个特殊的bean，经历 BeanDefinition -》bean -》处理bean的@Autowired注解的field
添加BeanDefinition
容器初始化时，最终会调用AnnotationConfigUtils.registerAnnotationConfigProcessors，添加BeanDefinition
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
....省略无关代码
//registry中不存在AutowiredAnnotationProcessor，则加入
if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
//新建AutowiredAnnotationBeanPostProcessor类型的RootBeanDefinition
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
//加入BeanDefinitionRegistry中
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
//同理加入CommonAnnotationBeanPostProcessor类型的BeanDefinition
if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
}
....省略无关代码
return beanDefs;
}
加载AutowiredAnnotationBeanPostProcessor
想象一下，在加载我们自定义的bean之前，AutowiredAnnotationBeanPostProcessor肯定已经加载到容器中了，因为在加载自定的bean时就需要用到此后置处理器。
AbstractApplicationContext.refresh() -> registerBeanPostProcessors()
->PostProcessorRegistrationDelegate.registerBeanPostProcessors
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
//获取BeanPostProcessor的名称
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
//priorityOrdered级别的BeanPostProcessor
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
//Ordered级别的BeanPostProcessor
List<String> orderedPostProcessorNames = new ArrayList<>();
//未实现Ordered级别的BeanPostProcessor
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
//匹配实现PriorityOrdered接口的BeanPostProcessor
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//getBean若获取不到则会创建bean
//故首次此处创建BeanPostProcessor
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
//判断是否为MergedBeanDefinitionPostProcessor类型
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
//匹配实现Ordered接口的BeanPostProcessor
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {//剩余未实现Ordered级别的BeanPostProcessor
nonOrderedPostProcessorNames.add(ppName);
}
}
//priorityOrdered级别的BeanPostProcessor排序，数字越小优先级越高
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
//按顺序添加至beanPostProcessors中
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
//...相同的逻辑处理Ordered级别和未实现Ordered级别的BeanPostProcessor
}
registerBeanPostProcessors添加BeanPostProcessor至beanPostProcessors
private static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
//循环列表中所有的BeanPostProcessor
//添加到beanFactory的beanPostProcessors中
for (BeanPostProcessor postProcessor : postProcessors) {
beanFactory.addBeanPostProcessor(postProcessor);
}
}
说明下：spring中很多地方需要对接口等进行排序，如此处的BeanPostProcessor，还有BeanFactoryPostProcessor等，因为最终循环执行的时候需要按照优先级执行。
spring中一般都按照PriorityOrdered>Ordered>none的优先级
看下AutowiredAnnotationBeanPostProcessor的初始化方法，将@Autowried、@Value或javax.inject.Inject包下的注解添加到自动注入的类型中，以便后续使用扫描数据，此处可以表明@Autowired注解最后会被AutowiredAnnotationBeanPostProcessor处理。
public AutowiredAnnotationBeanPostProcessor() {
this.autowiredAnnotationTypes.add(Autowired.class);
this.autowiredAnnotationTypes.add(Value.class);
try {
this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
}
catch (ClassNotFoundException ex) {
}
}
总结：上述源码主要创建BeanPostProcessor，并按照优先级排序后放入beanPostProcessors中。
加载自定义bean
首先看下调用链：
AbstractApplicationContext.refresh()
-> finishBeanFactoryInitialization()
->DefaultListableBeanFactory.preInstantiateSingletons
->AbstractBeanFactory.getBean -> doGetBean
->AbstractAutowireCapableBeanFactory.createBean
-> doCreateBean ->populateBean
继续看下AutowiredAnnotationBeanPostProcessor类图，继承于InstantiationAwareBeanPostProcessor
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
boolean continueWithPropertyPopulation = true;
//用来判断你的bean需不需要完成属性填充
//AutowiredAnnotationBeanPostProcessor会继续走下面逻辑
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//AutowiredAnnotationBeanPostProcessor父类
//InstantiationAwareBeanPostProcessorAdapter
//postProcessAfterInstantiation方法true
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
if (!continueWithPropertyPopulation) {
return;
}
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
//注解或@Bean中 autowire= “byType”/“byName”此处处理
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
//存在InstantiationAwareBeanPostProcessor类型的返回true
//AutowiredAnnotationBeanPostProcessor继承，故true
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
//循环执行所有InstantiationAwareBeanPostProcessor
//故会执行AutowiredAnnotationBeanPostProcessor
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//执行postProcessProperties方法，返回属性值
//最终赋值给pvs
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;
}
}
}
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
checkDependencies(beanName, mbd, filteredPds, pvs);
}
//反射赋值，可能多个属性，循环赋值
//有兴趣可自行研究
if (pvs != null) {
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
继续看AutowiredAnnotationBeanPostProcessor.postProcessProperties源码
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
//配置@Autowried、@Value或javax.inject.Inject包下的注解的方法或属性的对象
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
//调用inject注入propertyValues中
metadata.inject(bean, beanName, pvs);
}
catch (BeanCreationException ex) {
throw ex;
}
catch (Throwable ex) {
}
return pvs;
}
findAutowiringMetadata，作用是寻找配置了@Autowried、@Value或javax.inject.Inject包下的注解的方法或属性
这里有一点需要说明，其实这不是第一次加载这边注解数据，在 AbstractAutowireCapableBeanFactory.doCreateBean() 方法中调用 createBeanInstance 方法实例化数据后就会调用 AutowiredAnnotationBeanPostProcessor.postProcessMergedBeanDefinition() 方法进行解析对应的注解数据并缓存起来。第二次走到 findAutowiringMetadata 方法时，直接从缓存中获取即可。下面逻辑当未跑过此段逻辑，继续流程走。
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
//以beanName作为缓存的key
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
//缓存中根据key取InjectionMetadata
//首次缓存不存在，需刷新
InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
//metadata为空或clazz改变需刷新
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
metadata = buildAutowiringMetadata(clazz);
//放入缓存
this.injectionMetadataCache.put(cacheKey, metadata);
}
}
}
return metadata;
}
buildAutowiringMetadata作用：寻找配置了@Autowried、@Value或javax.inject.Inject包下的注解的方法或属性
private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
Class<?> targetClass = clazz;
do {
//存储当前包含了自动装配注解的元素
final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
//获取包含自动装配注解的
ReflectionUtils.doWithLocalFields(targetClass, field -> {
AnnotationAttributes ann = findAutowiredAnnotation(field);
if (ann != null) {
//判断是否为静态field，存在break
if (Modifier.isStatic(field.getModifiers())) {
return;
}
//获取required属性
boolean required = determineRequiredStatus(ann);
//加入值currElements
currElements.add(new AutowiredFieldElement(field, required));
}
});
//获取包含自动装配注解的方法
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
//静态方法不处理
if (Modifier.isStatic(method.getModifiers())) {
return;
}
boolean required = determineRequiredStatus(ann);
//获取方法入参
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
currElements.add(new AutowiredMethodElement(method, required, pd));
}
});
//都放入elements中
elements.addAll(0, currElements);
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
//构造InjectionMetadata返回
return new InjectionMetadata(clazz, elements);
}
上诉方法已找出所有@Autowired的方法和属性，下面看具体的注入过程
InjectionMetadata.inject
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Collection<InjectedElement> checkedElements = this.checkedElements;
Collection<InjectedElement> elementsToIterate =
(checkedElements != null ? checkedElements : this.injectedElements);
//elementsToIterate不为空，循环处理
if (!elementsToIterate.isEmpty()) {
for (InjectedElement element : elementsToIterate) {
//AutowiredFieldElement.inject()从beanFactory中获取到对应属性bean进行依赖注入
//调用AutowiredMethodElement.inject()从beanFactory中获取到对应入参bean，并执行方法
element.inject(target, beanName, pvs);
}
}
}
InjectedElement是个抽象类，以AutowiredFieldElement为例
@Override
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Field field = (Field) this.member;
Object value;
if (this.cached) {
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
}
else {
DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
desc.setContainingClass(bean.getClass());
Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
Assert.state(beanFactory != null, "No BeanFactory available");
TypeConverter typeConverter = beanFactory.getTypeConverter();
try {
//最终调用beanFactory.getBean(beanName)获取bean
//容器中没有则先创建bean
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
}
catch (BeansException ex) {
}
}
if (value != null) {
//设置field的setAccessible方法为true
ReflectionUtils.makeAccessible(field);
//field属性设置为value
field.set(bean, value);
}
}
总结
狭义的bean生命周期最简单的三步骤：实例化、属性填充、初始化，@Autowired最终处理是在属性填充过程中。
处理步骤：
1、容器初始添加AutowiredAnnotationBeanPostProcessor的BeanDefinition
2、初始化beanfactory后加载所有的BeanPostProcessor
3、加载自定义的bean，实例化后后置处理器AutowiredAnnotationBeanPostProcessor将bean的注解信息缓存，如@Autowired
4、填充属性时用后置处理器判断是否需要填充属性
5、需要填充属性时，后置处理器处理，AutowiredAnnotationBeanPostProcessor，取缓存注解信息
6、将@Autowired的field通过getBean从容器中取出，反射赋值到field中
166
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
