Spring5 @Value @Autowired注入主流程分析

已于 2022-05-27 14:31:29 修改
阅读量260 收藏
点赞数
分类专栏： Spring5 文章标签： java spring boot spring
于 2022-05-26 18:02:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shy_4500/article/details/124989634
版权

版本说明

Spring Boot:【2.4.6】

Spring: 【5.3.7】

主流程

@Vaule，@Autowired为Spring程序提供了DI的能力，这篇文章简要分析下注入的主流程，主要是使用AutowiredAnnotationBeanPostProcessor来做相应的处理。

主要包含的流程是：

  • 准备InjectionMetadata
  • 注入数据
    • 解决依赖

核心的类包括以下几个

  • AutowiredAnnotationBeanPostProcessor

  • InjectionMetadata，InjectionMetadata.InjectedElement，AutowiredFieldElement，AutowiredMethodElement 是InjectedElement子类

何时注册AutowiredAnnotationBeanPostProcessor的beandefination

在实例化AnnotationConfigServletWebServerApplicationContext的时候，注册了bd信息

	public AnnotationConfigServletWebServerApplicationContext() {
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

	// AutowiredAnnotationBeanPostProcessor对应的bean name
	public static final String AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalAutowiredAnnotationProcessor";

	public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}

		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

  	// 注册bd信息  
		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
		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));
		}

		// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
		if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition();
			try {
				def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
						AnnotationConfigUtils.class.getClassLoader()));
			}
			catch (ClassNotFoundException ex) {
				throw new IllegalStateException(
						"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
			}
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
		}

		if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
		}

		return beanDefs;
	}

AutowiredAnnotationBeanPostProcessor的处理

Inject注入发生在bean初始化阶段，初始化第一个步骤是填充属性，populate

AutowiredAnnotationBeanPostProcessor是一个InstantiationAwareBeanPostProcessor，在populate时会被调用

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		// ...
		if (hasInstAwareBpps) {
			if (pvs == null) {
        // 保证不会null
				pvs = mbd.getPropertyValues();
			}
			for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
        // AutowiredAnnotationBeanPostProcessor调用postProcessProperties
				PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
				// ...
			}
		}
		if (pvs != null) {
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}

	@Override
	public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    // 获取InjectionMetadata，没有则构建
		InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
		try {
      // 注入
			metadata.inject(bean, beanName, pvs);
		}
		return pvs;
	}

下面是findAutowiringMetadata，和buildAutowiringMetadata的详细流程，可跳过不看。

从cache查找，如果没有则直接构建

	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.
    // 从cache取
		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);
					}
          // 没有则build
					metadata = buildAutowiringMetadata(clazz);
          // 放进cache
					this.injectionMetadataCache.put(cacheKey, metadata);
				}
			}
		}
		return metadata;
	}

build过程

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

		List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
		Class<?> targetClass = clazz;
		// 从targetClass一直向上找，直到Object
		do {
			final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
			// 找Fields
			ReflectionUtils.doWithLocalFields(targetClass, field -> {
				MergedAnnotation<?> ann = findAutowiredAnnotation(field);
				if (ann != null) {
          // 不支持static field
					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))) {
          // 不支持static method
					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);
	}

这里以AutowiredFieldElement举例

// 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) {
        // 从cache找
				try {
					value = resolvedCachedArgument(beanName, this.cachedFieldValue);
				}
				catch (NoSuchBeanDefinitionException ex) {
					// Unexpected removal of target bean for cached argument -> re-resolve
					value = resolveFieldValue(field, bean, beanName);
				}
			}
			else {
        // cache中没有，处理依赖，使用BeanFactory去嵌套的getBean
				value = resolveFieldValue(field, bean, beanName);
			}
			if (value != null) {
				ReflectionUtils.makeAccessible(field);
        // 最终给字段赋值
				field.set(bean, value);
			}
		}

打个断点，直接查看是如何调用的，线程栈如下

从下往上看

