Lors du développement d’une application, il est très fréquent d’avoir plusieurs implémentations d’un service, et de devoir sélectionner l’une où l’autre en fonction de l’environnement sur lequel elle est déployée.

Un exemple classique : un service qui appelle une API d’un partenaire externe qu’on veut appeler uniquement en production, et donc mocker sur les environnements de développement et de test / UAT / staging.

Quarkus essaye de déporter au build time, via son plugin Maven ou Gradle, le plus de choses possibles. Entre autre, il découvre les beans CDI au build time, et ne va instancier que ceux nécessaire au runtime.

Pour pouvoir sélectionner un bean, on a la possibilité d’utiliser l’annotation @IfBuildProfile, l’annotation @IfBuildProperty, ou les alternatives CDI. Mais ces solutions vont sélectionner le bean au build time! Celà permet d’avoir un bean différent pour les tests unitaires ou le dev mode mais pas une fois que l’application a été construite. Pour utiliser ce mécanisme pour sélectionner un bean différent sur un environement UAT/staging et sur la prod, il faudrait builder plusieurs packages de l’application.

Sélectionner un bean au runtime reste possible en utilisation une Instance CDI, cela nécessite quelques lignes de code.

Voici comment faire.

Etape 1 : ajouter une propriété dans votre application.properties

service.implementation-name=mock

Etape 2 : annoter vos deux implémentations avec un qualifier CDI, ici on utilisera @Named mais Quarkus propose aussi @Identifier.

@ApplicationScoped
@Named("mock")
public class MockService implements RemoteService {
    // ....
}

@ApplicationScoped
@Named("real")
public class RealService implements RemoteService {
    // ....
}

Etape 3 : dans la classe utilisant votre service, sélectionner le bean au démarrage de l’application en vous basant sur la configuration de l’application.

@Path("/api")
public class MyEndpoint {
    @ConfigProperty(name="service.implementation-name") String implementationName;
    @Inject Instance<RemoteService>remoteServiceInstance;
    
    private RemoteService remoteService;

    @PostConstruct
    void init() {
        remoteService = remoteServiceInstance
            .select(NamedLiteral.of(implementationName)).get();
    }

    // ...
}

MISE A JOUR : Martin Kouba (merci à lui) a proposé une implémentation plus courte et clair, via injection dans le constructeur (ce que, à ma grand honte, je ne suis pas du tout familier). Je vous met donc ci-dessous une étape 3 avec un code simplifié :

@Path("/api")
public class MyEndpoint {   
   private final RemoteService remoteService;

   MyEndpoint(@ConfigProperty(name="service.implementation-name") String implName, 
         Instance<RemoteService> remoteServiceInstance) {
     remoteService = remoteServiceInstance.select(NamedLiteral.of(implName)).get();
   }

    // ...
}

Attention : les définitions (metadata) deux beans MockService et RemoteService seront créées et resterons en mémoire tout au long de la vie de votre application, même si uniquement l’un des deux sera utilisé. Elles ne seront pas supprimées automatiquement par Arc, l’implémentation CDI de Quarkus, via son mécanisme de suppression de bean inutilisé. Les beans quand à eux, s’ils utilisent un scope normal, seront créé de manière lazy.

Conclusion : même si sélectionner un bean au runtime va à l’encontre de la philosophie de Quarkus, c’est bien souvent une nécessité et cela reste possible via quelques lignes de code. Comme c’est quelque chose de classique, je vais évoquer le point avec la communauté Quarkus pour qu’on trouve quelque chose de plus pratique, stay tuned 😉

MISE A JOUR : J’ai depuis évoqué le point avec la communauté Quarkus et une solution plus pratique que l’utilisation de instance.select() a été implémentée grâce aux annotations @LookupIfProperty et @LookupUnlessProperty qui permettent d’ajouter, pour chaque bean, une condition pour leur sélection en fonction d’une propriété de configuration.

On peut donc remplacer les étapes 2 et 3 précédentes par celles-ci :

Etape 2 : annoter vos deux implémentations avec @LookupIfProperty.

@ApplicationScoped
@LookupIfProperty(name = "service.implementation-name", stringValue = "mock")
public class MockService implements RemoteService {
    // ....
}

@ApplicationScoped
@LookupIfProperty(name = "service.implementation-name", stringValue = "real")
public class RealService implements RemoteService {
    // ....
}

Etape 3 : dans la classe utilisant votre service, le bean doit être obtenu au démarrage via la méthode get() de l’instance. La présence de l’annotation @LookupIfProperty sur les deux implémentations fera que seul le bean de type MockService sera créé car la valeur de la propriété service.implementation-name utilisé dans son instance de @LookupIfProperty est mock.

@Path("/api")
public class MyEndpoint {
    @Inject Instance<RemoteService>remoteServiceInstance;
    
    private RemoteService remoteService;

    @PostConstruct
    void init() {
        remoteService = remoteServiceInstance.get();
    }

    // ...
}