Spring 中 @Primary 注解的原理是什么?

这篇具有很好参考价值的文章主要介绍了Spring 中 @Primary 注解的原理是什么?。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1. 问题分析

当我们使用 Spring 的时候,有时候会遇到下面这种情况。

假设我有 A、B 两个类,在 A 中注入 B,如下:

@Component
public class A {
    @Autowired
    B b;
}

至于 B,则在配置类中存在多个实例:

@Configuration
@ComponentScan
public class JavaConfig {
    @Bean("b1")
    B b1() {
        return new B();
    }

    @Bean("b2")
    B b2() {
        return new B();
    }
}

这样的项目启动之后,必然会抛出如下异常:

Spring 中 @Primary 注解的原理是什么?,spring,数据库,mysql

当然,对于这样的问题,相信有经验的同学都知道该怎么解决:

  1. 可以使用 @Resource 注解,使用该注解时指定具体的 Bean 名称即可。
  2. 在 @Autowired 注解之上,再多加一个 @Qualifier(“b1”) 注解,通过该注解去指定要加载的 Bean 名称。
@Component
public class A {
    @Autowired
    @Qualifier("b1")
    B b;
}
  1. 在多个 B 对象的某一个之上,添加 @Primary 注解,表示当存在重复的 B 对象时,优先使用哪一个。
@Configuration
@ComponentScan
public class JavaConfig {
    @Bean("b1")
    @Primary
    B b1() {
        return new B();
    }

    @Bean("b2")
    B b2() {
        return new B();
    }
}

除了这三个,还有没有其他办法呢?必须有!!!在 Spring 中 @Qualifier 注解还能这么用? 一文中,松哥还和大家扩展了 @Qualifier 注解的其他用法,感兴趣的小伙伴不要错过哦。

这里三个方法,其中 @Resource 是 JSR 中提供的注解,我这里先不展开,松哥后面专门再来和大家聊 @Resource 注解的注入原理。今天我主要是想和小伙伴们分享一下后面两种方案的实现原理。

2. 源码解析

本文基于前面@Autowired 到底是怎么把变量注入进来的?一文展开,所以如果还没看过改文章的小伙伴,建议先去阅读一下,这有助于更好的理解本文。

2.1 doResolveDependency

在@Autowired 到底是怎么把变量注入进来的?的 3.3 小节中,我们提到,给 A 注入 B 的时候,会调用到 doResolveDependency 方法,我们再来看下该方法:

DefaultListableBeanFactory#doResolveDependency:

@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
		@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
	    //...
		Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
		if (matchingBeans.isEmpty()) {
			if (isRequired(descriptor)) {
				raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
			}
			return null;
		}
		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);
		//...
}

在这个方法中,首先调用了 findAutowireCandidates 方法去找到所有满足条件的 Class。Map 中的 key 就是 Bean 的名称,value 则是一个 Class,此时还没有实例化。

如果我们是通过 @Qualifier 注解来解决问题的,那么问题就在 findAutowireCandidates 方法中被解决了。这个在前面的文章 Spring 中 @Qualifier 注解还能这么用? 中已经和小伙伴们聊过了。

如果 @Qualifier 注解没把问题解决掉,就会导致最终查询到的 matchingBeans 的数量大于 1,那么就会进入到接下来的 if 环节中,通过 determineAutowireCandidate 方法进一步确定到底使用哪一个 Bean,@Primary 注解的处理,就在该方法中完成。

2.2 determineAutowireCandidate

DefaultListableBeanFactory#determineAutowireCandidate

@Nullable
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;
}

这个方法里边一共做了三种尝试:

  1. 第一个尝试就是调用 determinePrimaryCandidate 方法去确定最佳候选 Bean,这个方法本质上就是通过 @Primary 注解找到最佳 BeanName。
  2. 如果第一步没有找到最佳 BeanName,那么接下来会调用 determineHighestPriorityCandidate 方法去查找最佳 Bean,该方法本质上是通过查找 JSR-330 中的 @Priority 注解,来确定 Bean 的优先级。
  3. 如果前两步都没找到合适的 BeanName,那么接下来这个 for 循环则是通过 Bean 的名称进行匹配了,即 A 类中变量的名称和目标 Bean 的名称是否匹配,如果能匹配上,那也可以。这也就是我么常说的 @Autowired 注解先按照类型去匹配,如果类型匹配不上,就会按照名称去匹配。

