springboot之@Autowired注解详解

最新推荐文章于 2024-06-17 15:11:16 发布
最新推荐文章于 2024-06-17 15:11:16 发布
阅读量2.7k 收藏 2
点赞数
文章标签： spring boot java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiaxiaoyan321/article/details/126837834
版权

日常开发中，@Autowired注解我们经常在使用，也会配合其他的注解一起（@Qualifier、@Primary、@lazy）等。
还有就是它跟@Resource的区别在哪里？一定要看到最后！！！
那么它的一个处理流程是怎样的呢？继续看，希望给大家带来对@Autowired注解使用上的一些帮助！

按照一贯的风格，首先给大家一个整体的流程图解
在这里插入图片描述

这里我挑出了8个重要的节点，入口类是AutowiredAnnotationBeanPostProcessor，关于这个类使用场景《springboot ApplicationContext之finishBeanFactoryInitialization(getBean())下》
接下来我们对各个节点进行一个解释

  1. findAutowiringMetadata，这个方法主要是对类进行一个扫描，对字段或者方法存在@Autowired注解进行存储，元素分别对应AutowiredFieldElement、AutowiredMethodElement，扫描的条件，这里列出下关键代码，会忽略带static的字段或方法
//处理字段
ReflectionUtils.doWithLocalFields(targetClass, field -> {
	MergedAnnotation<?> ann = findAutowiredAnnotation(field);
	if (ann != null) {
		//如果是static跳过
		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跳过
		if (Modifier.isStatic(method.getModifiers())) {
			if (logger.isInfoEnabled()) {
				logger.info("Autowired annotation is not supported on static methods: " + method);
			}
			return;
		}
		//如果参数的个数是0 跳过
		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));
	}
});
  1. inject，这个就是开始注入的一个动作，分别调用AutowiredFieldElement、AutowiredMethodElement 的inject方法
  2. resolveDependency，开始进入具体的处理类DefaultListableBeanFactory，这里会对一些具体的类型分别处理，按照顺序依次是：Optional、ObjectFactory || ObjectProvider、带有@lazy注解
	public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

		descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
		//Optional 处理
		if (Optional.class == descriptor.getDependencyType()) {
			//这里会直接走第4个步骤，并把结果存储在Optional中
			return createOptionalDependency(descriptor, requestingBeanName);
		}
		else if (ObjectFactory.class == descriptor.getDependencyType() ||
				ObjectProvider.class == descriptor.getDependencyType()) {
			//返回的类型是包装类型DependencyObjectProvider，在实际调用中获取bean，延迟加载的另外一种处理
			return new DependencyObjectProvider(descriptor, requestingBeanName);
		}
		else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
			return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
		}
		else {
			// @lazy处理，如果返回代理对象就结束流程
			Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
					descriptor, requestingBeanName);
			// 一般的类型，继续
			if (result == null) {
				result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
			}
			return result;
		}
	}
  1. doResolveDependency，这里是对一般类型字段或方法进行处理，分三步：处理@value注解、处理类型是Array、Collection、Map（这里实际上会调用后面5步骤，获取满足条件的类型，然后根据不同的类型进行组装）、普通类型
