Inject: Example to use Constructor in Module without instance..

[narcoticfresh]

Hi guys..

First, thanks for the great work in this project! I only use inject for now and I like it a lot!

So I struggle with something that seems very basic: I want to generate a binding for an Instance that has a Constructor with 1 Dependency - but without using/referencing the instance itself. Just with the Class - just using reflection..

Seems simple?

The use case

Let's say we have this class that needs injection

public class MyClass {
  private final MyDepInterface dep;
  public MyClass(MyDepInterface dep) {
    this.dep = dep;
  }
}

And what we want to inject is an implementation of MyDepInterface

public class MyDepImpl implements MyDepInterface {
}

Create a binding?

Via annotation? - How?

First of all, my first question:

• I found no doc nor no nothing how to generate a binding for this using annotation?
  I cannot put the @Provides annotation on the class nor Constructor. What is the approach to just generate bindings from existing Classes having only Constructor dependencies? Adding @Inject to the constructor does not seem to generate a correct binding in the case of an Interface dependency..

Programmatic

So ok, I couldn't solve it by annotations, I created a Module that scans the classpath for matching classes and tries to generate a binding..

ModuleBuilder builder = ModuleBuilder
  .create();

Class<?> clazz = classInfo.load(); // this is a Class for MyClass - the dependency MyDepImpl is bound.

// how to add a binding from 'clazz' to MyClass::new(MyDepImpl.class) - just with the Class?
// i tried this: 
Constructor<?> cons = clazz.getConstructor(MyDepImpl.class);
builder.bind(clazz).to(cons, Key.of(MyDepImpl.class));

// which obviously shows:
// Cannot resolve method 'to(Constructor<capture of ?>, Key<T>)'

So maybe it's so obvious I cannot see it, but I really tried to go through all the docs and search the issues and discussions - I couldn't find anything(?).. also, there seems to be no documentation of to use all those Constructor0...6|N FunctionalInterfaces.. A small doc page to that would be great! ;-)

Thanks so much!

[eduard-vasinskyi]

Hi, @narcoticfresh

I do not quite get the part where you need to create the binding without using/referencing the instance itself, but we actually have an example for injecting a class using an interface dependency. The example is not featured on a website, we will add it to the website documentation soon.

Take a look at the Application class. It has a single dependency to the MessageSender interface. In ApplicationModule we configure the required bindings. First binding is:

bind(MessageSender.class).to(ConsoleMessageSenderImpl.class);

We instruct the injector that whenever the MessageSender interface is required, we would actually use a ConsoleMessageSenderImpl implementation.

Another binding is:

bind(Application.class).to(Application::new,MessageSender.class);

We “teach” the injector that in order to create an instance of Application class it would need to call its constructor (Application::new) which requires a single argument of a type MessageSender.class (which is an interface).

This example covers the basic use-case for creating an instance with interface dependencies. If for some reason, you still need to use a reflection to create an instance of your class, you can do so like this, for example:
Substitute

bind(Application.class).to(Application::new,MessageSender.class);

with

bind(Application.class).to(messageSender -> {
  try {
     return Application.class
           .getConstructor(MessageSender.class)
           .newInstance(messageSender);
  } catch (InstantiationException |
         IllegalAccessException |
         InvocationTargetException |
         NoSuchMethodException e) {
     throw new RuntimeException(e);
  }
}, MessageSender.class);

Just make sure to change the Application class to be public and static, as well as its constructor to be a public one in order to make the example work.

Alternatively, if you can modify a class that you want to instantiate, you could put an @Inject annotation on Application(MessageSender) constructor and simply replace the binding:

bind(Application.class).to(Application::new,MessageSender.class);

with

bind(Application.class);

This binding informs the injector about the existence of the Application class, so that it is scanned and corresponding bindings are generated out of @Inject annotation.

[narcoticfresh]

Hi @eduard-vasinskyi
Thanks for your help!

Let's see those 2 approaches:

Construct myself

bind(Application.class).to(messageSender -> {
  try {
     return Application.class
           .getConstructor(MessageSender.class)
           .newInstance(messageSender);
  } catch (InstantiationException |
         IllegalAccessException |
         InvocationTargetException |
         NoSuchMethodException e) {
     throw new RuntimeException(e);
  }
}, MessageSender.class);

That's what I did first.. but obviously, any instance injections will not be processed this way.. That may be not a problem anymore though as I tried to loose those and consolidate into a constructor dependency.

I guess this approach could be combined with an instance injector if needed(?)..

That is totally doable, but I would prefer a binding based solution.

Preferred approach

So as you rightly point out in this snippet:

bind(Application.class).to(Application::new, MessageSender.class);

I'm basically trying to construct the function reference to Application::new via reflection. That seems to be my basic struggle. And my search suggests that it's impossible to construct.

I tried to fiddle around to convert a java.lang.reflect.Constructor instance to something that can figure as one of the FunctionalInterfaces in Constructors - but to no use..

Why would that be needed?

The background is as follows: I have n classes in the classpath that implement a certain interface. A transient injection returns 1 of those implementation based on a System.property() that could change at any time at runtime. So i check the property value and return a given instance. That's why I use reflection to get the Class.

Outcome

Now, as you say - yes, I could make the instance myself. But I'm looking for a binding based solution.

Do you see any way to construct a "function reference" (as in Application::new) via reflection - or you maybe see any possibility to expand the Injector DSL so it could support reflection entities?

[eduard-vasinskyi]

We have added an API to generate a binding out of Java’s constructor. The added method is ModuleBuilder0#to(java.lang.reflect.Constructor). We have also added a test that you can use as a reference. You can find those in the master branch.

The added method will be part of ActiveJ v5.5 release. For now, you can write a binding manually like this:

Constructor<Application> constructor = Application.class.getConstructor(MyInterface.class);
Key<Application> key = Key.of(constructor.getDeclaringClass());
Binding<Application> binding = ReflectionUtils.bindingFromConstructor(key, constructor);
bind(Application.class).to(binding);

[narcoticfresh]

Wow, @eduard-vasinskyi - great! thanks so much!
As you replied inline, I will mark your previous reply as answer; it also answers the question..