Injecting Dependencies with Dagger 2

Talk given at GDG DevFest Nord Italia 2016 in MIlan

Transcript

1. DAGGER 2 INJECTING DEPENDENCIES WITH
2. INJECTING DEPENDENCIES WITH DAGGER 2 WHO’S SPEAKING? ▸ Android Developer @ Ennova, Italy ▸ Kotlin lover @ the same place @_tiwiz tiwiz
3. SOFTWARE SHALL BE SOLID. EVERY SOFTWARE ENGINEER EVER INJECTING DEPENDENCIES WITH DAGGER 2
4. S.O.L.I.D.
5. S O L I D
6. S O L I D
7. ingle Responsibility Principle S O L I D
8. ingle Responsibility Principle pen/closed Principle S O L I D
9. ingle Responsibility Principle pen/closed Principle iskov substitution Principle S O L I D
10. ingle Responsibility Principle pen/closed Principle iskov substitution Principle nterface segregation Principle S O L I D
11. ingle Responsibility Principle pen/closed Principle iskov substitution Principle nterface segregation Principle ependency Inversion Principle S O L I D
12. Dependency Inversion Principle
13. Dependency Inversion Principle class NoDependencyInjection { private Dependency d; public NoDependencyInjection() { d = new Dependency(); } }
14. Dependency Inversion Principle class DependencyInjection { private Dependency d; public DependencyInjection(Dependency d) { this.d = d; } }
15. Different kinds of Dependency Injection class Example { private ConstructorDependency cd; private MethodDependency md; Example(ConstructorDependency cd) { this.cd = cd; //Constructor Dependency Injection } public setMethodDependency(MethodDependency md) { this.md = md; //Method Dependency Injection } }
16. LET’S DO IT THE ANDROID WAY Every Android Developer in the room
17. THE ANDROID WAY SETTING UP THE ENVIRONMENT - 1 buildscript{ ... dependencies{ ... classpath ‘com.neenbedankt.gradle.plugins:android-apt:1.8’ } }
18. THE ANDROID WAY SETTING UP THE ENVIRONMENT - 2 apply plugin: ‘com.neenbedankt.android-apt’
19. THE ANDROID WAY SETTING UP THE ENVIRONMENT - 3 dependencies{ ... compile ‘com.google.dagger:dagger:2.7’ apt ‘com.google.dagger:dagger-compiler:2.7’ provided ‘javax.annotation:jsr250-api:1.0’ }
20. THE ANDROID WAY SETTING UP THE ENVIRONMENT - 3 dependencies{ ... compile ‘com.google.dagger:dagger:2.7’ apt ‘com.google.dagger:dagger-compiler:2.7’ provided ‘javax.annotation:jsr250-api:1.0’ }
21. THE ANDROID WAY SETTING UP THE ENVIRONMENT - 3 dependencies{ ... compile ‘com.google.dagger:dagger:2.7’ apt ‘com.google.dagger:dagger-compiler:2.7’ provided ‘javax.annotation:jsr250-api:1.0’ } @Generated
22. HOW DOES IT WORK? DAGGER 2
23. DAGGER 2 MODULES COMPONENTS
24. DAGGER 2 MODULES COMPONENTS WHAT? WHERE?
25. WHAT? MODULES @Module public class ApplicationModule { private final Context context; public ApplicationModule(Context context) { this.context = context; } @Provides @Singleton public Context providesContext() { return context; } @Provides @Singleton public ConnectivityManager providesConnectivityManager(Context context) { return (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); } }
26. WHAT? MODULES @Module public class ApplicationModule { private final Context context; public ApplicationModule(Context context) { this.context = context; } @Provides @Singleton public Context providesContext() { return context; } @Provides @Singleton public ConnectivityManager providesConnectivityManager(Context context) { return (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE); } }
27. DAGGER 2 MODULES COMPONENTS WHAT? WHERE?
28. WHERE? COMPONENTS @Singleton @Component(modules = {ApplicationModule.class}) public interface ApplicationComponent { void inject(MainActivity activity); }}
29. DAGGER 2 MODULES COMPONENTS WHAT? WHERE? +
30. DAGGER 2 MODULES COMPONENTS WHAT? WHERE? +
31. MODULES COMPONENTS WHAT? WHERE? + WIRING EVERYTHING UP!
32. WIRING EVERYTHING UP! BUILDING IN THE APPLICATION public class App extends Application{ private ApplicationComponent component; @Override public void onCreate() { super.onCreate(); component = DaggerApplicationComponent.builder() .applicationModule(new ApplicationModule(this)) .build(); } public ApplicationComponent getComponent() { return component; } }
33. WIRING EVERYTHING UP! BUILDING IN THE APPLICATION public class App extends Application{ private ApplicationComponent component; @Override public void onCreate() { super.onCreate(); component = DaggerApplicationComponent.builder() .applicationModule(new ApplicationModule(this)) .build(); } public ApplicationComponent getComponent() { return component; } }
34. WIRING EVERYTHING UP! @INJECT ALL THE THINGS! public class MainActivity extends AppCompatActivity { @Inject ConnectivityManager manager; @Override protected void onCreate(Bundle savedInstanceState) { ... ((App) getApplication()).getComponent().inject(this); } }
35. WIRING EVERYTHING UP! @INJECT ALL THE THINGS! public class MainActivity extends AppCompatActivity { @Inject ConnectivityManager manager; @Override protected void onCreate(Bundle savedInstanceState) { ... ((App) getApplication()).getComponent().inject(this); } } 1
36. GETTING TO KNOW IT DAGGER 2
37. GETTING TO KNOW DAGGER 2 MOAR FEATUREZ! ▸ Multiple modules ▸ Scopes ▸ Subcomponents ▸ Testing
38. MOAR FEATUREZ! MULTIPLE MODULES @Singleton @Component(modules = {ApplicationModule.class}) public interface ApplicationComponent { void inject(MainActivity activity); }}
39. MOAR FEATUREZ! MULTIPLE MODULES @Singleton @Component(modules = {ApplicationModule.class}) public interface ApplicationComponent { void inject(MainActivity activity); }}
40. MOAR FEATUREZ! MULTIPLE MODULES @Singleton @Component(modules = {ApplicationModule.class}) public interface ApplicationComponent { void inject(MainActivity activity); }}
41. MOAR FEATUREZ! MULTIPLE MODULES @Singleton @Component(modules = {ApplicationModule.class, SecondModule.class}) public interface ApplicationComponent { void inject(MainActivity activity); }}
42. MOAR FEATUREZ! MULTIPLE MODULES public class App extends Application{ private ApplicationComponent component; @Override public void onCreate() { super.onCreate(); component = DaggerApplicationComponent.builder() .applicationModule(new ApplicationModule(this)) .secondModule(new SecondModule()) .build(); } public ApplicationComponent getComponent() { return component; } }
43. DAGGER IS ABLE TO RETRIEVE DEPENDENCIES DECLARED IN OTHER MODULES OF THE SAME COMPONENT WITHOUT THE NEED OF DECLARE THEM EVERY TIME. MULTIPLE MODULES
44. WHAT IF WE WANTED MORE AND DIFFERENT OBJECTS OF THE SAME TYPE? The curious Android Developer in the last line, on the left MULTIPLE MODULES
45. MULTIPLE MODULES DIFFERENT OBJECT OF THE SAME TYPE @Provides @Named(IMAGE_URL) String provideImageUrl() { return ImageApiService.ENDPOINT; } @Provides @Named(URL) String provideBaseUrl() { return RestApiService.ENDPOINT; }
46. MULTIPLE MODULES DIFFERENT OBJECT OF THE SAME TYPE @Provides @Named(IMAGE_URL) String provideImageUrl() { return ImageApiService.ENDPOINT; } @Provides @Named(URL) String provideBaseUrl() { return RestApiService.ENDPOINT; }
47. MULTIPLE MODULES DIFFERENT OBJECT OF THE SAME TYPE @Provides @Named(IMAGE_URL) String provideImageUrl() { return ImageApiService.ENDPOINT; } @Provides @Named(URL) String provideBaseUrl() { return RestApiService.ENDPOINT; } @Provides @Singleton @Named(IMAGE_API_RETROFIT) Retrofit imageRetrofit(@Named(IMAGE_URL) String b, OkHttpClient client) { ... } @Provides @Singleton @Named(REST_API_RETROFIT) Retrofit retrofit(@Named(URL) String b, OkHttpClient client) { ... }
48. MULTIPLE MODULES DIFFERENT OBJECT OF THE SAME TYPE @Provides @Named(IMAGE_URL) String provideImageUrl() { return ImageApiService.ENDPOINT; } @Provides @Named(URL) String provideBaseUrl() { return RestApiService.ENDPOINT; } @Provides @Singleton @Named(IMAGE_API_RETROFIT) Retrofit imageRetrofit(@Named(IMAGE_URL) String b, OkHttpClient client) { ... } @Provides @Singleton @Named(REST_API_RETROFIT) Retrofit retrofit(@Named(URL) String b, OkHttpClient client) { ... }
49. GETTING TO KNOW DAGGER 2 MOAR FEATUREZ! ▸ Multiple modules ▸ Scopes ▸ Subcomponents ▸ Testing
50. SCOPES DEFINES THE AVAILABILITY OF A CERTAIN DEPENDENCY LIMITING IT TO THE OBJECT TO WHICH IS RELATED. SCOPES
51. ALL THE ANNOTATIONS WORKS IN A WAY THAT THEY KEEP A SINGLE INSTANCE OF THE ANNOTATION ITSELF ALIVE AS LONG AS THE COMPONENT THEY ARE LINKED TO IS ALIVE SCOPES
52. SCOPES DEFINING A SCOPE @Scope public @interface MyScope { }
53. SCOPES DEALING WITH THE LIFECYCLE @MyScope @Subcomponent public interface DetailComponent { void inject(DetailActivity target); }
54. SCOPES DEALING WITH THE LIFECYCLE @MyScope @Subcomponent public interface DetailComponent { void inject(DetailActivity target); }
55. GETTING TO KNOW DAGGER 2 MOAR FEATUREZ! ▸ Multiple modules ▸ Scopes ▸ Subcomponents ▸ Testing
56. GETTING TO KNOW DAGGER 2 MOAR FEATUREZ! ▸ Multiple modules ▸ Scopes ▸ Subcomponents ▸ Testing
57. SUBCOMPONENTS WHAT ARE THEY? ▸ Components ▸ Need modules ▸ Inherit from the parent ▸ Recently changed in Dagger 2.7
58. SUBCOMPONENTS WHAT ARE THEY? ▸ Components ▸ Need modules ▸ Inherit from the parent ▸ Recently changed in Dagger 2.7
59. SUBCOMPONENTS BUILDING A SUBCOMPONENT @Component(modules = {…}) public interface ApplicationComponent { … MyComponent add(MyModule module); }
60. SUBCOMPONENTS BUILDING A SUBCOMPONENT public class App extends Application{ … private MyComponent myComponent; … public MyComponent createMyComponent() { return component.add(new MyModule()); } … }
61. SUBCOMPONENTS BUILDING A SUBCOMPONENT public class App extends Application{ … private MyComponent myComponent; … public MyComponent createMyComponent() { return component.add(new MyModule()); } … }
62. SUBCOMPONENTS INJECTING THE SUBCOMPONENT public class MyActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { … ((App) getApplication()).createMyComponent().inject(this); … } }
63. SUBCOMPONENTS INJECTING THE SUBCOMPONENT public class MyActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { … ((App) getApplication()).createMyComponent().inject(this); … } }
64. IF YOU RETAIN THE SUBCOMPONENT IN A FIELD, REMEMBER TO CLEAR IT WHEN YOU ARE DONE. SUBCOMPONENTS
65. GETTING TO KNOW DAGGER 2 MOAR FEATUREZ! ▸ Multiple modules ▸ Scopes ▸ Subcomponents ▸ Testing
66. TESTING WITH DAGGER 2 STEPS ▸ Extend component ▸ Create mock modules ▸ Extend application ▸ Extend test runner ▸ Profit
67. TESTING WITH DAGGER 2 - STEPS EXTENDING THE COMPONENT ▸ We need to do it so that we can pass in mock modules @Singleton @Component(modules = { TestAndroidModule.class, CommonModule.class }) public interface TestApplicationComponent extends ApplicationComponent { void inject(MainActivity mainActivity); }
68. TESTING WITH DAGGER 2 - STEPS EXTENDING THE MODULES ▸ So that we can pass in mocked objects @Module public class TestAndroidModule { @Provides @Singleton MockedStuff provideMockedStuff() { … } }
69. TESTING WITH DAGGER 2 - STEPS EXTENDING THE APPLICATION ▸ So that we can wire it all together public class MockApp extends MyApplication { private TestApplicationComponent component; @Override public void onCreate() { super.onCreate(); component = DaggerTestApplicationComponent.builder() .testAndroidModule(new TestAndroidModule()) … .build(); } @Override public ApplicationComponent component() { return component; } }
70. TESTING WITH DAGGER 2 - STEPS DO YOU RECALL THIS? android { defaultConfig { testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" } }
71. TESTING WITH DAGGER 2 - STEPS LET’S EXTEND IT! public class MockTestRunner extends android.support.test.runner.AndroidJUnitRunner{ @Override public Application newApplication(ClassLoader cl, String className, Context context) throws InstantiationException, IllegalAccessException, ClassNotFoundException { return super.newApplication(cl, MockApp.class.getName(), context); } }
72. IT’S JUST AS EASY AS USING DAGGER 2 TESTING WITH DAGGER 2
73. ANY QUESTION? Thanks for watching!