MCE^3 - Gregory Kick - Dagger 2

Confidential + ProprietaryConfidential + Proprietary
Dagger 2
Now Even Pointier!™

An introduction

Confidential + Proprietary
A quick (re)introduction to dependency injection
/* With Manual DI */
class CoffeeMaker {
private final Heater heater;
private final Pump pump;
CoffeeMaker(Heater heater, Pump pump) {
this.heater = checkNotNull(heater);
this.pump = checkNotNull(pump);
}
Coffee makeCoffee() {/* … */}
}
class CoffeeMain {
public static void main(String[] args) {
Heater heater = new ElectricHeater();
Pump pump = new Thermosiphon(heater);
Coffee coffee =
new CoffeeMaker(heater, pump).makeCoffee();
}
}
/* Without DI */
class CoffeeMaker {
private final Heater heater;
private final Pump pump;
CoffeeMaker() {
this.heater = new ElectricHeater();
this.pump = new Thermosiphon(heater);
}
Coffee makeCoffee() {/* … */}
}
class CoffeeMain {
public static void main(String[] args) {
Coffee coffee =
new CoffeeMaker().makeCoffee();
}
}

DI with Dagger 2

Dagger 2 - Injected objects
@Inject
Thermosiphon(Heater heater) {
this.heater = heater;
}

Dagger 2 - declarative configuration
@Provides
@Singleton
Heater provideHeater() {
return new ElectricHeater();
}

Dagger 2 - typesafe dependency injection
@Singleton
@Component(
modules = DripCoffeeModule.class)
public interface CoffeeComponent {
CoffeeMaker maker();
}

OK, but why?

Consistent, efficient
instance management

Dagger 2.0.1 - 2.4

static @Provides
methods

@Provides
Heater provideHeater() {
}

@Provides
static Heater provideHeater() {
}

Subcomponents

Subcomponents
@Component(modules = {ServerModule.class, AuthModule.class})
interface ServerComponent {
Server server();
SessionComponent sessionComponent(SessionModule sessionModule);
}
@Subcomponent(modules = SessionModule.class)
interface SessionComponent {
SessionInfo sessionInfo();
RequestComponent requestComponent();
}
@Subcomponent(modules = {RequestModule.class, AuthModule.class})
interface RequestComponent {
RequestHandler requestHandler();
}

Map Multibindings

Map multibindings

enum MessageType {
TEXT,
PHOTO,
LOCATION,
}
@MapKey
@interface ForMessageType {
MessageType value();
}
Map multibindings
@Provides
@IntoMap
@ForMessageType(TEXT)
Renderer contributeTextRenderer() { /*…*/ }
@Provides
@IntoMap
@ForMessageType(PHOTO)
Renderer contributePhotoRenderer() { /*…*/ }
@Provides
@IntoMap
@ForMessageType(LOCATION)
Renderer contributeVideoRenderer() { /*…*/ }

Map multibindings
@Inject Map<MessageType, Provider<Renderer>> renderers;
// …
for (Message message : messages) {
renderers.get(message.type()).get().render(message);
}

Producers

Producers
@ProducerModule(includes = UserModule.class)
final class UserResponseModule {
@Produces
static ListenableFuture<UserData>
lookUpUserData(
User user, UserDataStub stub) {
return stub.lookUpData(user);
}
@Produces
static Html renderHtml(
UserData data,
UserHtmlTemplate template) {
return template.render(data);
}
}
@Module
final class ExecutorModule {
@Provides
@Production
static Executor executor() {
return Executors.newCachedThreadPool();
}
}
@ProductionComponent(modules =
UserResponseModule.class)
interface UserResponseComponent {
ListenableFuture<Html> html();
}

Improved error
messages

Error messages
error: coffee.Pump cannot be provided without an
@Provides-annotated method.
CoffeeMaker maker();
^
coffee.Pump is injected at
coffee.CoffeeMaker.<init>(…, pump)
coffee.CoffeeMaker is provided at
coffee.CoffeeApp.CoffeeComponent.maker()

