quarkus依赖注入之四：选择注入bean的高级手段-6ren

quarkus依赖注入之四：选择注入bean的高级手段

转载作者：我是一只小鸟更新时间：2023-08-02 14:31:57

26

4

欢迎访问我的GitHub

这里分类和汇总了欣宸的全部原创(含配套源码)： https://github.com/zq2599/blog_demos 。

本篇概览

本文是《quarkus依赖注入》系列的第四篇，在应用中，一个接口有多个实现是很常见的，那么依赖注入时，如果类型是接口，如何准确选择实现呢？前文介绍了五种注解，用于通过配置项、profile等手段选择注入接口的实现类，面对复杂多变的业务场景，有时候仅靠这两种手段是不够的，最好是有更自由灵活的方式来选择bean，这就是本篇的内容，通过注解、编码等更多方式选择bean
本篇涉及的选择bean的手段有以下四种：

修饰符匹配
Named注解的属性匹配
根据优先级选择
写代码选择

关于修饰符匹配

为了说明修饰符匹配，先来看一个注解 Default ，其源码如下

                        
                          @Target({ TYPE, METHOD, PARAMETER, FIELD })
@Retention(RUNTIME)
@Documented
@Qualifier
public @interface Default {
    public static final class Literal extends AnnotationLiteral<Default> implements Default {
    	public static final Literal INSTANCE = new Literal();
			private static final long serialVersionUID = 1L;
    }
}

Default的源码在这里不重要，关键是它被注解 Qualifier 修饰了，这种被 Qualifier 修饰的注解，咱们姑且称之为 Qualifier修饰符
如果咱们新建一个注解，也用 Qualifier 来修饰，如下所示，这个MyQualifier也是个 Qualifier修饰符

                        
                          @Qualifier
@Retention(RUNTIME)
@Target({TYPE, METHOD, FIELD, PARAMETER})
public @interface MyQualifier {
    @Nonbinding String value();
}

在quarkus容器中的每一个bean都应该有一个 Qualifier修饰符在修饰，如下图红框，如果没有，就会被quarkus添加 Default 注解
依赖注入时，直接用 Qualifier修饰符修饰注入对象，这样quarkus就会去寻找被这个 Qualifier修饰符修饰的bean，找到就注入（找不到报错，找到多个也报错，错误逻辑和之前的一样）
所以用修饰符匹配来选择bean的实现类，一共分三步：

假设有名为 HelloQualifier 的接口，有三个实现类：HelloQualifierA、HelloQualifierB、HelloQualifierC，业务需求是使用HelloQualifierA
第一步：自定义一个注解，假设名为 MyQualifier ，此注解要被 Qualifier 修饰
第二步：用 MyQualifier 修饰HelloQualifierA
第三步：在业务代码的注入点，用 MyQualifier 修饰HelloQualifier类型的成员变量，这样成员变量就会被注入HelloQualifierA实例

仅凭文字描述，很难把信息准确传递给读者（毕竟欣宸文化水平极其有限），还是写代码实现上述场景吧，聪明的您一看就懂

编码演示修饰符匹配：准备工作

先按照前面的假设将接口和实现类准备好，造成一个接口有多个实现bean的事实，然后，再用修饰符匹配来准确选定bean 。
首先是接口 HelloQualifier ，如下所示。

                        
                          package com.bolingcavalry.service;

public interface HelloQualifier {
    String hello();
}

实现类 HelloQualifierA ，返回自己的类名

                        
                          package com.bolingcavalry.service.impl;

import com.bolingcavalry.service.HelloQualifier;
import javax.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class HelloQualifierA implements HelloQualifier {
    @Override
    public String hello() {
        return this.getClass().getSimpleName();
    }
}

实现类HelloQualifierB、HelloQualifierC的代码和上面的HelloQualifierA相同，都是返回自己类名，就不贴出来了
关于使用HelloQualifier类型bean的代码，咱们就在单元测试类中注入吧，如下所示：

                        
                          package com.bolingcavalry;

import com.bolingcavalry.service.HelloQualifier;
import com.bolingcavalry.service.impl.HelloQualifierA;
import io.quarkus.test.junit.QuarkusTest;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import javax.inject.Inject;

@QuarkusTest
public class QualifierTest {

    @Inject
    HelloQualifier helloQualifier;

    @Test
    public void testQualifier() {
        Assertions.assertEquals(HelloQualifierA.class.getSimpleName(),
                helloQualifier.hello());
    }
}

