Java dependency injection: Dagger 1 vs Dagger 2, which is better?

java android dependency-injection dagger dagger-2
Ognyan picture Ognyan · Jul 11, 2015 · Viewed 8.6k times · Source

What are the advantages of Dagger 2 over Dagger 1?

So far I found (just) 2:

  • Dagger 2 allows you to use code obfuscation with proguard
  • Dagger 2 is faster (which is not much of an advantage when using it for android application but it is sure an important thing if you use it for some kind of server)

In the same time I found one big disadvantage: you cannot have module overrides (@Module(overrides = true)) in Dagger 2, which is largely annoying at least for me - it was very useful for unit test.

Are there other advantages / disadvantages?

Answer

snafu109 picture snafu109 · Jan 29, 2016

Some advantages and disadvantages taken from https://blog.gouline.net/2015/05/04/dagger-2-even-sharper-less-square/ and http://google.github.io/dagger/dagger-1-migration.html:

Advantages of Dagger 2:

  • No more reflection - everything is done as concrete calls (ProGuard works with no configuration at all)
  • No more runtime graph composition - improves performance, including the per-request cases
  • Traceable - better generated code and no reflection help make the code readable and easy to follow
  • Supports method injection in addition to field and constructor injection which were the only two types supported by Dagger 1
  • Modules require less configuration than Dagger 1
  • Allows users to use any well-formed scope annotation. Dagger 1 only supported a single scope: @Singleton.

And disadvantages:

  • The inject() method now has a strong type association with the injection target. This is good for debugging, but it complicates a common practice of injecting from base classes (e.g. base activities, fragments etc).
  • Component implementation requires rebuilding the project to appear and any injection-related compile errors result in the class disappearing (i.e. not being generated).
  • Doesn't support overrides. Modules that override for simple testing fakes can create a subclass of the module to emulate that behavior. Modules that use overrides and rely on dependency injection should be decomposed so that the overriden modules are instead represented as a choice between two modules.

EDIT 2016/11/16: This is not a technical advantage, but Dagger 1 is now deprecated (as of September 15, 2016) and will no longer be actively developed. They recommend migrating to Dagger 2.

Related questions

Dagger 2: Cannot be provided without an @Provides-annotated method

I just started learning dagger2 and faced strange issue that looks like a bug to me. Here's the module: @Module public class SimpleModule { @Provides Cooker providerCooker() { return new Cooker("tom", "natie"); } } Component: @Component(modules = SimpleModule.class) public interface SimpleComponent { void …

Read More
Can I just inject super class when use dagger2 for dependency injection?

I use Dagger2 for DI in my android application. I found that I have to write inject method for every class that uses @Inject field. Is there a way that I can just inject the parent class so that I …

Read More
Dagger 2 - two provides method that provide same interface

lets say I have: public interface Shape {} public class Rectangle implements Shape { } public class Circle implements Shape { } and I have a ApplicationModule which needs to provides instances for both Rec and Circle: @Module public class ApplicationModule { private Shape rec; private …

Read More