从Spring源码角度看@Autowired（上篇）

最新推荐文章于 2022-06-12 11:44:02 发布
最新推荐文章于 2022-06-12 11:44:02 发布
阅读量515 收藏
点赞数
分类专栏： spring源码 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A1318066232/article/details/105884796
版权

从源码角度看@Autowired

@Autowired注解的源码

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {

	/**
	 * Declares whether the annotated dependency is required.
	 * <p>Defaults to {@code true}.
	 */
	boolean required() default true;

}
  • @Autowired只有一个属性 required，其默认值为true
  • 从@Target上看，其可以用在构造方法上、方法上、参数上、字段上、注解类型上
  • 从@Retention上看，其可以在运行期生效

处理@Autowired注解的后置处理器

  • 注：此处的后置处理器是将@Autowired修饰的属性或方法参数信息处理后赋值给RootBeanDefinition
  • AutowiredAnnotationBeanPostProcessor
public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter
	implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {}
  • 可以看到其实现了MergedBeanDefinitionPostProcessor

给@Autowired修饰的属性或方法上的参数赋值的后置处理器

  • CommonAnnotationBeanPostProcessor
public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
	implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {}
  • 可以看到其实现了InstantiationAwareBeanPostProcessor

处理@Autowired的整个流程

上篇：将@Autowired修饰的属性和方法以InjectedElement形式添加到RootBeanDefinition中的externallyManagedConfigMembers属性中

org.springframework.beans.factory.support.RootBeanDefinition{
    Set<Member> externallyManagedConfigMembers;
}
1. 调用此后置处理器的入口

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors 这个方法会在bean实例化之后，属性未填充之前调用

// 这里AutowiredAnnotationBeanPostProcessor实现了MergedBeanDefinitionPostProcessor接口
// 所以将执行bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
	for (BeanPostProcessor bp : getBeanPostProcessors()) {
		if (bp instanceof MergedBeanDefinitionPostProcessor) {
			MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
			bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
		}
	}
}
// 这里的getBeanPostProcessor() 方法一共会获取7个[在没有自定义的BeanPostProcessor情况下]，分别是
// 1. ApplicationContextAwareProcessor
// 2. ConfigurationClassPostProcessor$ImortAwareBeanPostProcessor
// 3. PostProcessorRegistrationDelegate$BeanPostProcessorChecker
// 4. CommonAnnotationBeanPostProcessor
// 5. AutowiredAnnotationBeanPostProcessor
// 6. RequiredAnnotationBeanPostProcessor
// 7. ApplicationListenerDetector
2. 执行postProcessMergedBeanDefinition方法

org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#postProcessMergedBeanDefinition

@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
    // 判断该bean的类型中是否有需要注入的元属性
	InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
	// 检查是否已注入
	metadata.checkConfigMembers(beanDefinition);
}
3. 执行findAutowiringMetadata方法获取类中的需要注入的元属性

org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#findAutowiringMetadata

private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
	// Fall back to class name as cache key, for backwards compatibility with custom callers.
	String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
	// Quick check on the concurrent map first, with minimal locking.
	
	// 首先从injectionMetadataCache中获取该bean的需要注入的元数据信息
	// 如果获取不到则重新构建，这里利用了双检锁的方式判断是否需要needsRefresh
	// Map<String, InjectionMetadata> injectionMetadataCache; key为bean的名字，value为需要注入的元数据
	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;
}
4.构建需要注入的元数据

org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#buildAutowiringMetadata

