Is there any way to ask Weld SE to inject a specific implementation at a given time? - weld

Question

I use Weld SE in an application, in my application I have an interface for which I have 3 implementations but this causes an ambiguity for Weld. As far as I can see Weld ambiguity resolution technics are static, this can be done by mean of: #specialize, #alternative, #Named or using Qualifier. but this doesn't help me. I need to be able specify a given class implementation of the interface for each case.
I couldn't figure out a solution for my requirement.
Here is a code that illustrates my point
public class Foo {
#Inject
MyInterface target;
public void doSomething() {
target.doIt();
}
}
public class Bar1 implements MyInterface {
public void doIt() {
System.out.println("Hello");
}
}
public class Bar2 implements MyInterface {
public void doIt() {
System.out.println("Goodbye");
}
}
public class FooMain {
public static void main(String[] args) {
Weld weld = new Weld();
final WeldContainer container = weld.initialize();
Foo foo1 = container.instance().select(Foo.class).get();
Foo foo2 = container.instance().select(Foo.class).get();
}
}
This code causes this exception :
Exception in thread "main" org.jboss.weld.exceptions.DeploymentException: WELD-001409: Ambiguous dependencies for type MyInterface with qualifiers #Default
at injection point [BackedAnnotatedField] #Inject com.lodh.arte.test.cdi.Foo.target
at com.lodh.arte.test.cdi.Foo.target(Foo.java:0)
Possible dependencies:
- Managed Bean [class com.lodh.arte.test.cdi.Bar2] with qualifiers [#Any #Default],
- Managed Bean [class com.lodh.arte.test.cdi.Bar1] with qualifiers [#Any #Default]
I need to dynamically tell Weld which implementation to use for injection, just like in this imaginary method Weld.use:
Weld.use ( MyInterface.class, Bar1.class);
Foo foo1 = container.instance().select(Foo.class).get();
Weld.use ( MyInterface.class, Bar2.class);
Foo foo2 = container.instance().select(Foo.class).get();
Thank you for your help
Regards
Nader

Answer 1

First you have two implementations of MyInterface. Bar1 and Bar2. Weld does not know which implementation to choose when injecting MyInterface, so it throws this "Ambiguous dependencies" error.
To avoid this error you should give your implementation different qualifiers.
You have to Qualify your implementations first:
#MyQualifier1
public class Bar1 implements MyInterface {
(...)
}
#MyQualifier2
public class Bar2 implements MyInterface {
(...)
}
This will allow to inject a specific implementation like this:
#Inject
#MyQualifier1
MyInterface target;
Now you're injecting an MyInterface qualified with #MyQualifier1. At runtime its Type will be Bar1 in this case.
Another approach if you want to decide at runtime which implementation you need would be the use of Instance:
#Inject
Instance<MyInterface> unqualifiedInstance;
void do(){
/// first attach the qualifier, we missed at the injection-point:
Instance qualifiedInstance = instance.select(new AnnotationLiteral<MyQualifier2>(){})
/// Now you have a qualified Instance, which is a new Object without touching the unqualifiedInstance!
MyInterface target = qualifiedInstance.get();
/// so you can decide which implementation you need by passing the qualifier per select-method. in this case its bar2
target.doIt();
}
If you need further help with qualifiers you may find the weld documentation and especially chapter 4.3 and the following helpful.
http://docs.jboss.org/weld/reference/latest/en-US/html/injection.html