@Nullable
// 步骤都是一致的，先调用findAutowireCandidates获取满足条件的类型，按照返回类型进行组装进行返回
private Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName,
		@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {

	Class<?> type = descriptor.getDependencyType();

	if (descriptor instanceof StreamDependencyDescriptor) {
		Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
		if (autowiredBeanNames != null) {
			autowiredBeanNames.addAll(matchingBeans.keySet());
		}
		Stream<Object> stream = matchingBeans.keySet().stream()
				.map(name -> descriptor.resolveCandidate(name, type, this))
				.filter(bean -> !(bean instanceof NullBean));
		if (((StreamDependencyDescriptor) descriptor).isOrdered()) {
			stream = stream.sorted(adaptOrderComparator(matchingBeans));
		}
		return stream;
	}
	else if (type.isArray()) {
		...
		Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType,
				new MultiElementDescriptor(descriptor));
		if (matchingBeans.isEmpty()) {
			return null;
		}
		if (autowiredBeanNames != null) {
			autowiredBeanNames.addAll(matchingBeans.keySet());
		}
		TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
		Object result = converter.convertIfNecessary(matchingBeans.values(), resolvedArrayType);
		if (result instanceof Object[]) {
			Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
			if (comparator != null) {
				Arrays.sort((Object[]) result, comparator);
			}
		}
		return result;
	}
	else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {
		...
		Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType,
				new MultiElementDescriptor(descriptor));
		if (matchingBeans.isEmpty()) {
			return null;
		}
		if (autowiredBeanNames != null) {
			autowiredBeanNames.addAll(matchingBeans.keySet());
		}
		TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
		Object result = converter.convertIfNecessary(matchingBeans.values(), type);
		if (result instanceof List) {
			if (((List<?>) result).size() > 1) {
				Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
				if (comparator != null) {
					((List<?>) result).sort(comparator);
				}
			}
		}
		return result;
	}
	else if (Map.class == type) {
		....
		Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType,
				new MultiElementDescriptor(descriptor));
		if (matchingBeans.isEmpty()) {
			return null;
		}
		if (autowiredBeanNames != null) {
			autowiredBeanNames.addAll(matchingBeans.keySet());
		}
		return matchingBeans;
	}
	else {
		return null;
	}
}
  1. findAutowireCandidates,按照类型查找对应的bean类型，这里只是类型、类型、类型，不是具体的对象
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) {
	// require字段的作用，如果找到，require=false，不报错
	if (isRequired(descriptor)) {
		raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
	}
	return null;
}
protected Map<String, Object> findAutowireCandidates(
			@Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {
	// 按照类型去容器中查询
	String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
			this, requiredType, true, descriptor.isEager());
	Map<String, Object> result = new LinkedHashMap<>(candidateNames.length);
	// 匹配spring一些已经注册的类
	for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
		Class<?> autowiringType = classObjectEntry.getKey();
		if (autowiringType.isAssignableFrom(requiredType)) {
			Object autowiringValue = classObjectEntry.getValue();
			autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
			if (requiredType.isInstance(autowiringValue)) {
				result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
				break;
			}
		}
	}
	for (String candidate : candidateNames) {
		if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
			addCandidateEntry(result, candidate, descriptor, requiredType);
		}
	}
	// 如果是空的一些另外处理
	if (result.isEmpty()) {
		boolean multiple = indicatesMultipleBeans(requiredType);
		// Consider fallback matches if the first pass failed to find anything...
		DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
		for (String candidate : candidateNames) {
			//isAutowireCandidate 这个方法会处理Qualifier注解，如果带有Qualifier，就按照名字去匹配
			if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor) &&
					(!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) {
				addCandidateEntry(result, candidate, descriptor, requiredType);
			}
		}
		if (result.isEmpty() && !multiple) {
			// Consider self references as a final pass...
			// but in the case of a dependency collection, not the very same bean itself.
			for (String candidate : candidateNames) {
				if (isSelfReference(beanName, candidate) &&
						(!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&
						isAutowireCandidate(candidate, fallbackDescriptor)) {
					addCandidateEntry(result, candidate, descriptor, requiredType);
				}
			}
		}
	}
	return result;
}
  1. determineAutowireCandidate，这个方法只会在找到多个满足条件的时候调用，如果待选的类型包含**@Primary**注解，就使用它，否则报错，因为spring不知道你要用哪个了
  2. resolveCandidate，这个方法就是按照名称继续bean流程获取
public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
		throws BeansException {

	return beanFactory.getBean(beanName);
}
  1. 反射注入属性，这个就不解释了

流程到这里就结束，当然忽略了一些非本文注重的内容例如（java的@inject注解），我想大家应该会有点对这个注解的理解提升吧！
接下来，看看具体的实例，对应的流程的步骤，都举了个例

@Service
public class TestA{
    //1
    @Autowired
    private Optional<OptionalInstance> optionalInstance;

    //2
    @Autowired
    ObjectFactory<ObjectFactoryInstance> objectFactoryInstance;

    //3
    @Autowired
    ObjectProvider<ObjectProviderTest.ObjectProviderInstance> objectProviderInstances;

    //4
    @Autowired
    @Lazy
    private LazyTest lazyTest;

