Spring @Autowired源码解析

最新推荐文章于 2024-09-30 14:38:42 发布
最新推荐文章于 2024-09-30 14:38:42 发布
阅读量641 收藏
点赞数
分类专栏： spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hj95815/article/details/117790260
版权

@Autowired可用于属性，方法，构造函数之上

  1. 当注解于属性时，其首先根据属性的类型去匹配，如果匹配到多个相同类型的bean则根据属性名称去匹配，还可通过@Primary注解和@Qualifier等注解进行辅助匹配。
  2. 当注解于构造方法时，当没有构造方法或有多个构造方法时，spring默认采用无参构造方法进行初始化，如果没有无参构造方法且有多个不同且没有标注@Autowired的构造方法，则会抛出异常无法进行初始话。若指定了一个构造方法有@Autowired注解，则根据指定构造方法中的参数的类型去找，如果多个则根据名称匹配，找到最终匹配的则进行初始化。
  3. 当注解于方法时，根据方法中的参数类型去容器中查找对应的bean，如果匹配到多个则根据属性名称匹配，匹配成功会调用该方法。不同于@Resource注解，该注解时先根据类型匹配，然后根据方法如setXXX中的XXX用名称去匹配，最后根据属性名称去匹配，匹配成功则进行方法的调用。

源码解析：

  •  进行注入点的查找并存入属性injectionMetadataCache的Map中。
    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean方法中的applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName)方法通过调用实现了MergedBeanDefinitionPostProcessor接口的org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#postProcessMergedBeanDefinition方法，如下
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
		InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
		metadata.checkConfigMembers(beanDefinition);
	}

         进行注入点的查找，并存入injectionMetadataCache的Map中，该map的value为InjectionMetadata类型，包含了注入的元数据信息。

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.
		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;
	}
buildAutowiringMetadata方法如下，其中有一个 do...while targetClass = targetClass.getSuperclass(); 的操作会将父类标注了@Autowired和@Value的属性或者方法进行属性填充。
因此父类可以不用@Component等注解就可进行属性填充。

 

private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
		if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
			return InjectionMetadata.EMPTY;
		}

		List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
		Class<?> targetClass = clazz;

		do {
			final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();

			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;
					}
					boolean required = determineRequiredStatus(ann);
					currElements.add(new AutowiredFieldElement(field, required));
				}
			});

			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;
					}
					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 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);
			}
		}
	}

与@Autowired和@Value进行匹配查找的方法如下：

private MergedAnnotation<?> findAutowiredAnnotation(AccessibleObject ao) {
		MergedAnnotations annotations = MergedAnnotations.from(ao);
		for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
			MergedAnnotation<?> annotation = annotations.get(type);
			if (annotation.isPresent()) {
				return annotation;
			}
		}
		return null;
	}
this.autowiredAnnotationTypes值的初始话在构造方法中进行，如下：

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.trace("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
		}
		catch (ClassNotFoundException ex) {
			// JSR-330 API not available - simply skip.
		}
	}
  • 进行属性的属性填充

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean

该方法会遍历InstantiationAwareBeanPostProcessor类型的bean，并调用该接口实现类的postProcessPropertyValues方法，

@Autowired注解对应的实现类方法为AutowiredAnnotationBeanPostProcessor.postProcessProperties

@Resource注解对应的实现类为org.springframework.context.annotation.CommonAnnotationBeanPostProcessor#postProcessProperties。类图如下：

postProcessProperties代码如下

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;
	}
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);
		if (!elementsToIterate.isEmpty()) {
			for (InjectedElement element : elementsToIterate) {
				if (logger.isTraceEnabled()) {
					logger.trace("Processing injected element of bean '" + beanName + "': " + element);
				}
				element.inject(target, beanName, pvs);
			}
		}
	}

如果注入点的类型是属性则会调用AutowiredFieldElement内部类的inject方法。

