Quarkus DI方案是基于Java上下文依赖注入2.0标准.但是它不是一个符合TCK的完整CDI实现只实现了CDI一部分功能(可以查看支持及限制列表支持功能清单and限制清单）

现有的 CDI 代码大多能正常工作，但是由于 Quarkus 架构及目标会有一些小差异。

1. Bean 发现

CDI中的Bean发现是一个复杂的过程，涉及传统的部署结构和底层模块体系结构的可访问性要求。但是，Quarkus使用的是简化的bean发现。只有一个带bean发现模式注释的bean存档，没有可见性边界。

Bean档案是根据以下内容合成的：

• application 类,
• 包含 beans.xml 的依赖项 (将忽略内容),
• 包含 Jandex 索引的依赖项 - META-INF/jandex.idx,
• application.properties 中 quarkus.index-dependency 用到的依赖,
• 和Quarkus集成代码。

不会发现没有注解 bean defining annotation 的 Bean 类。 此行为由CDI定义。 但是，包含 producer 方法、字段和 observer 方法的类，即使类未注解也会被发现（此行为与CDI中定义的行为不同）。 实际上，注解了 @Dependent 的类表示可以发现。（Quarkus 扩展可以声明其他发现规则。例如，即使声明类没有注解 @Scheduled 业务方法也会注册。）

1.1如何生成 Jandex 索引

具有Jandex索引的依赖项会自动扫描到bean。要生成索引，只需将以下内容添加到您的pom.xml：

<build>
  <plugins>
    <plugin>
      <groupId>org.jboss.jandex</groupId>
      <artifactId>jandex-maven-plugin</artifactId>
      <version>1.0.7</version>
      <executions>
        <execution>
          <id>make-index</id>
          <goals>
            <goal>jandex</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

如果您使用的是gradle，则可以将以下插件应用于您的build.gradle：

plugins {
    id 'org.kordamp.gradle.jandex' version '0.6.0'
}

如果您无法修改依赖项，则仍可以通过在以下quarkus.index-dependency项中添加条目来对其进行索引application.properties：

quarkus.index-dependency.<name>.group-id=
quarkus.index-dependency.<name>.artifact-id=
quarkus.index-dependency.<name>.classifier=(this one is optional)

例如，以下条目确保对org.acme:acme-api依赖项进行索引：

示例application.properties

quarkus.index-dependency.acme.group-id=org.acme //值是名为 acme 依赖项的 group id.
quarkus.index-dependency.acme.artifact-id=acme-api //值是名为 acme 依赖项的 artifact id.

1.2如何从发现中排除类型和依赖项

第三方库中的某些bean在Quarkus中可能无法正常工作。一个典型的示例是注入可移植扩展的bean。在这种情况下，可以从bean发现中排除类型和依赖项。该quarkus.arc.exclude-types属性接受一个字符串值列表，该字符串值用于匹配应排除的类。

示例application.properties
quarkus.arc.exclude-types=org.acme.Foo,org.acme.*,Bar

• 排除类型org.acme.Foo。
• 从org.acme包装中排除所有类型。
• 排除所有简单名称为的类型 Bar

也有可能排除依赖项工件，否则将对其进行扫描以查找bean。例如，因为它包含一个beans.xml描述符。

示例application.properties

quarkus.arc.exclude-dependency.acme.group-id=org.acme  //值是由name标识的依赖项的组ID acme。
quarkus.arc.exclude-dependency.acme.artifact-id=acme-services //值是由name标识的依赖项的工件ID acme。

2.原生执行文件与私有成员

Quarkus使用GraalVM来构建本地可执行文件。GraalVM的局限性之一是反射的使用。支持反射操作，但必须为所有相关成员进行明确注册以进行反射。这些注册导致更大的本机可执行文件。

如果Quarkus DI需要访问私有成员，则必须使用反射。这就是为什么鼓励Quarkus用户不要在其bean中使用私有成员。这涉及注入字段，构造函数和初始化程序，观察者方法，生产者方法和字段，处理程序和拦截器方法。

如何避免使用私人会员？您可以使用package-private修饰符：

@ApplicationScoped
public class CounterBean {

    @Inject
    CounterService counterService; //程序包专用的注入字段。

    void onMessage(@Observes Event msg) { //包私有的观察者方法。
    }
}

或构造函数注入：

@ApplicationScoped
public class CounterBean {

    private CounterService service;

    CounterBean(CounterService service) { //包私有的构造函数注入。@Inject在这种情况下是可选的。
      this.service = service;
    }
}

3.支持的功能

• Programming modelManaged beans implemented by a Java class@PostConstruct and @PreDestroy lifecycle callbacksProducer methods and fields, disposersQualifiersAlternativesStereotypes
• Dependency injection and lookupField, constructor and initializer/setter injectionType-safe resolutionProgrammatic lookup via javax.enterprise.inject.InstanceClient proxiesInjection point metadata
• Scopes and contexts@Dependent, @ApplicationScoped, @Singleton, @RequestScoped and @SessionScopedCustom scopes and contexts
• InterceptorsBusiness method interceptors: @AroundInvokeInterceptors for lifecycle event callbacks: @PostConstruct, @PreDestroy, @AroundConstruct
• Events and observer methods, including asynchronous events and transactional observer methods

4、限制

• @ConversationScoped 不支持
• 不支持装饰器
• 不支持便携式扩展
• BeanManager-只有以下方法实现：getBeans()，createCreationalContext()，getReference()，getInjectableReference()，resolve()，getContext()，fireEvent()，getEvent()和createInstance()
• 不支持专业化
• beans.xml 描述符内容被忽略
• 不支持钝化和钝化作用域
• 超类上的拦截器方法尚未实现
• @Interceptors 不支持

5. 非标准功能

5.1. 尽早初始化 Beans

5.1.1. 默认是延迟创建

默认情况下，在需要时可以延迟创建CDI bean。确切“需要”的含义取决于bean的范围。

• 在注入实例上调用方法时，需要使用普通作用域的Bean（@ApplicationScoped，@RequestScoped等）（根据规范，上下文引用）。换句话说，注入普通作用域的Bean是不够的，因为注入了客户端代理而不是Bean的上下文实例。
• 阿与伪范围豆（@Dependent和@Singleton注射时被创建的）。

延迟实例化示例

@Singleton // => pseudo-scope
class AmazingService {
  String ping() {
    return "amazing";
  }
}

@ApplicationScoped // => normal scope
class CoolService {
  String ping() {
    return "cool";
  }
}

@Path("/ping")
public class PingResource {

  @Inject
  AmazingService s1; //注入触发的实例化AmazingService。

  @Inject
  CoolService s2; //注入本身不会导致的实例化CoolService。客户端代理被注入。

  @GET
  public String ping() {
    return s1.ping() + s2.ping(); //对注入的代理的第一次调用触发的实例化CoolService。
  }
}

5.1.2. Startup 事件

但是，如果您真的需要早创建 bean，则可以：

• 声明一个观察者StartupEvent-在这种情况下，bean的范围无关紧要：

@ApplicationScoped
class CoolService {
  void startup(@Observes StartupEvent event) { //CoolService在启动期间创建一个A来为观察者方法调用提供服务。
  }
}

• 在观察者中使用StartupEventBean-必须按照默认的Lazy中的描述使用正常作用域的Bean ：

@Dependent
class MyBeanStarter {

  void startup(@Observes StartupEvent event, AmazingService amazing, CoolService cool) { //在AmazingService被注射期间创建的。
    cool.toString(); //该CoolService是正常范围的bean所以我们所注射的代理来调用一个方法来强制实例化。
  }
}

• @io.quarkus.runtime.Startup按照Startup注释中的说明对bean进行注释：

@Startup //对于每个带有@Startup合成观察者注释的bean StartupEvent。使用默认优先级。
@ApplicationScoped
public class EagerAppBean {

   private final String name;

   EagerAppBean(NameGenerator generator) { //当应用程序启动并且结果上下文实例存储在应用程序上下文中时，将调用Bean构造函数。
     this.name = generator.createName();
   }
}

鼓励Quarkus用户始终喜欢@Observes StartupEvent，@Initialized(ApplicationScoped.class)如《应用程序初始化和终止》指南中所述。

5.2请求上下文生命周期

请求上下文也处于活动状态：(在通知同步观察者方法期间。)

请求上下文被破坏：(在事件的观察者通知完成之后，如果通知启动时该事件尚未处于活动状态。)

• @Initialized(RequestScoped.class)为观察者通知初始化请求上下文时，将触发 带有限定符的事件。而且，带有限定符@BeforeDestroyed(RequestScoped.class)和的事件
• @Destroyed(RequestScoped.class)会在请求上下文被销毁时触发。

5.3限定注入字段

在CDI中，如果声明字段注入点，则需要使用，@Inject并且还可以选择使用一组限定符。

  @Inject
  @ConfigProperty(name = "cool")
  String coolProperty;

在Quarkus中，@Inject如果注入的字段声明了至少一个限定符，则可以完全跳过注释。

  @ConfigProperty(name = "cool")
  String coolProperty;

除了下面讨论的一种特殊情况外，@Inject构造函数和方法注入仍然需要。

5.4简化构造注入

在CDI中，普通作用域的bean必须始终声明一个无参数的构造函数（该构造函数通常由编译器生成，除非您声明任何其他构造函数）。但是，此要求使构造函数注入变得复杂-您需要提供一个虚拟的无参数构造函数以使事情在CDI中运行。

@ApplicationScoped
public class MyCoolService {

  private SimpleProcessor processor;

  MyCoolService() { // dummy constructor needed
  }

  @Inject // constructor injection
  MyCoolService(SimpleProcessor processor) {
    this.processor = processor;
  }
}

不需要为Quarkus中的普通作用域bean声明伪构造函数-它们是自动生成的。另外，如果只有一个构造函数，则不需要@Inject。

@ApplicationScoped
public class MyCoolService {

  private SimpleProcessor processor;

  MyCoolService(SimpleProcessor processor) {
    this.processor = processor;
  }
}

如果Bean类扩展了未声明no-args构造函数的类，则我们不会自动生成no-args构造函数。

5.5. 删除未使用的 Beans

默认情况下，容器会尝试在构建过程中删除所有未使用的bean。可以通过将设置quarkus.arc.remove-unused-beans为none或来禁用此优化false。

未使用的bean：

• is not a built-in bean or an interceptor,
• is not eligible for injection to any injection point,
• is not excluded by any extension,
• does not have a name,
• does not declare an observer,
• does not declare any producer which is eligible for injection to any injection point,
• is not directly eligible for injection into any javax.enterprise.inject.Instance or javax.inject.Provider injection point

此优化适用于所有形式的bean声明：bean类，生产者方法，生产者字段。

用户可以通过用注释来指示容器不要删除任何特定的bean（即使它们满足上述所有规则）io.quarkus.arc.Unremovable。该注释可以放在类型，生产者方法和生产者字段上。

由于这并非总是可能的，因此可以选择使用相同的via application.properties。该quarkus.arc.unremovable-types属性接受一个字符串值列表，该字符串值用于根据其名称或包来匹配bean。

示例application.properties

quarkus.arc.unremovable-types=org.acme.Foo,org.acme.*,Bar

此外，扩展可以通过产生来消除可能的误报UnremovableBeanBuildItem。

最后，Quarkus为Bean除去优化提供了中间立场，在这种情况下，无论是否未使用应用Bean，都不会除去它们，而对于非应用程序类，优化通常会进行。要使用此模式，请设置quarkus.arc.remove-unused-beans为fwk或framework。

使用开发人员模式（运行./mvnw clean compile quarkus:dev）时，您可以通过中的以下行启用其他日志记录，从而查看有关要删除哪些bean的更多信息application.properties。

quarkus.log.category."io.quarkus.arc.processor".level=DEBUG

5.6默认 Beans

Quarkus增加了一个功能，CDI目前不支持是有条件地声明一个bean，如果用同等类型和限定词没有其他的bean被任何可用的手段（bean class, producer, synthetic bean, …）这是用做声明的@io.quarkus.arc.DefaultBean注解并用一个例子最好的解释。

假设有一个Quarkus扩展，除其他外，它声明了一些CDI bean，如以下代码所示：

@Dependent
public class TracerConfiguration {

    @Produces
    public Tracer tracer(Reporter reporter, Configuration configuration) {
        return new Tracer(reporter, configuration);
    }

    @Produces
    @DefaultBean
    public Configuration configuration() {
        // create a Configuration
    }

    @Produces
    @DefaultBean
    public Reporter reporter(){
        // create a Reporter
    }
}

这个想法是，该扩展程序可以自动为用户配置内容，从而消除了很多样板操作-我们可以在任何需要@Inject的Tracer地方进行操作。现在想象一下，在我们的应用程序中，我们想利用configure Tracer，但是我们需要对其进行一些自定义，例如，通过提供一个custom Reporter。在我们的应用程序中唯一需要的是类似以下内容的东西：

@Dependent
public class CustomTracerConfiguration {

    @Produces
    public Reporter reporter(){
        // create a custom Reporter
    }
}

@DefaultBean 允许扩展（或与此有关的任何其他代码）在退回的情况下提供默认值（如果以Quarkus支持的任何方式提供了该类型的bean）。

5.7根据Profile启用Beans

Quarkus通过@io.quarkus.arc.profile.IfBuildProfile和@io.quarkus.arc.profile.UnlessBuildProfile注释添加了CDI当前不支持的功能，即在启用Quarkus构建时间配置文件时有条件地启用Bean 。与结合使用时@io.quarkus.arc.DefaultBean，这些批注允许为不同的构建概要文件创建不同的bean配置。

想象一下，例如，一个应用程序包含一个名为的Bean Tracer，在测试或开发模式下，它无需执行任何操作，但可以正常工作以用于生产工件。创建此类bean的一种优雅方法如下：

@Dependent
public class TracerConfiguration {

    @Produces
    @IfBuildProfile("prod")
    public Tracer realTracer(Reporter reporter, Configuration configuration) {
        return new RealTracer(reporter, configuration);
    }

    @Produces
    @DefaultBean
    public Tracer noopTracer() {
        return new NoopTracer();
    }
}

如果相反，则要求TracerBean也可以在dev-mode下工作，并且仅默认不对测试进行任何操作，@UnlessBuildProfile则将是理想的。代码如下：

@Dependent
public class TracerConfiguration {

    @Produces
    @UnlessBuildProfile("test") // this will be enabled for both prod and dev build time profiles
    public Tracer realTracer(Reporter reporter, Configuration configuration) {
        return new RealTracer(reporter, configuration);
    }

    @Produces
    @DefaultBean
    public Tracer noopTracer() {
        return new NoopTracer();
    }
}

使用@IfBuildProfile和运行时配置文件绝对不会影响Bean的分辨率@UnlessBuildProfile。

5.8根据配置变量启用Beans

Quarkus通过@io.quarkus.arc.properties.IfBuildProperty和@io.quarkus.arc.properties.UnlessBuildProperty注释添加了CDI当前不支持的功能，即当Quarkus构建时间属性具有特定值时，有条件地启用Bean 。与结合使用时@io.quarkus.arc.DefaultBean，此批注允许为不同的构建属性创建不同的bean配置。

我们上面提到的场景Tracer也可以通过以下方式实现：

@Dependent
public class TracerConfiguration {

    @Produces
    @IfBuildProperty(name = "some.tracer.enabled", stringValue = "true")
    public Tracer realTracer(Reporter reporter, Configuration configuration) {
        return new RealTracer(reporter, configuration);
    }

    @Produces
    @DefaultBean
    public Tracer noopTracer() {
        return new NoopTracer();
    }
}

如果相反，则需要将RealTracer豆仅用于如果some.tracer.enabled属性不是false，那么@UnlessBuildProperty将是理想的。代码如下：

@Dependent
public class TracerConfiguration {

    @Produces
    @UnlessBuildProperty(name = "some.tracer.enabled", stringValue = "false")
    public Tracer realTracer(Reporter reporter, Configuration configuration) {
        return new RealTracer(reporter, configuration);
    }

    @Produces
    @DefaultBean
    public Tracer noopTracer() {
        return new NoopTracer();
    }

使用时，在运行时设置的属性绝对不会影响Bean的分辨率@IfBuildProperty。

5.9声明选择替代

在CDI中，可以通过全局为应用程序选择替代bean，也可以@Priority使用beans.xml描述符为bean归档选择替代bean 。Quarkus具有简化的bean发现，并且其内容beans.xml被忽略。

缺点@Priority是它具有@Target({ TYPE, PARAMETER })并且因此不能用于生产者方法和字段。为了解决这个问题并简化代码，Quarkus提供了io.quarkus.arc.AlternativePriority注释。基本上，这是@Alternativeplus的快捷方式@Priority。另外，它可以用于生产者。

但是，也可以使用统一配置为应用程序选择替代方案。该quarkus.arc.selected-alternatives属性接受用于匹配备用Bean的字符串值列表。如果有任何值匹配，则将优先级Integer#MAX_VALUE用于相关bean。通过@Priority或声明的优先级@AlternativePriority被覆盖。

示例application.properties

quarkus.arc.selected-alternatives=org.acme.Foo,org.acme.*,Bar

5.10简化的生产者方法声明

在CDI中，生产者方法必须始终使用注释@Produces。

class Producers {

  @Inject
  @ConfigProperty(name = "cool")
  String coolProperty;

  @Produces
  @ApplicationScoped
  MyService produceService() {
    return new MyService(coolProperty);
  }
}

在Quarkus中，@Produces如果生产者方法使用范围注释，构造型或限定符进行注释，则可以完全跳过注释。

class Producers {

  @ConfigProperty(name = "cool")
  String coolProperty;

  @ApplicationScoped
  MyService produceService() {
    return new MyService(coolProperty);
  }
}

5.11拦截静态方法

拦截器规范明确指出，围绕调用方法一定不能声明为静态。但是，此限制主要是由技术限制引起的。并且由于Quarkus是面向构建时的堆栈，允许进行其他类转换，因此这些限制不再适用。可以使用拦截器绑定来注释非私有静态方法：

class Services {

  @Logged Logged //是拦截器绑定。
  static BigDecimal computePrice(long amount) { //如果存在与关联的拦截器，则将拦截每个方法调用Logged。

    BigDecimal price;
    // Perform computations...
    return price;
  }
}

5.11.1局限性

• 只有方法级别绑定被认为是向后兼容的原因（否则bean类的静态方法，声明类级别的绑定将被突然截断）
• 永远不会拦截私有静态方法
• InvocationContext#getTarget()null有明显原因的退货；因此，在拦截静态方法时，并非所有现有的拦截器都可能正常运行(拦截器可以InvocationContext.getMethod()用来检测静态方法并相应地调整行为。)

5.12处理“final”类和方法的能力

在普通的CDI中，标记为final和/或具有final方法的类不符合创建代理的条件，这反过来意味着拦截器和常规作用域的Bean无法正常工作。当尝试将CDI与其他JVM语言（如Kotlin）一起使用时，这种情况非常普遍final，默认情况下，类和方法为。

但是，当quarkus.arc.transform-unproxyable-classes设置为true（默认值）时，Quarkus可以克服这些限制。

5.13Container-managed的并发

CDI bean没有标准的并发控制机制。但是，可以从多个线程同时共享和访问一个bean实例。在这种情况下，它应该是线程安全的。您可以使用标准的Java结构（volatile，synchronized，ReadWriteLock等）或让容器控制并发访问。Quarkus@io.quarkus.arc.Lock为这个拦截器绑定提供了一个内置的拦截器。与被拦截bean的上下文实例相关联的每个拦截器实例都拥有一个单独ReadWriteLock的非公平排序策略。(io.quarkus.arc.Lock是常规的拦截器绑定，因此可以用于具有任何作用域的任何bean。但是，它对于“共享”范围（例如@Singleton和）特别有用@ApplicationScoped。)

容器管理的并发示例

import io.quarkus.arc.Lock;

@Lock //1@Lock@Lock(Lock.Type.WRITE)在类上声明的（映射到）指示容器为任何业务方法的任何调用锁定Bean实例，即，客户端具有“独占访问权”，并且不允许进行并发调用。
@ApplicationScoped
class SharedService {

  void addAmount(BigDecimal amount) {
    // ...changes some internal state of the bean
  }

  //@Lock(Lock.Type.READ)覆盖在类级别指定的值。这意味着任何数量的客户端都可以并发调用该方法，除非bean实例被锁定@Lock(Lock.Type.WRITE)。
  //还可以指定“等待时间”。如果在给定时间内无法获取锁，LockException则抛出a。
  @Lock(value = Lock.Type.READ, time = 1, unit = TimeUnit.SECONDS)  
  BigDecimal getAmount() {
    // ...it is safe to read the value concurrently
  }
}

5.14可重复的拦截器绑定

Quarkus对@Repeatable拦截器绑定注释的支持有限。

将拦截器绑定到组件时，可以@Repeatable在方法上声明多个注释。不支持在类和构造型上声明的可重复拦截器绑定，因为围绕与Interceptors规范的交互存在一些未解决的问题。将来可能会添加。

例如，假设我们有一个清除缓存的拦截器。相应的拦截器绑定将被调用@CacheInvalidateAll并将被声明为@Repeatable。如果我们想同时清除两个缓存，我们将添加@CacheInvalidateAll两次：

@ApplicationScoped
class CachingService {
  @CacheInvalidateAll(cacheName = "foo")
  @CacheInvalidateAll(cacheName = "bar")
  void heavyComputation() {
    // ...
    // some computation that updates a lot of data
    // and requires 2 caches to be invalidated
    // ...
  }
}

这就是拦截器的使用方式。如何创建拦截器？

在声明拦截器的拦截器绑定时，您可以@Repeatable像往常一样向拦截器类添加多个注释。当注释成员为时，这是没有用的@Nonbinding，就像@Cached注释的情况一样，但否则很重要。

例如，假设我们有一个拦截器，它可以自动将方法调用记录到某些目标。拦截器绑定批注@Logged将具有一个名为的成员target，该成员指定将日志存储在何处。我们的实现可能仅限于控制台日志记录和文件日志记录：

@Interceptor
@Logged(target = "console")
@Logged(target = "file")
class NaiveLoggingInterceptor {
  // ...
}

可以提供其他拦截器，以将方法调用记录到不同的目标。

6.构建时间扩展

Quarkus整合了构建时间优化，以提供即时启动和低内存占用。这种方法的缺点是不能支持CDI便携式扩展。但是，大多数功能可以使用Quarkus extensions来实现。有关更多信息，请参见集成指南。

7.开发模式

在开发模式下，将自动注册两个特殊的端点，以JSON格式提供一些基本的调试信息：

• HTTP GET-/q/arc返回摘要；Bean数，配置属性等。
• HTTP GET-/q/arc/beans返回所有bean的列表您可以使用查询参数来过滤输出：scope -包含范围以给定值结尾的bean，即 http://localhost:8080/q/arc/beans?scope=ApplicationScopedbeanClass -包含以给定值开头的bean类的bean，即 http://localhost:8080/q/arc/beans?beanClass=org.acme.Fookind-包括指定的种（豆CLASS，PRODUCER_FIELD，PRODUCER_METHOD，INTERCEPTOR或SYNTHETIC），即http://localhost:8080/q/arc/beans?kind=PRODUCER_METHOD
• HTTP GET-/q/arc/removed-beans返回在构建过程中删除的未使用bean的列表
• HTTP GET-/q/arc/observers返回所有观察者方法的列表

这些端点仅在开发模式下可用，即，当您通过mvn quarkus:dev（或./gradlew quarkusDev）运行应用程序时。

8ArC配置参考

在构建时固定了配置属性-在运行时可覆盖所有其他配置属性