Project
Management

Development within Google
● Millions of test targets are executed for
every Dagger change
● Constant performance testing and
monitoring from JVM and Android projects
● New APIs are developed against a huge,
searchable repository of real usages
● It is an invaluable, proven model from which
we have gotten projects like Guava
Working with GitHub
● We haven't done as well as we need to
○ Google builds from HEAD, but the rest of the
world doesn't
○ Syncs from Google were big, unmanaged
dumps of changes with no compatibility
guarantees
● New release policy makes sure that there is
a versioned release about every 2 weeks
○ Cultivated change log
○ Compatibility guarantees
Project management

Dagger 2.5+

Performance
enhancements

The generated code

Unnecessary Providers

Retained references

@Binds

@Provides
static Pump providePump(Thermosiphon pump) {
return pump;
}

@Binds
abstract Pump bindPump(Thermosiphon pump);

Memory
management tools

Considerations
Mobile devices mean we need to be judicious
● Number of allocations
● Long-term memory footprint

Unscoped
A new instance for every injection site

@Scope
Only one instance per component

@Reusable
Instances can be reused, but how and when isn't
a functional requirement

Pressure-sensitive scopes
There should only be one instance, but if there is
memory pressure make it eligible for garbage
collection

Easier
subcomponents

An Application component
@Singleton
@Component(modules = ApplicationModule.class)
interface MyApplicationComponent {
MyApplication inject(MyApplication application);
@Component.Builder
interface Builder {
Builder applicationModule(ApplicationModule module);
MyApplicationComponent build();
}
}

@ActivityScoped
@Subcomponent(
modules = ActivityModule.class)
interface MainActivitySubcomponent {
MainActivity injectMainActivity(
MainActivity activity);
@Subcomponent.Builder
interface Builder {
Builder activityModule(
ActivityModule activityModule);
MainActivitySubcomponent build();
}
}
An activity subcomponent today
@Singleton
@Component(modules = ApplicationModule.
class)
interface MyApplicationComponent {
MyApplication inject(
MyApplication application);
MainActivitySubcomponent.Builder
newMainActivitySubcomponentBuilder();
/* … */
}

What if we didn't have to have that method?
public final class MyAppication extends Application {
@Inject
MainActivitySubcomponent.Builder builder;
/* … */
}

First, a common interface
interface ActivityComponentBuilder<A extends Activity> {
ActivityComponentBuilder<A> activityModule(ActivityModule activityModule);
MembersInjector<A> build();
}
@ActivityScoped
@Subcomponent(modules = ActivityModule.class)
interface MainActivitySubcomponent {
MainActivity injectMainActivity(MainActivity activity);
@Subcomponent.Builder
interface Builder extends ActivityComponentBuilder<ActivityModule> {}
}

Second, map multibinder
@Module
abstract class MainActivitySubcomponentModule {
@Binds @IntoMap @ActivityKey(MainActivity.class)
abstract ActivityComponentBuilder<?> bindBuilder(
MainActivitySubcomponent.Builder<MainActivity> impl);
}

Finally, back to MyApplication
interface HasActivitySubcomponentBuilders {
<A extends Activity> ActivityComponentBuilder<A> getActivityComponentBuilder(
Class<? extends Activity> activityClass);
}
class MyApplication extends Application implements HasActivitySubcomponentBuilders {
@Inject Map<Class<? extends Activity, ActivityComponentBuilder<?>> activityComponentBuilders;
@Override
public <A extends Activity> ActivityComponentBuilder<A> getActivityComponentBuilder(
Class<? extends Activity> activityClass) {
checkArgument(activityComponentBuilders.containsKey(activityClass));
return (ActivityComponentBuilder<A>) activityComponentBuilders.get(activityClass);
}
}

Q & A

MCE^3 - Gregory Kick - Dagger 2

More Related Content

What's hot

Viewers also liked

Similar to MCE^3 - Gregory Kick - Dagger 2

Recently uploaded

MCE^3 - Gregory Kick - Dagger 2