inject configurable interface-implementation

[aremund]

We introduced Quarkus since a few weeks for our application and are very happy with it. I would like some guidance on how to best solve a very common requirement.

Setup

• We build our application once (with maven) and deploy it in different environments (e.g. dev, test & prod)
• Depending on the environment, we want to inject the "Mock"-implementation or the "Productive"-implemenation of an interface

Solutions

Since we deploy the same build in different environments, solutions with @IfBuildProfile, @UnlessBuildProfile, @IfBuildProperty or @UnlessBuildProperty do not work for us.
We have successfully tested the following implementations.

Property

We can control via the property quarkus.arc.selected-alternatives which implementation of an interface is instantiated. This property can be set depending on the environment.

@Typed

We annotate the implementations with @Typed and set the class of the implementation as value.
We write a producer-class for the interface which injects all implementations of the interface in own private variables. In the producer-implementation we read the configuration and return the respective injected implementation.

@ApplicationScoped
@Typed(GreetingServiceEnglish.class)
public class GreetingServiceEnglish implements GreetingService

@ApplicationScoped
@Typed(GreetingServiceFrench.class)
public class GreetingServiceFrench implements GreetingService

@ApplicationScoped
public class GreetingServiceProducer {

    private final Instance<GreetingServiceEnglish> greetingServiceEnglish;
    private final Instance<GreetingServiceFrench> greetingServiceFrench;

    @ConfigProperty(name = "service.language") 
    GreetingLanguage serviceLanguage;

    public GreetingServiceProducer(Instance<GreetingServiceEnglish> greetingServiceEnglish, Instance<GreetingServiceFrench> greetingServiceFrench) {
        this.greetingServiceEnglish = greetingServiceEnglish;
        this.greetingServiceFrench = greetingServiceFrench;
    }
    
    @Produces
    public GreetingService produceAdapter() {
        return switch (serviceLanguage) {
            case ENGLISH -> greetingServiceEnglish.get();
            case FRENCH -> greetingServiceFrench.get();
        };
    }

}

@Named

We annotate the implementations of the interface with @Named and set a String as the value.
We create a class extending AnnotationLiteral with Named implementing Named.
We create a producer-class in which an Instance of the interface is injected with @Any. In the producer-method, depending on the configuration we create the correct object of the extended AnnotationLiteral and use this to select the respective instance and get the instantiated object. Also, the producer-method needs to be annotated with @Alternative and @Priority(1) so that the producer method is selected when the interface is injected in a resource.

@ApplicationScoped
@Named("ENGLISH")
public class GreetingServiceEnglish implements GreetingService

@ApplicationScoped
@Named("FRENCH")
public class GreetingServiceFrench implements GreetingService

public class GreetingLanguageLiteral extends AnnotationLiteral<Named> implements Named {
    private final String value;

    private GreetingLanguageLiteral(String value) {
        this.value = value;
    }

    public static Named of(ServiceLanguage value) {
        return new GreetingLanguageLiteral(value.name());
    }

    @Override
    public String value() {
        return value;
    }
}

@ApplicationScoped
public class GreetingServiceProducer {

    @Inject
    @Any
    Instance<GreetingService> greetingServices;
	
    @ConfigProperty(name = "service.language") 
    ServiceLanguage serviceLanguage;
	
    @Produces
    @ApplicationScoped
    @Alternative
    @Priority(1)
    public GreetingService produceAdapter() {
        return greetingServices.select(GreetingLanguageLiteral.of(serviceLanguage)).get();
    }
}

Qualifier interface

We created an own Qualifier-annotation which has an ENUM as value.
We created a class extending the AnnotationLiteral with our enum implementing the annotation.
We create a producer-class in which an Instance of the interface is injected. In the producer-method, depending on the configuration we create the correct object of the extended AnnotationLiteral and use this to select the respective instance and get the instantiated object.

@ApplicationScoped
@GreetingServiceType(GreetingLanguage.ENGLISH)
public class GreetingServiceEnglish implements GreetingService

@ApplicationScoped
@GreetingServiceType(GreetingLanguage.FRENCH)
public class GreetingServiceFrench implements GreetingService

@Qualifier
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER})
public @interface GreetingServiceType {

    GreetingLanguage value();

}

public class GreetingLanguageLiteral extends AnnotationLiteral<GreetingServiceType> implements GreetingServiceType {

    private final GreetingLanguage greetingLanguage;

    public GreetingLanguageLiteral(GreetingLanguage greetingLanguage) {
		this.greetingLanguage = greetingLanguage;
	}
    
    @Override
    public GreetingLanguage value() {
        return greetingLanguage;
    }

}

@ApplicationScoped
public class GreetingServiceProducer {

    private final Instance<GreetingService> greetingServices;

    public GreetingServiceProducer(Instance<GreetingService> greetingServices) {
        this.greetingServices = greetingServices;
    }

    @ConfigProperty(name = "service.language") 
    GreetingLanguage serviceLanguage;

    @Produces
    public GreetingService produceAdapter() {
        return greetingServices.select(new GreetingLanguageLiteral(serviceLanguage)).get();
    }
    
}

Question

Which of the above solutions is the canonical one?
Is there another approach/pattern which we do not see?

[quarkus-bot[bot]]

/cc @radcortez (config)