private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
    // 存放所有需要注入的元数据列表
	List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
	Class<?> targetClass = clazz;

	do {
		final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
        // 判断目标类的属性上是否有@Autowired修饰的属性
		ReflectionUtils.doWithLocalFields(targetClass, field -> {
			AnnotationAttributes ann = findAutowiredAnnotation(field);
			if (ann != null) {
			    // 判断该字段的修饰符是否是static，如果是静态的则无法注入并打印日志
			    // field.getModifiers() 获取的就是类的修饰符，是一个int值，具体可百度此方法
				if (Modifier.isStatic(field.getModifiers())) {
					if (logger.isWarnEnabled()) {
						logger.warn("Autowired annotation is not supported on static fields: " + field);
					}
					return;
				}
				boolean required = determineRequiredStatus(ann);
				currElements.add(new AutowiredFieldElement(field, required));
			}
		});

        // 判断目标类的方法上是否有@Autowired修饰的方法
		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())) {
					if (logger.isWarnEnabled()) {
						logger.warn("Autowired annotation is not supported on static methods: " + method);
					}
					return;
				}
				// 判断方法的参数是否是0个，如果是0个则也无法注入且打印日志
				if (method.getParameterCount() == 0) {
					if (logger.isWarnEnabled()) {
						logger.warn("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 new InjectionMetadata(clazz, elements);
}
4-0 获取Autowired注解的注解属性

org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#findAutowiredAnnotation

private AnnotationAttributes findAutowiredAnnotation(AccessibleObject ao) {
	if (ao.getAnnotations().length > 0) {
	    // autowiredAnnotationTypes 是一个成员属性，用来存放可以解析的注解类型
	    // Set<Class<? extends Annotation>> autowiredAnnotationTypes = new LinkedHashSet<>();
		for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
			AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ao, type);
			if (attributes != null) {
				return attributes;
			}
		}
	}
	return null;
}

// 下面的是可以解析的注解类型，可忽略
// 可以看到其在无参构造方法中增加了@Autowired、@Value注解，如果支持JSR-303的@Inject注解的话，也会将其加上
// @Value注解主要是用来获取properties、yaml、环境中的值，如"#{systemProperties.myProp}"
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()));
		logger.info("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
	}
	catch (ClassNotFoundException ex) {
		// JSR-330 API not available - simply skip.
	}
}
4-1 ReflectionUtils.doWithLocalFields 对类中的所有属性做一些操作

org.springframework.util.ReflectionUtils#doWithLocalFields

public static void doWithLocalFields(Class<?> clazz, FieldCallback fc) {
	for (Field field : getDeclaredFields(clazz)) {
		try {
			fc.doWith(field);
		}
		catch (IllegalAccessException ex) {
			throw new IllegalStateException("Not allowed to access field '" + field.getName() + "': " + ex);
		}
	}
}

private static Field[] getDeclaredFields(Class<?> clazz) {
	Assert.notNull(clazz, "Class must not be null");
	// declaredFieldsCache 会以类为key，其所有的字段以数组方式作为value存储在map中
	// Map<Class<?>, Field[]> declaredFieldsCache = new ConcurrentReferenceHashMap(256);
	Field[] result = declaredFieldsCache.get(clazz);
	if (result == null) {
		try {
			result = clazz.getDeclaredFields();
			
			declaredFieldsCache.put(clazz, (result.length == 0 ? NO_FIELDS : result));
		}
		catch (Throwable ex) {
			throw new IllegalStateException("Failed to introspect Class [" + clazz.getName() +
					"] from ClassLoader [" + clazz.getClassLoader() + "]", ex);
		}
	}
	return result;
}
4-2 ReflectionUtils.doWithLocalMethods 对类中的方法做一些操作

org.springframework.util.ReflectionUtils#doWithLocalMethods

public static void doWithLocalMethods(Class<?> clazz, MethodCallback mc) {
	Method[] methods = getDeclaredMethods(clazz);
		for (Method method : methods) {
		try {
			mc.doWith(method);
		}
		catch (IllegalAccessException ex) {
			throw new IllegalStateException("Not allowed to access method '" + method.getName() + "': " + ex);
		}
	}
}

