CODEWITHSUNDEEP
androiddependency-injectiondagger
Christian Ammann
Christian Ammann

Reputation: 938

Android Dagger 2: Inject versus Provides

I have a question regarding Android Dagger 2 und the usage of @Inject and @Provide annotations. Given are the following two simplified examples:

public class A {
  String msg;

  public A(String msg){
    this.msg = msg;
  }
}

public class B {
  public A a;

  public B(A a){
    this.a = a;
  }
}

@Module
public class AModule {
  @Provides
  A providesA(){
    return new A("blah");
  }

  @Provides
  B ProvidesB(A a)
  {
    return new B(a);
  }
}

The example is pretty straight forward, I have two methods in my AModule with @Provides annotations. Therefore, Dagger can create an object of B using an instance of A with the string blah.

My second example looks like this:

public class A {
  String msg;

  public A(String msg){
    this.msg = msg;
  }
}

public class B {
  public A a;

  @Inject
  public B(A a){
    this.a = a;
  }
}

@Module
public class AModule {
  @Provides
  A providesA(){
    return new A("blah");
  }
}

In this example, Dagger can create an instance of B because an object A can be created using AModule. The instance of B can be created because it's constructor uses the @Inject annotation.

So my question is: What's the difference between those two examples? Both seem to have the same semantics. Does the generated code differ and are there any pitfalls? Or is it just a matter or personal taste or best practices?

Upvotes: 32

Views: 8597

Answers (1)

Jeff Bowman
Jeff Bowman

Reputation: 95634

They work similarly, and the @Inject style is preferred when you have such an easy choice like in your example. However, this isn't always the case:

  • If B, which consumes A, is not under your control and not DI-aware, you will have no way to add the @Inject annotation.
  • If B is an interface, you will need @Provides (or @Binds in newer Dagger versions) to identify which implementation to use.
  • If you choose not to use your Dagger object graph for every injected parameter, you can call the constructor manually whether it is marked @Inject or not. This might be the case if you want a specific instance or constant as a constructor parameter, but you can't or don't want to set up the binding for the whole object graph.

@Provides allows you to effectively create a factory method, with everything that allows. This is a great way to change which instances are included in your graph, or to effectively add to the class's constructor graph-wide if you can't (or shouldn't) change the class itself.

  • You can return an existing instance rather than a new one. Note that custom scopes (implemented in Dagger through subcomponents) might be a better fit for common cases, but if you have more complex instance control or use a third-party library that controls instances, you could put that into your factory method.
  • If you want your binding to return null sometimes that logic can live in a @Provides method. Make sure you annotate the injection sites as @Nullable.
  • You can choose between implementations with a factory method like a @Provides method, particularly if the choice depends on runtime environment.
  • You can run post-construction logic, including instance registration or initialization.

Upvotes: 30

Related Questions