Dagger is a new dependency injection framework for Android and Java. I went to a meetup yesterday to learn more about it. These are my notes:
The talk was by Jake Wharton who works at Square.
Every single app has some form of DI. You can do DI even if you're not using a library for doing it. The goal of DI is to separate the behavior of something from its required classes. If you've ever used a constructor to receive stuff, you've done a simple version of DI.
Square used Guice heavily.
Problems with Guice:
Config problems fail at runtime.
Slow initialization, slow injection, and memory problems.
These are worse on Android. It causes the OS to load all the code for your app at once. This caused their app to take 2 seconds to start.
They called Dagger "Object Graph" initially.
Goals of Dagger:
Static analysis of all dependencies and injections.
Fail as early as possible--compile time, not runtime.
Eliminate the need to do reflection of methods and annotations at runtime. Reflection in Dalvik is really slow.
Have negligible memory impact.
Jesse Wilson wrote it over the course of 5 weeks. He previously worked on Guice and Dalvik.
Square switched from Guice to Dagger in a fairly short period of time.
The name Dagger refers to "directed acyclic graph".
An ObjectGraph is the central dependency manager and injector.
@Module + @Provides
Modules are meant to be composed together.
@Inject is required.
Field injection or constructor injection.
Dependencies can be stored in private final fields.
If you have @Inject, you don't have to say @Provides.
Injected fields cannot be private or final. They can be package protected.
Object graphs can be scoped. One object graph is a superset of another. For instance, you might create a new object graph once the user logs in that contains all of the objects that are require a user object.
The ObjectGraph is just another object. Hence, you can pass it around like a normal object.
There's one pain point in Dagger. All injection points must be listed on a module. This is used for aggressive static analysis.
Use overrides to facilitate testing.
He showed how to integrate with Gradle.
They have a "Debug Drawer" in their apps. It is hidden in the UI, but lets you configure all sorts of debug settings.
U+2020 is a sample app to show how to do all of this.
Using DI Incorrectly
Do NOT make every class use the pattern. Use it for the big things, such as the things that talk to a remote API.
Do NOT store dependencies as static fields.
Dagger is developer and debugger friendly.
They're working on the next major version, version 2.0.
Google is leading the development of the next version.
It won't use any reflection.
Dagger is not Android specific.
They're getting rid of injects lists.
Components encapsulate dependencies.
There will be dedicated annotations to denote scopes.
They have code that can generate a GraphViz file that shows you your dependency graph.
In their apps, they have a network module, an Android module, an app module, etc.
There's an IntelliJ plugin that lets you jump between @Inject and @Provides.