org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject方法，代码如下

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 {
                     //获取注入属性的值
					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注解可用表达式，如“${”开头的占位符表达式，和“#{”开头的EL表达式。

（1）@Value("${}")：可以获取对应属性文件中定义的属性值。

（2）@Value("#{}")：表示 SpEl 表达式通常用来获取 bean 的属性，或者调用 bean 的某个方法。org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveDependency方法如下

public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

		descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
		if (Optional.class == descriptor.getDependencyType()) {
			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 {
			Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
					descriptor, requestingBeanName);
			if (result == null) {
				result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
			}
			return result;
		}
	}

 

public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

		InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
		try {
			Object shortcut = descriptor.resolveShortcut(this);
			if (shortcut != null) {
				return shortcut;
			}

			Class<?> type = descriptor.getDependencyType();
            //对@Value注解做特殊的处理
			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()));
				}
			}

            //如果属性的类型是集合类型
			Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
			if (multipleBeans != null) {
				return multipleBeans;
			}

            //查找匹配的候选的注入结果值
			Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
			if (matchingBeans.isEmpty()) {
				if (isRequired(descriptor)) {
					raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
				}
				return null;
			}

			String autowiredBeanName;
			Object instanceCandidate;

			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<String, Object> entry = matchingBeans.entrySet().iterator().next();
				autowiredBeanName = entry.getKey();
				instanceCandidate = entry.getValue();
			}

			if (autowiredBeanNames != null) {
				autowiredBeanNames.add(autowiredBeanName);
			}
			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);
		}
	}
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);对@Value注解做特殊的处理。

Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);如果对集合属性的属性注入的处理。

Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);获取候选的匹配的Bean.

如果有多个匹配的bean则进行determineAutowireCandidate方法获取最终匹配的bean 

protected String determineAutowireCandidate(Map<String, Object> candidates, DependencyDescriptor descriptor) {
		Class<?> requiredType = descriptor.getDependencyType();
		String primaryCandidate = determinePrimaryCandidate(candidates, requiredType);
		if (primaryCandidate != null) {
			return primaryCandidate;
		}
		String priorityCandidate = determineHighestPriorityCandidate(candidates, requiredType);
		if (priorityCandidate != null) {
			return priorityCandidate;
		}
		// Fallback
		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;
	}

首先根据@Primary注解的主类bean进行匹配，没有则根据优先级@Priority进行匹配最终找到对应的结果进行属性填充

if (value != null) {
   ReflectionUtils.makeAccessible(field);
   field.set(bean, value);
}

 