"main@1" prio=5 tid=0x1 nid=NA runnable
  java.lang.Thread.State: RUNNABLE
  	# 直到所有嵌套的都被处理，才能决议当前要注入的value。。。
	  at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.resolveFieldValue(AutowiredAnnotationBeanPostProcessor.java:650)
	  at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:640)
	  at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:119)
	  at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessProperties(AutowiredAnnotationBeanPostProcessor.java:399)
	  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1413)
	  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:601)
	  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:524)
	  at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:335)
	  at org.springframework.beans.factory.support.AbstractBeanFactory$$Lambda$219.172699023.getObject(Unknown Source:-1)
	  at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:234)
	  - locked <0x15a5> (a java.util.concurrent.ConcurrentHashMap)
	  at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:333)
	  at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:208)
	  at org.springframework.beans.factory.config.DependencyDescriptor.resolveCandidate(DependencyDescriptor.java:276)
	  at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:1380)
	  # DefaultListableBeanFactory.resolveDependency 处理依赖
	  at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:1300)
	  # 直到所有嵌套的都被处理，才能决议当前要注入的value。。。构成一个递归的点
	  at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.resolveFieldValue(AutowiredAnnotationBeanPostProcessor.java:657)
	  # 字段类型或者方法类型(AutowiredMethodElement)去注入
	  at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:640)
	  # 注入属性
	  at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:119)
	  # 发现InjectionMetadata，没有就构建
	  at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessProperties(AutowiredAnnotationBeanPostProcessor.java:399)
	  # 初始化前重要方法，populateBean 填充属性
	  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1413)
	  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:601)
	  at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:524)
	  at org.springframework.beans.factory.support.AbstractBeanFactory.lambda$doGetBean$0(AbstractBeanFactory.java:335)
	  at org.springframework.beans.factory.support.AbstractBeanFactory$$Lambda$219.172699023.getObject(Unknown Source:-1)
	  at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:234)
	  at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:333)
	  # BeanFactory的getBean流程
	  at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:208)
	  at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:944)
	  # 实例化所有剩余的singletons
	  at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:918)
	  # AbstractApplicationContext#refresh核心流程
	  at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:583)
	  - locked <0x1290> (a java.lang.Object)
	  at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.refresh(ServletWebServerApplicationContext.java:144)
	  at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:771)
	  at org.springframework.boot.SpringApplication.refresh(SpringApplication.java:763)
	  at org.springframework.boot.SpringApplication.refreshContext(SpringApplication.java:438)
	  at org.springframework.boot.SpringApplication.run(SpringApplication.java:339)
	  at org.springframework.boot.SpringApplication.run(SpringApplication.java:1329)
	  at org.springframework.boot.SpringApplication.run(SpringApplication.java:1318)
	  # 程序main入口
	  at com.hongyi.demo.SimpleWebApplication.main(SimpleWebApplication.java:10)