上面大致介绍了这个方法的执行思路,接下来我们就来看一下执行细节。

2.2.1 determinePrimaryCandidate
@Nullable
protected String determinePrimaryCandidate(Map<String, Object> candidates, Class<?> requiredType) {
	String primaryBeanName = null;
	for (Map.Entry<String, Object> entry : candidates.entrySet()) {
		String candidateBeanName = entry.getKey();
		Object beanInstance = entry.getValue();
		if (isPrimary(candidateBeanName, beanInstance)) {
			if (primaryBeanName != null) {
				boolean candidateLocal = containsBeanDefinition(candidateBeanName);
				boolean primaryLocal = containsBeanDefinition(primaryBeanName);
				if (candidateLocal && primaryLocal) {
					throw new NoUniqueBeanDefinitionException(requiredType, candidates.size(),
							"more than one 'primary' bean found among candidates: " + candidates.keySet());
				}
				else if (candidateLocal) {
					primaryBeanName = candidateBeanName;
				}
			}
			else {
				primaryBeanName = candidateBeanName;
			}
		}
	}
	return primaryBeanName;
}
protected boolean isPrimary(String beanName, Object beanInstance) {
	String transformedBeanName = transformedBeanName(beanName);
	if (containsBeanDefinition(transformedBeanName)) {
		return getMergedLocalBeanDefinition(transformedBeanName).isPrimary();
	}
	return (getParentBeanFactory() instanceof DefaultListableBeanFactory parent &&
			parent.isPrimary(transformedBeanName, beanInstance));
}

我们来看下这个方法的执行逻辑。

参数 candidates 中保存了所有符合条件的 BeanDefinition,参数 key 就是 Bean 的名称,Value 则是对应的 BeanDefinition。现在就去遍历 candidates,在遍历的时候,调用 isPrimary 方法去判断这个 BeanDefinition 上是否含有 @Primary 注解,isPrimary 方法的逻辑比较简单,我就不啰嗦了,该方法中涉及到 getMergedLocalBeanDefinition 方法去父容器中查找两个细节,这个松哥在之前的文章中也都和大家聊过了(Spring BeanDefinition:父子关系解密、Spring 中的父子容器是咋回事?)。

在查找的过程中,如果有满足条件的 BeanName,则赋值给 primaryBeanName 变量然后返回,如果存在多个满足条件的 BeanName,那就抛出 NoUniqueBeanDefinitionException 异常。

2.2.2 determineHighestPriorityCandidate

要理解 determineHighestPriorityCandidate 方法,得先了解 @Priority 注解的用法。考虑到有的小伙伴可能还不熟悉 @Priority 注解,我这里也跟大家稍微说两句。

@Priority 注解作用有点类似于 @Order,可以用来指定一个 Bean 的优先级,这是 JSR 中提供的注解,所以如果想使用这个注解,需要先添加依赖:

<dependency>
    <groupId>jakarta.annotation</groupId>
    <artifactId>jakarta.annotation-api</artifactId>
    <version>2.1.1</version>
</dependency>

然后在类上添加该注解,像下面这样:

public interface IBService {
}
@Component
@Priority(100)
public class BServiceImpl1 implements IBService{
}
@Component
@Priority(101)
public class BServiceImpl2 implements IBService{
}

@Priority 注解中的数字表示优先级,数字越大优先级越小。将来在 A 中注入 IBService 时,就会优先查找优先级高的 Bean。虽然 @Priority 注解可以加在类上,也可以加在方法上,但是在具体实践中,加在方法上这个注解并不会生效,只能加在类上面。至于原因,大家看完接下来的源码分析就懂了。

现在我们再来看下 determineHighestPriorityCandidate 方法:

@Nullable
protected String determineHighestPriorityCandidate(Map<String, Object> candidates, Class<?> requiredType) {
	String highestPriorityBeanName = null;
	Integer highestPriority = null;
	for (Map.Entry<String, Object> entry : candidates.entrySet()) {
		String candidateBeanName = entry.getKey();
		Object beanInstance = entry.getValue();
		if (beanInstance != null) {
			Integer candidatePriority = getPriority(beanInstance);
			if (candidatePriority != null) {
				if (highestPriorityBeanName != null) {
					if (candidatePriority.equals(highestPriority)) {
						throw new NoUniqueBeanDefinitionException(requiredType, candidates.size(),
								"Multiple beans found with the same priority ('" + highestPriority +
								"') among candidates: " + candidates.keySet());
					}
					else if (candidatePriority < highestPriority) {
						highestPriorityBeanName = candidateBeanName;
						highestPriority = candidatePriority;
					}
				}
				else {
					highestPriorityBeanName = candidateBeanName;
					highestPriority = candidatePriority;
				}
			}
		}
	}
	return highestPriorityBeanName;
}

determineHighestPriorityCandidate 方法的整体处理思路跟 determinePrimaryCandidate 方法特别像,不同的是 determinePrimaryCandidate 方法处理的是 @Primary 注解,而 determineHighestPriorityCandidate 方法处理的是 @Priority 注解。

determineHighestPriorityCandidate 方法也是遍历 candidates,然后调用 getPriority 方法获取到具体的优先级的值。然后根据这个具体的数字选定一个合适的 beanName 返回,如果存在多个优先级相同的 bean,那么就会抛出 NoUniqueBeanDefinitionException 异常。

最后再来看下 getPriority 方法,几经辗转之后,该方法会调用到 AnnotationAwareOrderComparator#getPriority 方法:

@Override
@Nullable
public Integer getPriority(Object obj) {
	if (obj instanceof Class<?> clazz) {
		return OrderUtils.getPriority(clazz);
	}
	Integer priority = OrderUtils.getPriority(obj.getClass());
	if (priority == null  && obj instanceof DecoratingProxy decoratingProxy) {
		return getPriority(decoratingProxy.getDecoratedClass());
	}
	return priority;
}

可以看到,这里最终就是调用 OrderUtils.getPriority 方法去查找参数 clazz 上的 @Priority 注解,并找到注解上对应的值返回。OrderUtils.getPriority 在执行的时候,参数时 clazz,即只会查找 clazz 上的 注解,并不会查找方法上的注解,因此前面我说 @Priority 注解要加在类上才有效。

2.2.3 按名称匹配

最后我们再来看下按照名字去匹配的逻辑:

// 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;
	}
}
protected boolean matchesBeanName(String beanName, @Nullable String candidateName) {
	return (candidateName != null &&
			(candidateName.equals(beanName) || ObjectUtils.containsElement(getAliases(beanName), candidateName)));
}

可以看到,这里也是遍历 candidates 集合,然后调用 matchesBeanName 方法,在该方法中,会去判断候选的 BeanName 和需要注入的变量名(descriptor.getDependencyName())是否相等,如果相等,就直接返回即可。即下面这种代码不需要额外的注解是可以运行不会报错的:

@Component
public class AService {
    @Autowired
    B b1;

}
@Configuration
@ComponentScan
public class JavaConfig {

    @Bean
    public B b1() {
        return new B();
    }

    @Bean
    B b2() {
        return new B();
    }

}

3. 小结

好啦,经过上面的分析,现在小伙伴们明白了 @Primary 注解的完整处理逻辑了吧~本文结合@Autowired 到底是怎么把变量注入进来的? 和 Spring 中 @Qualifier 注解还能这么用? 一起食用效果更好哦!文章来源地址https://www.toymoban.com/news/detail-664307.html