上面的代码中，成员变量 helloQualifier 的类型是HelloQualifier，quarkus的bean容器中，HelloQualifierA、HelloQualifierB、HelloQualifierC等三个bean都符合注入要求，此时如果执行单元测试，应该会报错：同一个接口多个实现bean的问题
执行单元测试，如下图，黄框中给出了两个线索：第一，错误原因是注入时发现同一个接口有多个实现bean，第二，这些bean都是用 Default 修饰的，然后是绿框，里面将所有实现bean列出来，方便开发者定位问题

现在准备工作完成了，来看如何用修饰符匹配解决问题：在注入点准确注入HelloQualifierA类型实例

编码演示修饰符匹配：实现匹配

使用修饰符匹配，继续按照前面总结的三步走
第一步：自定义一个注解，名为 MyQualifier ，此注解要被 Qualifier 修饰

                        
                          package com.bolingcavalry.annonation;

import javax.enterprise.util.Nonbinding;
import javax.inject.Qualifier;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Qualifier
@Retention(RUNTIME)
@Target({TYPE, METHOD, FIELD, PARAMETER})
public @interface MyQualifier {
    @Nonbinding String value();
}

第二步：用 MyQualifier 修饰HelloQualifierA，下图红框是新增的代码。
第三步：在业务代码的注入点，用 MyQualifier 修饰HelloQualifier类型的成员变量，下图红框是新增的代码。
改动完成了，再次执行单元测试，顺利通过。

在这里插入图片描述

修饰符匹配要注意的地方

修饰符匹配的逻辑非常简单：bean定义和bean注入的地方用同一个修饰符即可，使用中有三个地方要注意

在注入bean的地方，如果有了 Qualifier修饰符，可以把 @Inject 省略不写了
在定义bean的地方，如果没有 Qualifier修饰符去修饰bean，quarkus会默认添加 Default
在注入bean的地方，如果没有 Qualifier修饰符去修饰bean，quarkus会默认添加 Default

关于默认的@Default

回头看刚才的代码，如果保留HelloQualifierA的 MyQualifier 修饰，但是删除QualifierTest的成员变量helloQualifier的 MyQualifier 修饰，会发生什么呢？咱们来分析一下:
首先，QualifierTest的成员变量helloQualifier会被quarkus默认添加 Default 修饰。
其次，HelloQualifierB和HelloQualifierC都会被quarkus默认添加 Default 修饰。
所以，注入helloQualifier的时候，quarkus去找 Default 修饰的bean，结果找到了两个：HelloQualifierB和HelloQualifierC，因此启动会失败。
您可以自行验证结果是否和预期一致。
看到这里，您应该掌握了修饰符匹配的用法，也应该发现其不便之处：要新增注解，这样下去随着业务发展，注解会越来越多，有没有什么方法来解决这个问题呢?
方法是有的，就是接下来要看的 Named 注解。

Named注解的属性匹配

Named注解的功能与前面的 Qualifier修饰符是一样的，其特殊之处在于通过注解属性来匹配修饰bean和注入bean 。
以刚才的业务代码为例来演示Named注解，修改 HelloQualifierA ，如下图红框，将 @MyQualifier("") 换成 @Named("A") ，重点关注Named注解的属性值，这里等于 A 。
接下来修改注入处的代码，如下图红框，在注入位置也用 @Named("A") 来修饰，和bean定义处的一模一样。
如此，bean定义和bean注入的两个地方，通过Named注解的属性完成了匹配，至于单元测试您可以自行验证，这里就不赘述了。
至此，详细您已经知道了Named注解的作用：功能与前面的 Qualifier修饰符一样，不过bean的定义和注入处的匹配逻辑是Named注解的属性值。
以上就是修饰符匹配的全部内容。

根据优先级选择

使用优先级来选择注入是一种简洁的方式，其核心是用 Alternative 和 Priority 两个注解修饰所有备选bean，然后用Priority的属性值（int型）作为优先级，该值越大代表优先级越高。
在注入位置，quarkus会选择优先级最高的bean注入。
接下来编码演示。
新增演示用的接口HelloPriority.java 。

                        
                          public interface HelloPriority {
    String hello();
}

HelloPriority的第一个实现类HelloPriorityA.java，注意它的两个注解 Alternative 和 Priority ，前者表明这是个可供选择的bean，后者表明了它的优先级，数字1001用于和其他bean的优先级比较，数字越大优先级越高

                        
                          @ApplicationScoped
@Alternative
@Priority(1001)
public class HelloPriorityA implements HelloPriority {
    @Override
    public String hello() {
        return this.getClass().getSimpleName();
    }
}

HelloPriority的第二个实现类HelloPriorityB，可见Priority属性值是 1002 ，代表选择的时候优先级比HelloPriorityA更高

                        
                          @ApplicationScoped
