Dependency Injection of Primitive Types (Decided at Runtime) With HK2

Question

So basically, I have a situation where I want to inject primitive types into a class (i.e. a String and an Integer). You can think of a URL and port number for an application as example inputs. I have three components:

Now say I have a class, which does take in these params:

public class PrimitiveParamsDIExample {

  private String a;
  private Integer b;

  public PrimitiveParamsDIExample(String a, Integer b) {
    this.a = a;
    this.b = b;
  }
}

So my question here is simple. How do I inject a and b into class PrimitiveParamsDIExample?

In general, this is also asking how to inject parameters that are decided on runtime as well. If I have a and b above, read from STDIN or from an input file, they're obviously going to be different from run to run.

All the more, how do I do the above within the HK2 framework?

EDIT[02/23/15]: @jwells131313, I tried your idea, but I'm getting the following error (this one for the String param; similar one for int):

org.glassfish.hk2.api.UnsatisfiedDependencyException: There was no object available for injection at Injectee(requiredType=String,parent=PrimitiveParamsDIExample,qualifiers

I set up classes exactly as you did in your answer. I also overrode the toString() method to print both variables a and b in PrimitiveParamsDIExample. Then, I added the following in my Hk2Module class:

public class Hk2Module extends AbstractBinder {
    private Properties properties;

    public Hk2Module(Properties properties){
      this.properties = properties;
    }

    @Override
    protected void configure() {
          bindFactory(StringAFactory.class).to(String.class).in(RequestScoped.class);
          bindFactory(IntegerBFactory.class).to(Integer.class).in(RequestScoped.class);
          bind(PrimitiveParamsDIExample.class).to(PrimitiveParamsDIExample.class).in(Singleton.class);
    }
}

So now, I created a test class as follows:

@RunWith(JUnit4.class)
public class TestPrimitiveParamsDIExample extends Hk2Setup {

    private PrimitiveParamsDIExample example;

    @Before
    public void setup() throws IOException {
        super.setupHk2();
        //example = new PrimitiveParamsDIExample();
        example = serviceLocator.getService(PrimitiveParamsDIExample.class);
    }

    @Test
    public void testPrimitiveParamsDI() {
        System.out.println(example.toString());
    }
}

where, Hk2Setup is as follows:

public class Hk2Setup extends TestCase{
    // the name of the resource containing the default configuration properties
    private static final String DEFAULT_PROPERTIES = "defaults.properties";
    protected Properties config = null;
    protected ServiceLocator serviceLocator;
    public void setupHk2() throws IOException{
        config = new Properties();
        Reader defaults = Resources.asCharSource(Resources.getResource(DEFAULT_PROPERTIES), Charsets.UTF_8).openBufferedStream();
        load(config, defaults);
        ApplicationHandler handler = new ApplicationHandler(new MyMainApplication(config));
        final ServiceLocator locator = handler.getServiceLocator();
        serviceLocator = locator;
    }

    private static void load(Properties p, Reader r) throws IOException {
        try {
            p.load(r);
        } finally {
            Closeables.close(r, false);
        }
    }
}

So somewhere, the wiring is messed up for me to get an UnsatisfiedDependencyException. What have I not correctly wired up?

Thanks!

Answer 1

There are two ways to do this, but one isn't documented yet (though it is available... I guess I need to work on documentation again...)

I'll go through the first way here.

Basically, you can use the HK2 Factory.

Generally when you start producing Strings and ints and long and scalars like this you qualify them, so lets start with two qualifiers:

@Retention(RUNTIME)
@Target( { TYPE, METHOD, FIELD, PARAMETER })
@javax.inject.Qualifier
public @interface A {}

and

@Retention(RUNTIME)
@Target( { TYPE, METHOD, FIELD, PARAMETER })
@javax.inject.Qualifier
public @interface B {}

then write your factories:

@Singleton // or whatever scope you want
public class StringAFactory implements Factory<String> {

    @PerLookup // or whatever scope, maybe this checks the timestamp?
    @A // Your qualifier
    public String provide() {
        // Write your code to get your value...
        return whatever;
    }

    public void dispose(String instance) {
        // Probably do nothing...
    }
}

and for the Integer:

@Singleton // or whatever scope you want
public class IntegerBFactory implements Factory<Integer> {

    @PerLookup // or whatever scope, maybe this checks the timestamp?
    @B // Your qualifier
    public Integer provide() {
        // Write your code to get your value...
        return whatever;
    }

    public void dispose(String instance) {
        // Probably do nothing...
    }
}

Now lets re-do your original class to accept these values:

public class PrimitiveParamsDIExample {

  private String a;
  private int b;

  @Inject
  public PrimitiveParamsDIExample(@A String a, @B int b) {
    this.a = a;
    this.b = b;
  }
}

Note I changed Integer to int, well... just because I can. You can also just use field injection or method injection in the same way. Here is field injection, method injection is an exercise for the reader:

public class PrimitiveParamsDIExample {
  @Inject @A
  private String a;

  @Inject @B
  private int b;

  public PrimitiveParamsDIExample() {
  }
}

There are several ways to bind factories.

In a binder: bindFactory

Using automatic class analysis: addClasses

An EDSL outside a binder: buildFactory