private static Method[] getDeclaredMethods(Class<?> clazz) {
	Assert.notNull(clazz, "Class must not be null");
	// declaredMethodsCache 会以类为key，其所有的方法以数组方式作为value存储在map中
	// Map<Class<?>, Method[]> declaredMethodsCache = new ConcurrentReferenceHashMap<>(256);
	Method[] result = declaredMethodsCache.get(clazz);
	if (result == null) {
		try {
			Method[] declaredMethods = clazz.getDeclaredMethods();
			List<Method> defaultMethods = findConcreteMethodsOnInterfaces(clazz);
			if (defaultMethods != null) {
				result = new Method[declaredMethods.length + defaultMethods.size()];
				System.arraycopy(declaredMethods, 0, result, 0, declaredMethods.length);
				int index = declaredMethods.length;
				for (Method defaultMethod : defaultMethods) {
					result[index] = defaultMethod;
					index++;
				}
			}
			else {
				result = declaredMethods;
			}
			declaredMethodsCache.put(clazz, (result.length == 0 ? NO_METHODS : result));
		}
		catch (Throwable ex) {
			throw new IllegalStateException("Failed to introspect Class [" + clazz.getName() +
					"] from ClassLoader [" + clazz.getClassLoader() + "]", ex);
		}
	}
	return result;
}

private static List<Method> findConcreteMethodsOnInterfaces(Class<?> clazz) {
	List<Method> result = null;
	for (Class<?> ifc : clazz.getInterfaces()) {
		for (Method ifcMethod : ifc.getMethods()) {
			if (!Modifier.isAbstract(ifcMethod.getModifiers())) {
				if (result == null) {
					result = new LinkedList<>();
				}
				result.add(ifcMethod);
			}
		}
	}
	return result;
}
4-3 BridgeMethodResolver.findBridgedMethod 判断是否是桥接方法

org.springframework.core.BridgeMethodResolver#findBridgedMethod
具体可参考 JAVA方法中Bridge修饰符，其主要是一个方法修饰符bridge，这个修饰符不是给程序员使用的，而是编译器为了实现泛型而自动产生的

public static Method findBridgedMethod(Method bridgeMethod) {
	if (!bridgeMethod.isBridge()) {
		return bridgeMethod;
	}

	// Gather all methods with matching name and parameter size.
	List<Method> candidateMethods = new ArrayList<>();
	Method[] methods = ReflectionUtils.getAllDeclaredMethods(bridgeMethod.getDeclaringClass());
	for (Method candidateMethod : methods) {
		if (isBridgedCandidateFor(candidateMethod, bridgeMethod)) {
			candidateMethods.add(candidateMethod);
		}
	}

	// Now perform simple quick check.
	if (candidateMethods.size() == 1) {
		return candidateMethods.get(0);
	}

	// Search for candidate match.
	Method bridgedMethod = searchCandidates(candidateMethods, bridgeMethod);
	if (bridgedMethod != null) {
		// Bridged method found...
		return bridgedMethod;
	}
	else {
		// A bridge method was passed in but we couldn't find the bridged method.
		// Let's proceed with the passed-in method and hope for the best...
		return bridgeMethod;
	}
}
  • 到此，已经收集完此类中所有需要注入的属性和方法，并存储于 InjectionMetadata
5. 执行checkConfigMembers完成BeanDefinition中的externallyManagedConfigMembers属性的注入

org.springframework.beans.factory.annotation.InjectionMetadata#checkConfigMembers

public void checkConfigMembers(RootBeanDefinition beanDefinition) {
	Set<InjectedElement> checkedElements = new LinkedHashSet<>(this.injectedElements.size());
	for (InjectedElement element : this.injectedElements) {
		Member member = element.getMember();
		if (!beanDefinition.isExternallyManagedConfigMember(member)) {
		    // 给RootBeanDefinition中添加额外配置
			beanDefinition.registerExternallyManagedConfigMember(member);
			checkedElements.add(element);
			if (logger.isDebugEnabled()) {
				logger.debug("Registered injected element on class [" + this.targetClass.getName() + "]: " + element);
			}
		}
	}
	this.checkedElements = checkedElements;
}
5-1 通过registerExternallyManagedConfigMember给RootBeanDefinition中注册额外配置