到了这里,关于Spring 中 @Primary 注解的原理是什么?的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Spring Boot 中的 @RabbitListener 注解是什么,原理,如何使用

    在 RabbitMQ 中,消息的接收需要通过监听队列来实现。在 Spring Boot 应用程序中,可以使用 @RabbitListener 注解来监听队列,并在接收到消息时执行指定的方法。本文将介绍 @RabbitListener 注解的原理、使用方法和常见应用场景。 @RabbitListener 注解是 Spring AMQP 框架中的一个关键组件,

    2024年02月09日
    浏览(57)
  • Spring Boot 中的 @RefreshScope 注解是什么,原理,如何使用

    在 Spring Boot 中,@RefreshScope 注解是一个非常有用的注解。它可以让 Spring Boot 应用程序在运行时重新加载配置。这意味着您可以在不停止和重新启动应用程序的情况下更改配置。在本文中,我们将介绍 @RefreshScope 注解的原理和如何在 Spring Boot 应用程序中使用它。 @RefreshScope 是

    2024年02月13日
    浏览(34)
  • Spring Boot中的@EnableWebSocketMessageBroker注解是什么,原理,以及如何使用

    WebSocket是一种在Web浏览器和Web服务器之间进行双向通信的技术。在传统的HTTP通信中,客户端向服务器发送请求,服务器响应请求,然后关闭连接。而在WebSocket中,客户端和服务器之间的连接始终保持打开状态,可以随时互相发送消息,实现实时通信。 Spring Boot提供了对WebSo

    2024年02月12日
    浏览(70)
  • 基于Spring注解 + MyBatis + Servlet 实现数据库交换的小小Demo

    配置数据库连接信息 db.properties 配置web.xml 配置logback.xml配置文件 配置applicationContext.xml 里面的bean 配置myBatis核心配置文件mybatis-config.xml 创建实体类对象User 创建LoginServlet响应前端的数据 创建UserService 接口 创建UserMapper接口 创建UserServiceImpl 接口实现类 按照这样的方式进行拼接

    2024年02月02日
    浏览(81)
  • Spring事务管理 | 数据库连接池流程原理分析

    💗wei_shuo的个人主页 💫wei_shuo的学习社区 🌐Hello World ! 事务(Transaction),一般是指要做的或所做的事情。在计算机 术语 中是指访问并可能更新数据库中各种 数据项 的一个程序 执行单元 。事务通常由 高级数据库 操纵语言或编程语言(如SQL,C++或Java)书写的 用户程序

    2024年02月02日
    浏览(48)
  • Spring @Autowired 注解原理

    被扫描的组件配置类 输出结果 定位@Autowired所在包 org.springframework.beans.factory.annotation.Autowired 找到同包下 AutowiredAnnotationBeanPostProcessor AutowiredAnnotationBeanPostProcessor 的类继承图如下 AutowiredAnnotationBeanPostProcessor实现了InstantiationAwareBeanPostProcessor与 MergedBeanDefinitionPostProcessor两个Bea

    2024年02月16日
    浏览(41)
  • Spring Boot 学习之——@SpringBootApplication注解(自动注解原理)

    springboot是基于spring的新型的轻量级框架,最厉害的地方当属**自动配置。**那我们就可以根据启动流程和相关原理来看看,如何实现传奇的自动配置 从上面代码可以看出,Annotation定义(@SpringBootApplication)和类定义(SpringApplication.run)最为耀眼,所以要揭开SpringBoot的神秘面纱

    2024年01月25日
    浏览(49)
  • Spring Boot 中@EnableAutoConfiguration注解原理

    开启  Spring  的自动装配功能; 简单点说就是Spring Boot根据依赖中的jar包,自动选择 实例化 某些配置,配置类必须有@Configuration注解。 二、@EnableAutoConfiguration的原理 1.点进启动类上的EnableAutoConfiguration注解 2.发现@EnableAutoConfiguration注解实际上也是@Import注解实现的(其实@Ena

    2024年01月17日
    浏览(40)
  • Spring(18) @Order注解介绍、使用、底层原理

    @Order :是 spring-core 包下的一个注解。@Order 作用是 定义 Spring IOC 容器中 Bean 的执行顺序 。 注意: Spring 的 @Order 注解或者 Ordered 接口,不决定 Bean 的加载顺序和实例化顺序,只决定 Bean 注入到 List 中的顺序。 @Order 注解接受一个整数值作为参数, 数值越小表示优先级越高 。

    2024年02月20日
    浏览(37)
  • Spring cloud负载均衡 @LoadBalanced注解原理

    接上一篇文章,案例代码也在上一篇文章的基础上。 在上一篇文章的案例中,我们创建了作为Eureka server的Eureka注册中心服务、作为Eureka client的userservice、orderservice。 orderservice引入RestTemplate,加入了@LoadBalanced注解,代码如下: 从而,我们实现了基于Eureka注册中心的微服务治

    2024年02月05日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包