xk-cap
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring源码解析 --AutowiredAnnotationBeanPostProcessor
m0_47039719的博客
03-26 1089
bean实例化时会处理其属性值，其中有一步是对标注了@Autowire的字段进行解析， 较为复杂的是对于方法上标记了@Autowire 在对象实例化后，在doCreateBean中会调用 AutowiredAnnotationBeanPostProcessor实现了MergedBeanDefinitionPostProcessor AutowiredAnnotationBeanPostProcessor#postProcessMergedBeanDefinitio...
Spring源码分析（三）依赖注入之AutowiredAnnotationBeanPostProcessor
caicongyang
01-24 685
Spring源码分析（三）依赖注入之AutowiredAnnotationBeanPostProcessor
Spring的Bean后置处理器之AutowiredAnnotationBeanPostProcessor
Silence的博客
11-07 1261
本文能帮你解答的问题 @Autowired注解是如何完成属性自动注入的？ 如何改变bean实例化构造函数的选择？ @Aut...
Spring源码导读之AutowiredAnnotationBeanPostProcessor
lightj1996的博客
07-22 279
通过构造函数注入 案例 为构造函数加加@Autowire注解，希望Spring通过注解的形式将其注入。 DemoDomainService public class DemoDomainService { private DemoWriteService demoWriteService; @Autowired public DemoDomainService(DemoWriteService demoWriteService) { this....
Spring5：@Autowired注解、@Resource注解和@Service注解
Trival_dreamy的博客
11-15 149
什么是注解 传统的Spring做法是使用.xml文件来对bean进行注入或者是配置aop、事物，这么做有两个缺点： 1、如果所有的内容都配置在.xml文件中，那么.xml文件将会十分庞大；如果按需求分开.xml文件，那么.xml文件又会非常多。总之这将导致配置文件的可读性与可维护性变得很低 2、在开发中在.java文件和.xml文件之间不断切换，是一件麻烦的事，同时这种思维上的不连贯也会降低...
Spring核心注解深入解析：提升开发效率
12-13
@Autowired 注解用于自动注入依赖，它可以放置在字段、构造器、setter方法或其他任何方法上，Spring容器会自动寻找并注入正确的bean。 @Configuration 和 @Bean 注解用于Java配置，允许开发者用程序的方式定义Spring...
Spring Boot最常用的30个注解.docx
最新发布
04-23
详细介绍了Spring Boot最常用的30个注解，包含概念、原理、示例 Spring Boot最常用的30个注解 一、 @SpringBootApplication 二、 Spring Bean 相关 1 @Controller 2 @Service 3 @Repository 4 @Component 5 @Bean 6 ...
spring4框架系列 [ 5 ]
01-19
spring4框架系列 [ 5 ] 基于注释注入@Component @Value @Resource @Autowired @PostConstruct @PreDestroy
Spring.html
03-23
Spring IOC 控制反转:把创建对象的权利交给Spring 创建对象 1.无参构造 2.静态工厂 3.实例工厂 管理对象 对象关系DI 构造器注入 set注入 生命周期 scope:prototype/singleton init-...
spring杂谈 作者zhang KaiTao
10-17
1.30 Shiro+Struts2+Spring3 加上@RequiresPermissions 后@Autowired失效 1.31 Spring事务不起作用 问题汇总 1.32 Spring3 Web MVC下的数据类型转换（第一篇）——《跟我学Spring3 Web MVC》抢先看 1.33 Spring 注入...
Spring5源码解析-@Autowired
qq_36879870的博客
04-22 340
@Autowired所具有的功能 @Autowired是一个用来执行依赖注入的注解。每当一个Spring管理的bean发现有这个注解时候，它会直接注入相应的另一个Spring管理的bean。 该注解可以在不同的层次上应用: 类字段:Spring将通过扫描自定义的packages(例如在我们所注解的controllers)或通过在配置文件中直接查找bean。 方法:使用@Autowired注解的每...
Autowired注解源码解析
zhangshenglu1的博客
02-10 1807
我们都知道一个Bean的大致生命周期有这几个阶段，实例化--> 属性填充 --> 初始化 --> 销毁回调其中Autowired作用的时间就是在属性填充阶段，而且是通过AutowiredAnnotation BeanPostProcessor类进行处理的。
@Autowire源码分析，@Autowire是怎么实现依赖注入的
秃了也弱了
02-13 2158
我们经常用@Autowire，那@Autowire是怎么实现自动注入的呢？一起分析源码看看吧！
Spring源码分析衍生篇五：AutowiredAnnotationBeanPostProcessor
猫吻鱼的博客
05-29 8471
文章目录一、前言二、AutowiredAnnotationBeanPostProcessor三、determineCandidateConstructors四、postProcessProperties & postProcessPropertyValues1. findAutowiringMetadata 一、前言 本文是 Spring源码分析：单例bean的获取 - createBean 的衍生文章。主要是因为本人菜鸡，在分析源码的过程中还有一些其他的内容不理解，故开设衍生篇来完善内容以学习。
Autowired注解分析(AutowiredAnnotationBeanPostProcessor)
香酥蟹的博客
07-06 393
AutowiredAnnotationBeanPostProcessor如何注入容器 SpringApplication protected ConfigurableApplicationContext createApplicationContext() { ... return (ConfigurableApplicationContext) BeanUtils.instantiate(contextClass); } AnnotationConfigApplicationContext publ
Spring @Autowired 属性注入过程分析
知识不加糖的分享圈
12-16 1061
@Autowired 到底是如何进行属性注入的，为什么会发生 bean 冲突，按类型注入是什么鬼？
SpringFramework之AutowiredAnnotationBeanPostProcessor
weixin_45594127的博客
10-17 754
org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor
spring源码讲解支线任务——AutowiredAnnotationBeanPostProcessor
欢迎光临雨落星辰的博客
02-22 170
spring源码讲解支线任务——AutowiredAnnotationBeanPostProcessor。
一文搞懂Spring @Autowired注解的使用及其原理
热门推荐
MarkusZhang的博客
02-12 1万+
依赖注入（DI）是Spring核心特性之一，而@Autowired也是我们日常高频使用的Spring依赖注入方式之一，因此有必要对它的使用以及原理做一个全面的掌握。本文从@Autowired使用、原理入手记录，并扩展延伸Spring中其他具备注入功能的注解。
@Autowired和@Resource和@Value的区别
07-28
@Autowired、@Resource和@Value是Spring框架中用于注入依赖和属性值的注解，它们的区别如下： 1. @Autowired： @Autowired是Spring的核心注解之一，用于自动装配Bean。它可以用于构造方法、属性、方法和参数上。当...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值