org.springframework.beans.factory.support.RootBeanDefinition#registerExternallyManagedConfigMember

public void registerExternallyManagedConfigMember(Member configMember) {
	synchronized (this.postProcessingLock) {
		if (this.externallyManagedConfigMembers == null) {
			this.externallyManagedConfigMembers = new HashSet<>(1);
		}
		this.externallyManagedConfigMembers.add(configMember);
	}
}
冰式的美式
关注
专栏目录
Spring源码解析之@Autowired注解实现原理
MingjaLee's Blog
11-30 713
Spring @Autowired注解实现原理 目录Spring @Autowired注解实现原理前言Demo演示依赖注入bean定义创建Bean的配置类容器启动类输出结果Autowired实现原理(AutowiredAnnotationBeanPostProcessor)AutowiredAnnotationBeanPostProcessor 类结构图References 前言 IOC是Spring的核心功能之一，在日常开发中，我们经常用到@Autowired注解来完成自动装配工作，但它的原理是怎样的呢
Spring源码解读之@Autowired如何解决循环依赖
scientificCommunity的博客
10-22 7264
文章目录@Autowired的what&how什么是循环依赖spring如何解决循环依赖 @Autowired的what&how 在spring框架下，我们可以通过@Autowired注解对属性或者方法参数进行标注，当spring ioc容器初始化时，会帮我们从容器中拿到对应的实例进行注入 什么是循环依赖 加入现在有两个Bean如下所示 public class BeanA { @Autowired private BeanB beanB; } public class B
Spring源码阅读（一）：IOC容器的初始化
码平天下
03-17 159
        一直想研究下当下流行的开源框架的代码，最近年初终于得空了看了下Spring Framework的部分源代码。Spring最核心的功能是IOC容器，其他所有功能都是在此基础上做出的内部扩展，如aop、tx等。         首先先从web工程下经常使用的ContextLoaderListener开始阅读，可以知道Spring bean的创建过程是context-&gt; be...