@Alternative
@Priority(1002)
public class HelloPriorityB implements HelloPriority {
    @Override
    public String hello() {
        return this.getClass().getSimpleName();
    }
}

HelloPriority的第二个实现类HelloPriorityC，可见Priority属性值是 1003 ，代表选择的时候优先级比HelloPriorityA和HelloPriorityB更高

                        
                          @ApplicationScoped
@Alternative
@Priority(1003)
public class HelloPriorityC implements HelloPriority {
    @Override
    public String hello() {
        return this.getClass().getSimpleName();
    }
}

接下来是单元测试，验证注入的bean是否符合预期，理论上注入的应该是优先级最高的 HelloPriorityC

                        
                          @QuarkusTest
public class PriorityTest {

    @Inject
    HelloPriority helloPriority;

    @Test
    public void testSelectHelloInstanceA() {
        Assertions.assertEquals(HelloPriorityC.class.getSimpleName(),
                                helloPriority.hello());
    }
}

单元测试结果如下，符合预期

在这里插入图片描述

以上就是优先级选择bean的操作，如果这还不够用，那就祭出最后一招：写代码选择bean

写代码选择bean

如果不用修饰符匹配，再回到最初的问题：有三个bean都实现了同一个接口，应该如何注入？
在注入bean的位置，如果用 Instance<T> 来接收注入，就可以拿到T类型的所有bean，然后在代码中随心所欲的使用这些bean
新增演示用的接口HelloInstance.java

                        
                          package com.bolingcavalry.service;

public interface HelloInstance {
    String hello();
}

HelloInstance的第一个实现类HelloInstanceA.java

                        
                          package com.bolingcavalry.service.impl;

import com.bolingcavalry.service.HelloInstance;
import javax.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class HelloInstanceA implements HelloInstance {
    @Override
    public String hello() {
        return this.getClass().getSimpleName();
    }
}

HelloInstance的另外两个实现类HelloInstanceB、HelloInstanceC，代码与HelloInstanceA一样，就不贴出来了
接下来的单元测试类演示了如何使用Instance接受注入，以及业务代码如何使用指定的实现类bean，可见 select(Class).get() 是关键，select方法指定了实现类，然后get取出该实例

                        
                          package com.bolingcavalry;

import com.bolingcavalry.service.HelloInstance;
import com.bolingcavalry.service.impl.HelloInstanceA;
import com.bolingcavalry.service.impl.HelloInstanceB;
import io.quarkus.test.junit.QuarkusTest;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import javax.enterprise.inject.Instance;
import javax.inject.Inject;

@QuarkusTest
public class InstanceTest {

    @Inject
    Instance<HelloInstance> instance;

    @Test
    public void testSelectHelloInstanceA() {
        Class<HelloInstanceA> clazz = HelloInstanceA.class;

        Assertions.assertEquals(clazz.getSimpleName(),
                instance.select(clazz).get().hello());
    }

    @Test
    public void testSelectHelloInstanceB() {
        Class<HelloInstanceB> clazz = HelloInstanceB.class;

        Assertions.assertEquals(clazz.getSimpleName(),
                instance.select(clazz).get().hello());
    }
}

执行单元测试，顺利通过，符合预期。
至此，连续两篇关于注入bean的方式全部验证完毕，如此丰富的手段，相信可以满足您日常开发的需要。

欢迎关注博客园：程序员欣宸

学习路上，你不孤单，欣宸原创一路相伴... 。

最后此篇关于quarkus依赖注入之四：选择注入bean的高级手段的文章就讲到这里了,如果你想了解更多关于quarkus依赖注入之四：选择注入bean的高级手段的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！。

26

4

0

文章推荐：更快的训练和推理:对比HabanaGaudi®2和英伟达A10080GB

文章推荐： ProxmoxVE软件防火墙的配置

文章推荐：重返照片的原始世界：我为.NET打造的RAW照片解析利器

