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

已于 2022-05-27 14:31:29 修改
阅读量307 收藏
点赞数
分类专栏： 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
关注
专栏目录
Spring Boot进阶(57)：Spring中@Autowired不适用的场景，不要掉进坑里！
**My Coding Family**
07-19 1605
Spring中什么时候不要用@Autowired注入？你若不会我可以教你。
Spring @Resource与@Autowired的加载过程
sincehl的博客
11-02 942
一、@Autowired加载过程 以下分析以@Autowired注解在成员属性上使用 1.org.springframework2..beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject2 protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) t
.spring5源码 -- ioc加载的整体流程
java_xiaoo的博客
09-24 568
之前我们知道了spring ioc的加载过程, 具体如下图. 下面我们就来对照下图, 看看ioc加载的源代码. 下面在用装修类比, 看看个个组件都是怎么工作的. 接下来是源码分析的整体结构图. 对照上面的思路梳理出来的 一、源码分析的入口 通常,我们的入口都是从main方法进入. 这里我们也来定义一个main方法 public class MainStarter { public static void main(String[] args) { ...
Spring5 @Autowired
weixin_34101784的博客
03-20 264
为什么80%的码农都做不了架构师？>>> ...
SpringBoot的@Value和@AutoWired自动装配注解源码
qq_51598480的博客
12-21 942
然后这两个方法postProcessMergedBeanDefinition和postProcessProperties都是在Spring容器去拿Bean实例的方法doCreateBean方法中遍历接口实现类调用接口方法调用的，这两个方法都是接口的实现方法，理解到这，懂了，这就是Spring留出的一个很牛逼的扩展点。之后调用该类的postProcessProperties方法为找到的这些需要自动装配的类进行属性值注入。在寻找当前Bean需要自动装配的属性的时候，怎么确定该属性需要自动装配？
Spring populateBean注入属性-@Value @Autowired到底怎么解析的？
paralysed的博客
08-23 580
一些小的知识点 1:beanFactory.getAutowireCandidateResolver() 获取到的对象是什么时候注入的？ private AutowireCandidateResolver autowireCandidateResolver = SimpleAutowireCandidateResolver.INSTANCE; 可以看到默认是初始化了一个 SimpleAutowireCandidateResolver 的实例，但是它并没有重写getSuggestedValue...
Spring注解学习之@Value
russle的专栏
07-07 1086
本系列开始Spring主要注解的介绍。 我们先从@Value开始， @Value和@Configuration和一起使用，读取属性文件。. @Value reads the property file. 属性文件可以通过应用的xml加载。下面的例子中，我们从应用的xml文件获得属性文件，然后通过@Value读取属性值，. 具体代码在这里，欢迎fork，加星，谢谢！ @Configuratio...
详解Spring @Autowired 注入小技巧
08-27
Spring @Autowired 注入小技巧 在 Spring 框架中，@Autowired 注解是用来实现自动依赖注入的。它可以根据类型（Type）进行自动注入，并且默认注入的 bean 为单例（SingleTon）的。下面我们来详解一些 @Autowired ...
详解Spring依赖注入：@Autowired，@Resource和@Inject区别与实现原理
08-25
Spring 依赖注入：@Autowired，@Resource 和@Inject 区别与实现原理 Spring 依赖注入是指在应用程序中将对象之间的依赖关系自动装配的过程。Spring 框架提供了多种依赖注入方式，包括 @Autowired、@Resource 和@...
Spring系列第21篇：注解实现依赖注入（@Autowired、@Resource、@Primary、(1)
最新发布
WJud11的博客
04-18 1156
面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！2个实现类Service1@ComponentService2@Component@Primary。
关于@Value和@Autowired
weixin_43519121的博客
09-18 761
关于@Value和@Autowired ConfigurationClassPostProcessor ConfigurationClassParser ConfigurationClassBeanDefinitionReader 一切的一切又得回到Spring中大多数bean的起点ConfigurationClassPostProcessor，ConfigurationClassPostProcessor实现了BeanDefinitionRegistryPostProcessor接口。我们在Sprin
Spring注解开发5 --- Bean属性赋值 @Value @PropertySource
Visonws的博客
09-22 1462
1.使用@Value给属性字段赋值 直接赋值基本数据 可以写SpEL ，#{} 可以写${},取出配置文件（properties文件）中的值（在运行变量中的值） 和之前在xml配置相似 1.1 前两种的使用例子： 对象类： @Data @Builder @AllArgsConstructor @NoArgsConstructor public class User { @...
Spring5：@Autowired注解、@Resource注解和@Service注解
Trival_dreamy的博客
11-15 171
什么是注解 传统的Spring做法是使用.xml文件来对bean进行注入或者是配置aop、事物，这么做有两个缺点： 1、如果所有的内容都配置在.xml文件中，那么.xml文件将会十分庞大；如果按需求分开.xml文件，那么.xml文件又会非常多。总之这将导致配置文件的可读性与可维护性变得很低 2、在开发中在.java文件和.xml文件之间不断切换，是一件麻烦的事，同时这种思维上的不连贯也会降低...
Spring5源码解析-@Autowired
qq_36879870的博客
04-22 377
@Autowired所具有的功能 @Autowired是一个用来执行依赖注入的注解。每当一个Spring管理的bean发现有这个注解时候，它会直接注入相应的另一个Spring管理的bean。 该注解可以在不同的层次上应用: 类字段:Spring将通过扫描自定义的packages(例如在我们所注解的controllers)或通过在配置文件中直接查找bean。 方法:使用@Autowired注解的每...
Spring5外部化配置(@Value,@PropertySource)示例
qq_34466889的博客
11-17 409
Spring 允许外部化你的配置，这样你就可以在不同的环境中使用相同的应用程序代码，你可以使用properties文件、YAML文件、环境变量和命令行参数来外部化配置，属性值可以通过使用@Value注解直接注入到你的bean中，通过@Configuration,@PropertySource绑定到结构化对象。 import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annot
关于@Value和@Autowired的问题解决
Z242877的博客
02-04 495
1.@Value取不到Application.yml中值问题： 1.1：@Value是属于在容器当中，所以想要使用，需要在只用类上面加上容器注解， 比如：@Component ， @Controller ， @Configuration等 2.使用容器注入中的对象时，比如上图中的OssUtil类注意！！！！ ![在这里插入图片描述](https://img-blog.csdnimg.cn/20210204155810644.png) 需要使用@Autowired注解或者@Resource注入 ，切记不能
@Autowire/@Value注解实现
u013015681的博客
09-01 290
在Spring中，autowire注解的功能主要是通过AutowiredAnnotationBeanPostProcessor类来实现的，AutowiredAnnotationBeanPostProcessor类本身会通过xml标签"context:annotation-config" and "context:component-scan"进行注册，可以去掉或者管理默认的注解配置，如果你希望去声明一个个性化的AutowiredAnnotationBeanPostProcessor bean...
使用@Value和@Autowired注入的参数放到static方法中
lixinze的博客
05-23 419
项目需求我需要封装一个发消息的公共工具类在封装过程中遇到几个有趣的问题 发送消息使用的自己公司的消息推送系统，身份验证需要用app_id和app_secret换取token，产品要求把所有账号密码请求的地址都放到配置文件中。由于@Value不能给到静态变量注入，刚开始封的方法是这样的 //获取 tenant_access_token（企业自建应用） public static String getTenantAccessToken(String app_id,String app_secret,S
spring中依赖注入@Value和@Autowired的使用
qq_27579471的博客
01-29 3445
可以写在何处 @Value可以写在变量、方法（包括构造方法）入参、只有一个参数的方法（包括构造方法）上 @Autowired可以写在变量、方法（包括构造方法）上 在spring4.x中新增了新的特性：如果类只提供了一个带参数的构造方法，则不需要对其内部的属性写@Autowired注解，spring会自动为你注入属性；配合lombok的@RequiredArgsConstructor使用体验很好。 @Value与@Autowired混合使用 执行到有@Autowired的构造方法时: 执行到有@Po
深入解析Spring @Autowired的内部工作机制
这篇文章通过分析Spring源码，揭示了@Autowired注解如何在背后与BeanPostProcessor协作，确保对象的自动装配和依赖注入。对于希望深入了解Spring内部机制的开发者来说，这篇分析提供了宝贵的见解，有助于提升对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值