    //5方法注入，对@value的处理
    @Autowired
    private void valueTest(@Value("${spring.application.name}")String name){

    }

    @Autowired
    private TestB testB;

    private TestC testC;

	//方法注入
    @Autowired
    public void setP(TestC testC){
        this.testC =testC;
    }
	// TestD是个接口，多个类实现
    @Autowired
    private List<TestD> testDS;

	// TestE是个接口，多个类实现
    @Autowired
    @Qualifier(value = "testE1") 会注入名称为testE1的类，没有这个注解就报错拉。。。
    private TestE testE;

	// TestE是个接口，多个类实现，这样应该是会报错的但是我在其中的一个类上加了@Primary注解
    @Autowired
    private TestF testF;

    public void sayObjectFactory(){
        System.out.println(this.objectFactoryInstance.getObject());
        System.out.println(optionalInstance.isPresent());
        System.out.println(lazyTest);
    }

    public void sayObjectProvider(){
        System.out.println(this.objectProviderInstances.getIfUnique());
        System.out.println(objectProviderInstances.getIfAvailable());
        System.out.println(objectProviderInstances.getObject());
    }
}

在对代码中的ObjectFactory、ObjectProvider进行下说明吧，它的重要类似@lazy，在使用的时候再进行bean的获取，ObjectFactory还记得它吗？我们在循环依赖中，放入二级缓存的东西《springboot ApplicationContext之finishBeanFactoryInitialization(getBean())上》，ObjectProvider是它的之类扩展了一些方法getIfUnique、getIfAvailable、stream相关等，主要扩展的是，默认require =false，也就是说，如果不存在在启动的时候不会报错，使用的时候会报错
在这里插入图片描述

	private class DependencyObjectProvider implements BeanObjectProvider<Object> {

		private final DependencyDescriptor descriptor;

		private final boolean optional;

		@Nullable
		private final String beanName;

		public DependencyObjectProvider(DependencyDescriptor descriptor, @Nullable String beanName) {
			this.descriptor = new NestedDependencyDescriptor(descriptor);
			this.optional = (this.descriptor.getDependencyType() == Optional.class);
			this.beanName = beanName;
		}

		@Override
		public Object getObject() throws BeansException {
			if (this.optional) {
				return createOptionalDependency(this.descriptor, this.beanName);
			}
			else {
				Object result = doResolveDependency(this.descriptor, this.beanName, null, null);
				if (result == null) {
					throw new NoSuchBeanDefinitionException(this.descriptor.getResolvableType());
				}
				return result;
			}
		}

		@Override
		public Object getObject(final Object... args) throws BeansException {
			if (this.optional) {
				return createOptionalDependency(this.descriptor, this.beanName, args);
			}
			else {
				DependencyDescriptor descriptorToUse = new DependencyDescriptor(this.descriptor) {
					@Override
					public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory) {
						return beanFactory.getBean(beanName, args);
					}
				};
				Object result = doResolveDependency(descriptorToUse, this.beanName, null, null);
				if (result == null) {
					throw new NoSuchBeanDefinitionException(this.descriptor.getResolvableType());
				}
				return result;
			}
		}

		@Override
		@Nullable
		public Object getIfAvailable() throws BeansException {
			if (this.optional) {
				return createOptionalDependency(this.descriptor, this.beanName);
			}
			else {
				DependencyDescriptor descriptorToUse = new DependencyDescriptor(this.descriptor) {
					// 可以允许不存在
					@Override
					public boolean isRequired() {
						return false;
					}
				};
				return doResolveDependency(descriptorToUse, this.beanName, null, null);
			}
		}

		@Override
		@Nullable
		public Object getIfUnique() throws BeansException {
			DependencyDescriptor descriptorToUse = new DependencyDescriptor(this.descriptor) {
				// 可以允许不存在
				@Override
				public boolean isRequired() {
					return false;
				}
				@Override
				@Nullable
				public Object resolveNotUnique(ResolvableType type, Map<String, Object> matchingBeans) {
					return null;
				}
			};
			if (this.optional) {
				return createOptionalDependency(descriptorToUse, this.beanName);
			}
			else {
				return doResolveDependency(descriptorToUse, this.beanName, null, null);
			}
		}

		@Nullable
		protected Object getValue() throws BeansException {
			if (this.optional) {
				return createOptionalDependency(this.descriptor, this.beanName);
			}
			else {
				return doResolveDependency(this.descriptor, this.beanName, null, null);
			}
		}

		@Override
		public Stream<Object> stream() {
			return resolveStream(false);
		}

		@Override
		public Stream<Object> orderedStream() {
			return resolveStream(true);
		}

		@SuppressWarnings("unchecked")
		private Stream<Object> resolveStream(boolean ordered) {
			DependencyDescriptor descriptorToUse = new StreamDependencyDescriptor(this.descriptor, ordered);
			Object result = doResolveDependency(descriptorToUse, this.beanName, null, null);
			return (result instanceof Stream ? (Stream<Object>) result : Stream.of(result));
		}
	}