奈文杰
关注
专栏目录
spring@Autowired源码解析
phhong的专栏
06-24 178
参考：https://www.cnblogs.com/youzhibing/p/11031216.html protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException { // Instantiate the bean. BeanWrapper i.
Spring @Autowired注解解析
暴躁兔子的记录
04-28 1047
前言 在我们学习 spring 的时候，尤其是使用注解的方式实现自动装配，总会感到很神奇，也产生了很多的疑问。 注解是什么时候被解析的？ 注解的生效逻辑是什么？ 以@Autowired 为例，为什么加了这个直接就可以直接得到对应的属性实例，并调用它的方法呢？ 我们越学感觉到疑问越多，而光看源码又容易被带偏，总是一个问题深入研究下去就找不到回来的路了。 本文试着从问题的角度出发，边看源码边解答这...
java web中spring自动注入autowired极度精简版源代码
10-11
java web开中spring在autowired自动注入极度精简版本，绝对可以运行。博客地址： http://blog.csdn.net/qq5132834/article/details/47870351
Spring系列之@Autowired源码解析
zhao6406879的博客
02-03 1395
11
springboot源码阅读--@autowired注解源码解析
最新发布
qq_41858137的博客
09-30 804
springboot注解源码解析
spring 中@Autowired源码解析
坑里水库的博客
10-10 1020
使用过@Autowired的都应该知道，这个注解是手动注入依赖对象的，并且先通过bean类型去查找然后再根据属性名去查找 准备4个类： 1 Dao 接口 2 IndexDao 测试类 3 IndexDao2 实现了Dao接口 4 IndexDao3类实现了Dao接口 public class IndexDao { @Autowire Dao dao； } 这样spr...
Spring @Autowire 源码分析
qq_44851477的博客
07-29 252
Autowire注解是由AutowiredAnnotationBeanPostProcessor处理器来实现的。@Autowired注解正是通过这个方法实现注入类型的预解析，将需要依赖注入的属性信息封装到InjectionMetadata类中。，InjectionMetadata类中包含了需要注入的元素(injectedElements)及元素要注入的目标类(tagetClass)。然后其最终会调用doCreateBean方法中，其中会执行populateBean方法实现对属性的注入。...
（转）Spring中@Autowired注解和@Resource注解的区别
08-11
通过源码分析，我们可以了解到Spring如何解析这些注解并执行依赖注入的过程，这有助于我们更好地理解和利用Spring框架。同时，结合工具如IDEA的代码提示和重构功能，可以更高效地运用这些注解进行开发。
Spring @Autowired
04-02
源码解析 `@Autowired`注解的实现涉及到Spring的核心组件——`BeanFactory`和`ApplicationContext`。当遇到`@Autowired`注解时，Spring会通过`AutowiredAnnotationBeanPostProcessor`进行处理，它实现了`...
两个原因导致Spring @Autowired注入的组件为空
java100001的博客
05-06 1224
@Controller public class Controller { @GetMapping(“/example”) public String example() { MyService my = new MyService(); my.doStuff(); } } @Service public class MyService() { @Autowired MyRepository repo; public void doStuff() { repo.findByName( “steve” );
Spring中@Autowired注解的工作原理
m0_67393157的博客
08-02 446
Autowired注解大家再熟悉不过了，在项目中使用@Autowired注解的比例非常高，可以说基本用过Spring的同学都接触过这个注解，因此，我们有必要详细了解一下其工作原理。@Autowired注解的作用是帮我们注入我们需要的对象，Spring会自动按照类型注入，只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以注入成功。在分析这个注解的实现原理之前，我们不妨先来回顾一下@Autowired注解的用法。找出需要自动装配的元素httpshttpshttps。...
spring源码16: @Autowired实现原理
12-22
在阅读本篇之前，如果对后置处理器还不够熟悉的先参考下spring BeanPostProcessor 生命周期 @Autowired使用 构造函数注入 public Class Outer { private Inner inner; @Autowired public Outer(Inner inner) { this.inner = inner; } } 属性注入 public Class Outer { @Autowired private Inner inner; } 方法注入 public Class Outer { private Inner inner;
Spring的Autowired自动装配(XML版本+Annotation版本+源码+解析)
04-08
NULL 博文链接：https://moshow.iteye.com/blog/1607718
Spring5源码解析-@Autowired
qq_36879870的博客
04-22 377
@Autowired所具有的功能 @Autowired是一个用来执行依赖注入的注解。每当一个Spring管理的bean发现有这个注解时候，它会直接注入相应的另一个Spring管理的bean。 该注解可以在不同的层次上应用: 类字段:Spring将通过扫描自定义的packages(例如在我们所注解的controllers)或通过在配置文件中直接查找bean。 方法:使用@Autowired注解的每...
Spring IOC原理源码解析(@Autowired原理详解 ：标识构造函数)（一 ）
点滴之积
11-06 4298
@Autowired标识构造函数，指定实例化Bean时使用哪个构造函数，而不是使用默认的构造函数，同时在实例化时对此构造函数涉及的属性赋值
【spring源码分析】@Autowired的使用以及分析
lzq2357639195的博客
12-13 1205
spring源码分析，@Autowired的使用以及分析
Spring注解@Autowired源码分析
wanghao112956的博客
10-11 478
AutowiredAnnotationBeanPostProcessor是Spring的后置处理器，专门处理@Autowired和@Value注解。 一、触发方式 Spring容器在每个Bean实例化之后，调用AutowiredAnnotationBeanPostProcessor的postProcessMergedBeanDefinition方法。 Spring在每个Bean实例化的时候，...
7、Spring源码之@Autowired
u014647223的专栏
02-01 183
Spring源码之@Autowired源码
深入解析Spring @Autowired的内部工作机制
这篇文章通过分析Spring源码，揭示了@Autowired注解如何在背后与BeanPostProcessor协作，确保对象的自动装配和依赖注入。对于希望深入了解Spring内部机制的开发者来说，这篇分析提供了宝贵的见解，有助于提升对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值