Spring 注解解析
kkkkk777的博客
08-26 201
AutowiredAnnotationBeanPostProcessor 继承图
java 泛型详解-绝对是对泛型方法讲解最详细的，没有之一
热门推荐
s10461的博客
12-30 61万+
对java的泛型特性的了解仅限于表面的浅浅一层，直到在学习设计模式时发现有不了解的用法，才想起详细的记录一下。 本文参考java 泛型详解、Java中的泛型方法、 java泛型详解 1. 概述泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传
从 Spring 容器取 Service Bean 报错
灵台方寸山斜月三星洞
03-09 368
昨天想写个测试，发现取不到 sevice 的 bean。原因是要取接口class而非实现类class 提个基类，方便从容器取 bean package com.jerryjin.mapper; import org.springframework.context.support.ClassPathXmlApplicationContext; import junit.framework.Test...
springboot中@Autowired 注入失效的四种原因及解决方法
m0_67390969的博客
06-12 1万+
通常是因为被注入的对象没有被spring扫描到，此时需要添加对应的包扫描路径。 2. 需要自动注入的对象不是spring加载，而是new的方式创建 由于对象不是spring创建的，当然spring也就无法根据注解自动注入对应的实例对象。此时可以采用代码的方式，从spring容器中获取对象实例。 3. 需要自动注入的对象不是spring加载，而是采用反射的方式创建 这种情况和第二种情况类似，通常在一些框架调用的时候，采用的对象创建方式，为了避免对spring的依赖，采用类的反射方式进行创建。 4. 使用spr
spring源码16: @Autowired实现原理
12-22
在阅读本篇之前，如果对后置处理器还不够熟悉的先参考下spring BeanPostProcessor 生命周期 @Autowired使用 构造函数注入 public Class Outer { private Inner inner; @Autowired public Outer(Inner inner) { ...
（转）Spring中@Autowired注解和@Resource注解的区别
08-11
在Spring框架中，`@Autowired`和`@Resource`注解是两个常见的依赖注入(DI, Dependency Injection)工具，它们都是用来解决组件之间的耦合问题，使得代码更加灵活和可测试。然而，这两个注解在具体使用时有一些关键性...
spring源码学习---@Autowired 注入源码分析和自定义依赖注入
qq_36697880的博客
07-08 1654
一、简介 众所周知，Spring的依赖注入（DI）对Spring IOC 有着举足轻重的作用，是Spring灵魂所在。本篇文章就从日常开发中最常用的注解@Autowired开始，着手分析Spring是如何通过它们将Bean所需的外部资源注入其中. 1.1、@Autowired 注入规则 @Autowired可以应用在非静态字段、非静态方法、构造器上面注入bean。 1.2、@Autowired 注入过程 元信息解析 依赖查找 依赖注入（字...
实例化Spring bean的两种工厂方法
07-24
通过实例工厂方法和静态工厂方法实例化spring bean的例子。
类集的一些问题
weixin_43573534的博客
08-05 181
1.ArraryList，Vector，LinkedList的区别和关系 三者都是List的接口的常用子类 ArraryList，Vector是基于数组实现的；LinkedList是基于链表实现的 ArraryList采用懒加载策略，扩容为原先数组的1.5倍，采用异步处理，线程不安全，性能较高；在频繁查找或者需要在尾部插入或者删除的时候使用 Vector当产生对象时就初始化内部数组（默认大...
Spring component-scan源码分析（三） -- @Autowired等注解的处理
seasonLai的博客
10-13 446
相关笔记： Spring component-scan源码分析（一） – XML解析 Spring component-scan源码分析（二） – @Configuration注解处理 本篇文章分析注入注解（@Autowired、@Value等）的处理，其逻辑在AutowiredAnnotationBeanPostProcessor类中。 可以看到AutowiredAnnotationBeanP...
Spring 源码之 BeanDefinition阅读
灵小帝的博客
07-01 1万+
Spring容器启动的过程中，会将Bean解析成Spring内部的BeanDefinition结构
解决：Django模型类中没有CharField字段时报错 UserCourse has no field named 'comments'
rusi__的博客
11-21 825
摘要 版本时 python3.65 django 2.1 先看问题代码片 class UserCourse(models.Model): '''用户课程''' user = models.ForeignKey(UserProfile, verbose_name="用户", on_delete=models.CASCADE) course = models.Foreign...
深入理解@Autowired注解以及Spring加载Bean的机制
Nuomizhende45
12-14 1万+
@Autowired注解在平时开发中用的非常的多，即自动装配，这些天碰到了一个与之相关的报错，所以打算深入理解其原理。 首先看看它的定义如下：这里提一下它上面有三个元注解： 1、@Target表示这个注解是作用在什么上，方法上还是类上还是参数上等等。 2、@Rentention 可以理解为这个注解的生命周期，RententionPolicy.SOURCE、RententionPolicy....
ApplicationContext中getBean详解
weixin_30449453的博客
09-04 1279
在org.springframework.context包中有一个接口叫 applicationContext applicationContext中有一个getBean方法，此方法继承之BeanFactory Methods inherited from interface org.springframework.beans.factory.BeanFactory containsBean...
Spring源码分析之注解分析
zxz1580977728的博客
11-24 279
一、通过注解方式加载Spring AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyBeanConfig.class); 二、AnnotationConfigApplicationContext初始化reader和scanner，然后加载bean public AnnotationConfigApplicationContext(Class<?>... annotatedC
泛型擦除，桥接方法介绍
wang0907的博客
10-10 453
1：简答说明 泛型是在jdk5才引入的一种编译前的一种机制，实现了类级别参数的动态传入。 2：方法重载 为了更好的理解泛型擦除，桥接方法，这里我们先看下方法重载。当一个类中的方法签名除了参数类型不同，其它都相同的时候，我们叫做是方法重载。我们先定义如下的类： public class MethodOverload { public void sayHi(Object param) { System.out.println("Object param is: " + param);
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

冰式的美式

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值