在局部发育过程中用夸克注入不同的bean

Question

我读过这个帖子：https://quarkus.io/blog/quarkus-dependency-injection/。在这篇StackOverflow文章中也提到了这个过程：如何覆盖Quarkus中的CDI bean进行测试？。最后一篇文章说，“Create bean in test directory”。

我的问题略有不同。我想在“开发”时注入一个bean。在生产过程中，我希望注入默认bean。从文档上看，我看不出有什么办法让应用程序做出这种区分。

如果我有一个像这样的默认类：

@DefaultBean
@ApplicationScoped
class ProdProvider : SomeProvider {}

@Alternative
@Priority(1)
class DevProvider : SomeProvider {}

在一个例子中，我有一个credential provider类，它在本地开发时设置Google的PubSub仿真器。在生产中，我使用一个实现相同接口的类，但却是一个真正的凭据提供程序。但是,导致我提出这个问题的特定案例是一个实现一个方法的类：

@ApplicationScoped
class VaultLoginJwtProvider : LoginJwtProvider {
  @ConfigProperty(name = "vault.tokenPath")
  private val jwtPath: String? = null

  companion object {
    val logger: Logger = LoggerFactory.getLogger("VaultTokenProvider")
  }

  override fun getLoginJwt(): Optional<String> {
    logger.info("Using Vault Login JWT")

    return try {
      Optional.of(String(Files.readAllBytes(Paths.get(jwtPath))).trim { it <= ' ' })
    } catch (e: Exception) {
      logger.error("Could not read vault token at $jwtPath")
      logger.error(e.printStackTrace().toString())
      Optional.empty()
    }
  }
}

通过构造函数注入将该类注入到另一个类中：

@Singleton
class JwtServiceImpl(
  @RestClient val vaultClient: VaultClient,
  @Inject val loginJwtProvider: LoginJwtProvider
) {
  private var serviceJwt: String? = null

  companion object {
    val logger: Logger = LoggerFactory.getLogger("JwtServiceImpl")
  }

  private fun getLoginToken(): String? {
    val vaultLogin = VaultLogin(
      role = "user-service",
      jwt = loginJwtProvider.getLoginJwt().get()
    )

    val loginResponse = vaultClient.login(vaultLogin)

    return loginResponse.auth.clientToken
  }
}

我想在开发中注入更多的“模拟”类，它只返回一个静态字符串。我可以使用ProfileManager.getActiveProfile()，但这使我将开发问题混入了我的逻辑中。我不觉得这在我编译的生产代码中有任何位置。

Answer 1

我的解决方案是在@javax.ws.rs.ext.Provider中自己创建最后一个bean。不像Micronaut@所要求的那么优雅，但好吧，它起作用了。

请注意，SomeProvider的实例不是一个“bean”，您必须自己关心生命周期（依赖注入、PostConstruct，没有PreDestroy,……)。

org.acme.someProvider.java

package org.acme;

import javax.enterprise.context.ApplicationScoped;

public interface SomeProvider {

  void providerMethod();

  @ApplicationScoped
  class ProdProviderRequirement {
    void foo() {}
  }

  class ProdProvider implements SomeProvider {

    private final ProdProviderRequirement prodProviderRequirement;

    ProdProvider(final ProdProviderRequirement prodProviderRequirement) {
      this.prodProviderRequirement = prodProviderRequirement;
    }

    @Override
    public void providerMethod() {
      prodProviderRequirement.foo();
    }
  }

  class DevProvider implements SomeProvider {
    @Override
    public void providerMethod() {}
  }
}

package org.acme;

import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.inject.Produces;
import javax.inject.Inject;
import javax.ws.rs.ext.Provider;
import org.acme.SomeProvider.DevProvider;
import org.acme.SomeProvider.ProdProvider;
import org.acme.SomeProvider.ProdProviderRequirement;

@Provider
class SomeProviderFactory {

  SomeProvider someProvider;

  @Inject
  SomeProviderFactory(final ProdProviderRequirement prodProviderRequirement) {
    final var someCondition = true;
    someProvider = someCondition ? new DevProvider() : new ProdProvider(prodProviderRequirement);
  }

  @Produces
  @ApplicationScoped
  SomeProvider someProvider() {
    return someProvider;
  }
}