接下来我们来聊聊@Autowired、@resource的区别在哪里，看到流程图中的那个箭头了吗！！！在这里插入图片描述
就是inject方法再调用具体的类型的inject方法是多了个判断，@resource注解的作用类是CommonAnnotationBeanPostProcessor，她调用findResourceMetadata返回的对象是ResourceElement，我们看下该类的inject方法（实际调用的父类InjectionMetadata.InjectedElement）

protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs)
		throws Throwable {

	if (this.isField) {
		Field field = (Field) this.member;
		ReflectionUtils.makeAccessible(field);
		field.set(target, getResourceToInject(target, requestingBeanName));
	}
	else {
		if (checkPropertySkipping(pvs)) {
			return;
		}
		try {
			Method method = (Method) this.member;
			ReflectionUtils.makeAccessible(method);
			method.invoke(target, getResourceToInject(target, requestingBeanName));
		}
		catch (InvocationTargetException ex) {
			throw ex.getTargetException();
		}
	}
}

调用都是getResourceToInject，这个方法ResourceElement进行重写，

@Override
protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
	// @lazy注解分开处理
	return (this.lazyLookup ? buildLazyResourceProxy(this, requestingBeanName) :
			getResource(this, requestingBeanName));
}

protected Object getResource(LookupElement element, @Nullable String requestingBeanName)
	throws NoSuchBeanDefinitionException {
//忽略了其它一些
....
return autowireResource(this.resourceFactory, element, requestingBeanName);
}

autowireResource就是重要的区别方法了，仔细、仔细看下，方法会判断factory.containsBean(name)是否存在，如果不存在就转交成@Autowired处理，如果存在直接按照名称获取（这个时候就不会存在返回多bean了，但是如果名称对应的类型跟定义的类型不一致就会报错）。

protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName)
			throws NoSuchBeanDefinitionException {

		Object resource;
		Set<String> autowiredBeanNames;
		String name = element.name;

		if (factory instanceof AutowireCapableBeanFactory) {
			AutowireCapableBeanFactory beanFactory = (AutowireCapableBeanFactory) factory;
			DependencyDescriptor descriptor = element.getDependencyDescriptor();
			// 区别在这里。。。。，会判断factory.containsBean(name)是否存在，如果不存在就转交成@Autowired处理
			if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) {
				autowiredBeanNames = new LinkedHashSet<>();
				resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);
				if (resource == null) {
					throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object");
				}
			}
			//已经存在的，直接按照名称获取
			else {
				resource = beanFactory.resolveBeanByName(name, descriptor);
				autowiredBeanNames = Collections.singleton(name);
			}
		}
		else {
			resource = factory.getBean(name, element.lookupType);
			autowiredBeanNames = Collections.singleton(name);
		}

		if (factory instanceof ConfigurableBeanFactory) {
			ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) factory;
			for (String autowiredBeanName : autowiredBeanNames) {
				if (requestingBeanName != null && beanFactory.containsBean(autowiredBeanName)) {
					beanFactory.registerDependentBean(autowiredBeanName, requestingBeanName);
				}
			}
		}

		return resource;
	}

个人总结下两者的区别：

  • @Resource，优先按照名称注入，存在，进入bean的获取流程；不存在，回滚到@Autowired
  • @Autowired，按照类型注入