dependencies - gobject 依赖 glib 还是 glib 依赖 gobject？
我在 gobject 上阅读了一个维基百科页面，上面写着， Depending only on GLib and libc, GObject is a cornerstone of GNOME and
wpf - 依赖属性依赖于另一个
如何注册一个依赖属性，其值是使用另一个依赖属性的值计算的？由于 .NET 属性包装器在运行时被 WPF 绕过，因此不应在 getter 和 setter 中包含逻辑。解决方案通常是使用 Proper
ActionBarSherlock maven 依赖
我一直在尝试将 ActionbarSherlock maven 依赖项添加到我的项目中 com.actionbarsherlock library 4.2.0 在我的 po
oop - 依赖/依赖是什么意思？
http://tutorials.jenkov.com/ood/understanding-dependencies.html#whatis说(强调我的): Whenever a class A us
wpf - 依赖/附加属性如何在内部工作以及值存储在哪里？
我对所有这些魔法有点不清楚。据我了解，依赖属性是从 DependencyObject 继承的，因此存储值: 如果分配了值(在本地字典中)，则在实例本身中或者如果未指定值，则从指向父元素的链接中获取
Twilio RestSharp 依赖
我刚刚更新了在 ASP.NET Framework 4.5.2 版上运行的 MVC Web 应用程序。我正在使用 Twilio 发送 SMS 消息: var twilio = new TwilioRe
java - Spring 依赖
我刚刚发现了一件令人生畏的事情。 spring 依赖坐标有两个版本。项目依赖于 spring mvc 和 spring flow。有两组并行的依赖项。 Spring MVC 具有以下方案的依赖项
Maven 依赖 picocontainer
我正在尝试包含的 maven 依赖项 org.jacorb jacorb 2.3.1 依赖已解决，但它导致另一个依赖 picocontainer 出现问题: [ERROR
Haskell 依赖 hell
我正在尝试在 Haskell 项目中包含特定版本的库。该库是住宿加早餐型的(用于 martix 操作)，但我需要特定的 0.4.3 版本，该版本修复了乘法实现的错误。所以，我的 stack.yaml
iphone - 依赖 UIPickerView
有谁知道如何制作依赖的 UIPickerView.例如，当我选择组件一的第 2 行时，组件二的标题会发生变化吗？我在互联网上查找过，没有真正的答案，我尝试过使用 if 和 switch 语句，但它们
Maven WAR 依赖
我正在编写一个用于验收测试的项目，由于各种原因，这依赖于另一个打包为 WAR 的项目。我已成功使用 maven-dependency-plugin 解压 WAR，但无法让我的项目包含解压的 WEB-I
Django，依赖 session
或多或少我在 session 上大量构建我的网站(特别是重定向用户等)，我很好奇这是否是一种危险的做法。禁用浏览器 cookie 保存的用户的大致比例是多少？我愿意接受任何建议:) 谢谢最佳答案 s
scala - 依赖 future
开始玩 Scala futures，我被依赖的 futures 困住了。让我们举个例子。我搜索地点并获得 Future[Seq[Place]]。对于这些地点中的每一个，我搜索最近的地铁站(该服务返回
Django，依赖 session
或多或少我在 session 上大量构建我的网站(特别是重定向用户等)，我很好奇这是否是一种危险的做法。禁用浏览器 cookie 保存的用户的大致比例是多少？我愿意接受任何建议:) 谢谢最佳答案 s
c - GLIBC 依赖
我有一个二进制文件，需要一些 *.so 文件才能执行。现在，当我尝试在一些旧机器上执行它时，它会显示 /lib/libc.so.6: version `GLIBC_2.4' not found 如何将
javascript - DyGraph 依赖
我尝试使用 Dygraph 来表示图表，我在 https://github.com/danvk/dygraphs 中找到了代码，但是它有太多的依赖文件，我觉得很烦人。是否有一个文件可以容纳所有必需的
javascript - Jasmine 依赖
我正在处理一个 javascript 文件，该文件 a) 声明一个具有函数的对象，并且 b) 使用它期望在外部声明的散列调用该对象的 init 函数。我的 Jasmine 规范提示它找不到哈希，因为它
javascript - Angular 依赖
最近我一直在学习 Angular 并且进展顺利，但是关于依赖注入(inject)的一些事情我仍然不清楚。是否有任何理由在我的 app.js 文件中声明我的应用程序的其他部分(服务、 Controll
php - 依赖 "mysql_insert_id"
考虑一个名为 foo 的表，它有 id (PRIMARY & AUTO_INCREMENT) 列。我正在向该表中插入一行，挑战从此时开始。 $db->query("INSERT INTO `foo`
javascript - 依赖/级联下拉菜单
我正在使用级联下拉 jquery 插件。 (https://github.com/dnasir/jquery-cascading-dropdown) 我有两个下拉菜单。 “客户端”和“站点”。根据您

首页

博学

6Ren·AI

商城

quarkus依赖注入之四：选择注入bean的高级手段

欢迎访问我的GitHub

本篇概览

关于修饰符匹配

编码演示修饰符匹配：准备工作

编码演示修饰符匹配：实现匹配

修饰符匹配要注意的地方

关于默认的@Default

Named注解的属性匹配

根据优先级选择

写代码选择bean

欢迎关注博客园：程序员欣宸