red-nation
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
史上最全 SpringBoot 注解详解
12-21
一、注解(annotations)列表 1、@SpringBootApplication 包含了@ComponentScan、@Configuration和@EnableAutoConfiguration注解。 其中@ComponentScan让Spring Boot扫描到Configuration类并把它加入到程序上下文。 2、@ComponentScan 组件扫描，可自动发现和装配一些Bean。 3、@Configuration 等同于Spring的XML配置文件；使用Java代码可以检查类型安全。 4、@EnableAutoConfiguration 自动配置 5、@RestContro
Springboot @Autowired 和 @Resource 我的剖析，你看完就不会忘
默默不代表沉默
10-23 9868
前言 @Autowired 和 @Resource 这两个注解大家想必都有在项目里面出现过，但是真的清楚这俩玩意的用法或者说是区别么？ 一直用的都是@Autowired ？ 别人代码用什么就copy用什么，反正他没错，俺也不会错？ 它们都是一样的作用？只是名字不一样而已？ 如果你存在以上这些疑问，那么你看这篇文章必赚！ 上车！ 如果你不存在以上这些疑问，那么你看这篇文章也不亏！ 正文 跟着我 了解下 @Autowired 和@Resource ...
@Autowired注解 -【Spring底层原理】
最新发布
2401_85767200的博客
06-17 990
【1】注解用法根据@Autowired注解的源码，可以看到该注解可以作用在构造器、参数、方法、属性，都是从容器中获取参数组件的值标注在方法上：@Bean+方法参数，参数从容器中获取，默认不写@Autowired效果是一样的，都能自动装配标注在构造器上：如果组件上只有一个有参构造，这个有参构造的@Autowired可以省略，参数位置的组件还是可以自动从容器中获取标注在参数位置标注在属性位置。
SpringBoot中@Autowired注解
javabbcc的博客
06-28 7331
SpringBoot中@Autowired注解
Spring Boot——@Autowired属性注入问题
Wen先森的博客
04-27 3974
例如，使用 Setter Injection 的类可能会存在不完整的状态，如果必需的依赖项没有被设置，可能会导致运行时错误。相比于 Field Injection，Setter Injection 的主要优势是可以避免直接访问类的属性，而是通过 setter 方法来设置依赖项，从而实现更好的封装性。但是，当依赖项过多时，类的属性列表可能会变得很长，降低代码的可读性和可维护性。但是，使用 Setter Injection 的类可能会存在不完整的状态，如果必需的依赖项没有被设置，可能会导致运行时错误。
SpringBoot - @Autowired注解使用详解
记录并分享
02-17 7225
@Autowired由Spring框架定义，当Spring框架的项目在运行时如果发现由它管理的Bean对象中有使用@Autowired注解描述的属性/方法，Spring会按照指定规则为属性/方法赋值(DI)。
Spring Boot的@Autowired
matthewchen123的博客
02-03 1341
@Autowired @Autowired是用在JavaBean中的注解，通过byType形式，用来给指定的字段或方法注入所需的外部资源。 @Autowired 是一个注释，它可以对类成员变量、方法及构造函数进行标注，让 spring 完成 bean 自动装配的工作。 通过 @Autowired的使用来消除 set ，get方法。 在使用@Autowired之前，我们对一个bean配置起属性时，（如下）繁琐复杂 <property name="属性名" value=" 属性值"/> @A
解析SpringBoot中@Autowire注解的实现原理
一名Java语言狂热分子。
06-02 2211
Autowired 是 Spring 框架提供的一种依赖注入方式，它可以自动装配 Bean，并将成员变量、方法参数或构造函数中需要的对象注入到对应的位置。它是基于 Java 的反射机制实现的，能够方便地管理对象之间的依赖关系。Spring Boot 中 @Autowired 注解实现依赖注入的功能是基于 Java 的反射机制实现的。它可以方便地管理对象之间的依赖关系，并提高代码的可读性和可维护性。
Springboot @Import 详解
08-26
Springboot @Import 详解 @Import 是 Spring Boot 中的一个重要注解，用于将指定的类实例注入到 Spring IOC Container 中。在本篇文章中，我们将详细介绍 @Import 的作用和使用方法。 什么是 @Import？ @Import ...
Springboot @Value使用代码实例
08-25
Springboot @Value注解使用详解 在 Spring Boot 框架中，@Value 注解是一个非常重要的组件，它可以将外部配置文件中的值注入到 Java Bean 中，从而实现了配置文件和 Java 代码的解耦。下面我们将通过一个实例来详细...
SpringBoot常用注解详解含使用示例（值得珍藏）
02-01
本文将详细介绍Spring Boot中最常用的注解，包括@SpringBootApplication、@Component、@Service、@Repository、@Controller、@RequestMapping、@GetMapping、@PostMapping、@PutMapping、@DeleteMapping、@Autowired...
SpringBoot异步任务使用方法详解
08-19
例如，在上面的示例代码中，我们定义了一个测试控制器AsyncController，该控制器使用@Autowired注解来注入异步任务业务类AsyncTask，然后调用其方法来执行异步任务。 SpringBoot异步任务使用方法详解的优点： * ...
【SpringBoot】 注解@Autowired
九师兄
01-08 2997
Autowired应该是我们在Spring项目中最常用的注解了。@Target({/*** 申明当前对象是否是必须的可以配置在构造函数、方法上、方法参数上、成员变量上。既然是通过Annotation的方式来注入bean，那么一定要记得在实现类上添加相应的注解；通过JavaConfig的方式来扫描包下的类，并添加到容器中，这种方式类似于beans.xml中我们在使用@Autowired注解的时候，Spring主要是基于类型来主动装配的，如果我们需要指定某一个实现类，可以考虑使用。
SpringBoot@Autowired使用详解及实例演示
pengweismile的专栏
07-06 2313
前面介绍过通过@Import/@ComponentScan+@Component/@Bean/实现FactoryBean接口四种方式可以把bean加到spring的ioc容器中来。 而@AutoWired注解则可以为这些加到容器中的实例的变量，参数，方法进行自动赋值。 主要知识点： 1.@Autowired 默认时根据类型来赋值的，可以使用@Bean(autowire = Autowire....
Spring Boot @Autowired 没法自动注入的问题
热门推荐
dulabing的专栏
01-12 4万+
Application 启动类： @SpringBootApplication @EnableConfigurationProperties @ComponentScan(basePackages = { "com.testing"}) public class Application { @Bean RestTemplate restTemplate() { ret
【SpringBoot入门】详解@Autowired的使用
qq_43720551的博客
09-05 726
@Autowire在不同地方注入依赖项的使用&&简单示例
SpringBoot注解篇之@Resource与@Autowired
weixin_36808034的博客
10-12 3390
大家好，我是AK，最近在整理Java相关技术知识体系化；本篇主要介绍@Resource 注解和 @Autowired的区别以及使用，适合学习spring框架小伙伴了解学习。
SpringBoot @Autowired注解的使用
专注基础架构领域
06-09 1128
可以把@Autowired的属性required设置成为false，此时spring会自己选择使用哪一种构造方法；1.会优先考虑参数多的（先ByType找到多个该类型的bean，再ByName进行注入）2.如果多个类型的bean按照ByName无法注入，则去考虑参数少的进行注入，依次类推；3.在参数个数相同、ByName,也可以注入的情况下，按照构造方法的书写顺序进行选择；在同一个类上有多个构造方法上使用了@Autowired，默认情况下会报错；
软件框架SpringBoot-实现使用@Autowired@PropertySource（指定自定义文件的位置，开启对应配置）等方法实现将配置文件输出在控制台上
weixin_59042297的博客
03-24 572
3.这个程序具体的内容我忘了，只知道使用@Data@Configuration@Autowired@PropertySource@Test（指定自定义文件的位置，开启对应配置）等方法写的，具体实现的功能就是新建几个.yml和.java文件，实现在.yml文件中配置访问路径（输入信息）通过localhost:8080端口实现在网页上输出；以上为本代码的结构，下面为代码的结构，画框的就是需要编写的代码，下面会依次将各代码段粘贴。4.下面写的是这个表需要建的结构和代码段以及运行的结果；1.id控制台运行的结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值