Injeção de Dependência no Android com Dagger 2

Transcript

1. Dagger 2 Injeção de Dependência no Android
2. rafaeltoledo.net @_rafaeltoledo Desenv. Android @ Concrete Solutions
3. O que é Injeção de Dependência?
4. “Injeção de Dependência (ou Dependency Injection, em inglês) é um padrão de desenvolvimento de programas de computadores utilizado quando é necessário manter baixo o nível de acoplamento entre diferentes módulos de um sistema. (...)”
5. “Nesta solução as dependências entre os módulos não são definidas programaticamente, mas sim pela configuração de uma infraestrutura de software (container) que é responsável por "injetar" em cada componente suas dependências declaradas. A Injeção de dependência se relaciona com o padrão Inversão de controle mas não pode ser considerada um sinônimo deste.” Wikipedia, 2015
6. ?????????
7. Diz respeito a separação de onde os objetos são criados e onde são utilizados
8. Em vez de criar, você pede
9. class UserController { void doLogic() { try { User user = RetrofitApi.getInstance().getUser(1); new UserDaoImpl().save(user); Logger.getForClass(UserController.class).log("Success"); } catch (IOException e) { Logger.getForClass(UserController.class).logException(e); } } }
10. class UserController { UserDaoImpl dao; Logger logger; UserApi api; void doLogic() { try { api = RetrofitApi.getInstance(); User user = api.getUser(1); dao = new UserDaoImpl(); dao.save(user); logger = Logger.getForClass(UserController.class); logger.log("Success"); } catch (IOException e) { logger = Logger.getForClass(UserController.class); logger.logException(e); } } }
11. class UserController { UserDao dao; // Interface! Logger logger; Api api; void doLogic() { try { if (api == null) api = RetrofitApi.getInstance(); User user = api.getUser(1); if (dao == null) dao = new UserDaoImpl(); dao.save(user); if (logger == null) logger = Logger.getForClass(UserController.class); logger.log("Success"); } catch (IOException e) { if (logger == null) logger = Logger.getForClass(UserController.class); logger.logException(e); } } }
12. class UserController { UserDao dao = new UserDaoImpl(); Logger logger = Logger.getForClass(UserController.class); Api api = RetrofitApi.getInstance(); void doLogic() { try { User user = api.getUser(1); dao.save(user); logger.log("Success"); } catch (IOException e) { logger.logException(e); } } }
13. class UserController { UserDao dao; Logger logger; Api api; public UserController() { dao = new UserDaoImpl(); api = RetrofitApi.getInstance(); logger = Logger.getForClass(UserController.class); } void doLogic() { try { User user = api.getUser(1); dao.save(user); logger.log("Success"); } catch (IOException e) { logger.logException(e); } } }
14. class UserController { UserDao dao; Logger logger; Api api; public UserController() { dao = new UserDaoImpl(); api = RetrofitApi.getInstance(); logger = Logger.getForClass(UserController.class); } void doLogic() { try { User user = api.getUser(1); dao.save(user); logger.log("Success"); } catch (IOException e) { logger.logException(e); } } }
15. class UserController { UserDao dao; Logger logger; Api api; public UserController() { dao = new UserDaoImpl(); api = RetrofitApi.getInstance(); logger = Logger.getForClass(UserController.class); } void doLogic() { try { User user = api.getUser(1); dao.save(user); logger.log("Success"); } catch (IOException e) { logger.logException(e); } } }
16. class UserController { UserDao dao; Logger logger; Api api; public UserController() { dao = new UserDaoImpl(); api = RetrofitApi.getInstance(); logger = Logger.getForClass(UserController.class); } void doLogic() { try { User user = api.getUser(1); dao.save(user); logger.log("Success"); } catch (IOException e) { logger.logException(e); } } }
17. UserDao UserController
18. UserDao UserController SessionManager
19. UserDao UserController SessionManager SignInController
20. UserDao UserController SessionManager SignInController CookieJob JobManager JobController PermissionChecker ReminderJob RoleController CandyShopper FruitJuicerJob UnknownController
21. UserDao UserController SessionManager SignInController CookieJob JobManager JobController PermissionChecker ReminderJob RoleController CandyShopper FruitJuicerJob UnknownController EM TODO LUGAR!
22. class UserDaoImpl implements UserDao { public UserDaoImpl() { //... } }
23. class UserDaoImpl implements UserDao { public UserDaoImpl(Context context) { //... } }
25. Alteração em todas as classes!
26. Alteração em todas as classes! Muito retrabalho!
27. Alteração em todas as classes! Muito retrabalho!
28. Alteração em todas as classes! Muito retrabalho!
29. class UserController { UserDao dao; Logger logger; Api api; public UserController() { dao = new UserDaoImpl(); api = RetrofitApi.getInstance(); logger = Logger.getForClass(UserController.class); } void doLogic() { try { User user = api.getUser(1); dao.save(user); logger.log("Success"); } catch (IOException e) { logger.logException(e); } } }
30. class UserController { UserDao dao; Logger logger; Api api; public UserController() { dao = new UserDaoImpl(); api = RetrofitApi.getInstance(); logger = Logger.getForClass(UserController.class); } void doLogic() { try { User user = api.getUser(1); dao.save(user); logger.log("Success"); } catch (IOException e) { logger.logException(e); } } }
31. class UserController { UserDao dao; Logger logger; Api api; public UserController(UserDao dao, Api api, Logger logger) { this.dao = dao; this.api = api; this.logger = logger; } void doLogic() { try { User user = api.getUser(1); dao.save(user); logger.log("Success"); } catch (IOException e) { logger.logException(e); } } }
32. DI: Separação do uso e criação de objetos
33. DI: Separação do uso e criação de objetos não há a necessidade de bibliotecas ou frameworks!
34. Desvantagem: muito boilerplate
35. Spring, Guice, Dagger 1 & cia #oldbutgold
36. Spring, Guice, Dagger 1 & cia #oldbutnot
37. Dagger 2
38. Dagger 2?
39. Dagger 2 • Fork do Dagger, da Square, feito pela Google • Elimina todo o uso de reflections • Construída sobre as anotações javax. inject da especificação JSR-330
40. Dagger 2 • Validação de todo o grafo de dependências em tempo de compilação • Menos flexível, se comparado ao Dagger 1 - ex.: não possui module overriding • Proguard configuration-free
41. Dagger 2 • API enxuta! • Código gerado é debugger-friendly • Muito performático • google.github.io/dagger
42. public @interface Component { Class<?>[] modules() default {}; Class<?>[] dependencies() default {}; } public @interface Subcomponent { Class<?>[] includes() default {}; } public @interface Module { Class<?>[] includes() default {}; } public @interface Provides { } public @interface MapKey { boolean unwrapValue() default true; } public interface Lazy<T> { T get(); }
43. // JSR-330 public @interface Inject { } public @interface Scope { } public @interface Qualifier { }
44. Como integro no meu projeto?
45. // build.gradle buildscript { repositories { jcenter() } dependencies { classpath 'com.android.tools.build:gradle:1.2.3' } } allprojects { repositories { jcenter() } }
46. // build.gradle buildscript { repositories { jcenter() } dependencies { classpath 'com.android.tools.build:gradle:1.2.3' } } allprojects { repositories { jcenter() } }
47. // build.gradle buildscript { repositories { jcenter() } dependencies { classpath 'com.android.tools.build:gradle:1.2.3' classpath 'com.neenbedankt.gradle.plugins:android-apt:1.6' } } allprojects { repositories { jcenter() } }
48. // build.gradle buildscript { repositories { jcenter() } dependencies { classpath 'com.android.tools.build:gradle:1.2.3' classpath 'com.neenbedankt.gradle.plugins:android-apt:1.6' } } allprojects { repositories { jcenter() } }
49. apply plugin: 'com.android.application' android { compileSdkVersion 22 buildToolsVersion '22.0.1' defaultConfig { applicationId 'net.rafaeltoledo.tdc2015' minSdkVersion 15 targetSdkVersion 22 versionCode 1 versionName '1.0' } } dependencies { compile 'com.android.support:appcompat-v7:22.2.1' }
50. apply plugin: 'com.android.application' apply plugin: 'com.neenbedankt.android-apt' android { compileSdkVersion 22 buildToolsVersion '22.0.1' defaultConfig { applicationId 'net.rafaeltoledo.tdc2015' minSdkVersion 15 targetSdkVersion 22 versionCode 1 versionName '1.0' } } dependencies { compile 'com.android.support:appcompat-v7:22.2.1' compile 'com.google.dagger:dagger:2.0.1' apt 'com.google.dagger:dagger-compiler:2.0.1' provided 'org.glassfish:javax.annotation:10.0-b28' }
51. apply plugin: 'com.android.application' apply plugin: 'com.neenbedankt.android-apt' android { compileSdkVersion 22 buildToolsVersion '22.0.1' defaultConfig { applicationId 'net.rafaeltoledo.tdc2015' minSdkVersion 15 targetSdkVersion 22 versionCode 1 versionName '1.0' } } dependencies { compile 'com.android.support:appcompat-v7:22.2.1' compile 'com.google.dagger:dagger:2.0.1' apt 'com.google.dagger:dagger-compiler:2.0.1' provided 'org.glassfish:javax.annotation:10.0-b28' // JSR-330 }
52. E pronto!
53. Vamos começar?
54. @Inject @Component @Module @Provides Dagger 2
55. @Inject • Parte da JSR-330 • Marca quais dependências devem ser fornecidas pelo Dagger • Pode aparecer de 3 formas no código
56. public class TdcActivityPresenter { private TdcActivity activity; private TdcDataStore dataStore; @Inject public TdcActivityPresenter(TdcActivity activity, TdcDataStore dataStore) { this.activity = activity; this.dataStore = dataStore; } } 1. No Construtor
57. 1. No Construtor • Todas as dependências vem do grafo de dependências do Dagger • Anotar uma classe dessa forma faz com que ela também faça parte do grafo de dependências (podendo ser injetada em outras classes)
58. 1. No Construtor • Limitação: não podemos anotar mais que um construtor com a anotação @Inject
59. public class TdcActivity extends AppCompatActivity { @Inject TdcActivityPresenter presenter; @Inject SharedPreferences preferences; @Override protected void onCreate(Bundle bundle) { super.onCreate(bundle); getComponent().inject(this); } } 2. Nos Atributos da Classe
60. 2. Nos Atributos da Classe • A injeção nesse caso deve ser manual, caso contrários os atributos serão todos nulos @Override protected void onCreate(Bundle bundle) { super.onCreate(bundle); getComponent().inject(this); } • Limitação: os atributos não podem ser privados!
61. public class TdcActivityPresenter { private TdcActivity activity; @Inject public TdcActivityPresenter(TdcActivity activity) { this.activity = activity; } @Inject public void enableAnalytics(AnalyticsManager analytics) { analytics.track(this); } } 3. Em métodos públicos
62. 3. Em métodos públicos • Utilizado em conjunto com a anotação no construtor da classe • Para casos onde o objeto injetado necessitamos da instância da própria classe na dependência fornecida @Inject public void enableAnalytics(AnalyticsManager analytics) { analytics.track(this); }
63. 3. Em métodos públicos • O método anotado é chamado automaticamente logo após o construtor
64. @Module • Parte da API do Dagger • Utilizada para identificar classes que fornecem dependências
65. @Module public class DataModule { @Provides @Singleton public OkHttpClient provideOkHttpClient() { OkHttpClient okHttpClient = new OkHttpClient(); okHttpClient.setConnectionTimeout(10, TimeUnit.SECONDS); okHttpClient.setReadTimeout(10, TimeUnit.SECONDS); okHttpClient.setWriteTimeout(10, TimeUnit.SECONDS); return okHttpClient; } @Provides @Singleton public RestAdapter provideRestAdapter(OkHttpClient client) { return new RestAdapter.Builder() .setClient(new OkClient(okHttpClient)) .setEndpoint("https://api.github.com") .build(); } }
66. @Module public class DataModule { @Provides @Singleton public OkHttpClient provideOkHttpClient() { OkHttpClient okHttpClient = new OkHttpClient(); okHttpClient.setConnectionTimeout(10, TimeUnit.SECONDS); okHttpClient.setReadTimeout(10, TimeUnit.SECONDS); okHttpClient.setWriteTimeout(10, TimeUnit.SECONDS); return okHttpClient; } @Provides @Singleton public RestAdapter provideRestAdapter(OkHttpClient client) { return new RestAdapter.Builder() .setClient(new OkClient(okHttpClient)) .setEndpoint("https://api.github.com") .build(); } }
67. @Provide • Utilizada nas classes anotadas como @Module para identificar quais métodos retornam dependências
68. @Module public class DataModule { @Provides @Singleton public OkHttpClient provideOkHttpClient() { OkHttpClient okHttpClient = new OkHttpClient(); okHttpClient.setConnectionTimeout(10, TimeUnit.SECONDS); okHttpClient.setReadTimeout(10, TimeUnit.SECONDS); okHttpClient.setWriteTimeout(10, TimeUnit.SECONDS); return okHttpClient; } @Provides @Singleton public RestAdapter provideRestAdapter(OkHttpClient client) { return new RestAdapter.Builder() .setClient(new OkClient(okHttpClient)) .setEndpoint("https://api.github.com") .build(); } }
69. @Module public class DataModule { @Provides @Singleton public OkHttpClient provideOkHttpClient() { OkHttpClient okHttpClient = new OkHttpClient(); okHttpClient.setConnectionTimeout(10, TimeUnit.SECONDS); okHttpClient.setReadTimeout(10, TimeUnit.SECONDS); okHttpClient.setWriteTimeout(10, TimeUnit.SECONDS); return okHttpClient; } @Provides @Singleton public RestAdapter provideRestAdapter(OkHttpClient client) { return new RestAdapter.Builder() .setClient(new OkClient(okHttpClient)) .setEndpoint("https://api.github.com") .build(); } }
70. @Component • É a anotação que liga os @Modules aos @Injects • É colocada em uma interface • Define quais módulos possui, quem será injetado
71. @Component • Precisa especificar obrigatoriamente seu escopo (ciclo de vida de suas dependências) • Pode publicar dependências • Pode possuir outros componentes
72. @Singleton @Component( modules = { DataModule.class, UiModule.class } ) public interface TdcAppComponent { void inject(TdcApplication app); MainActivity inject(MainActivity activity); Application getApplication(); AnalyticsManager getAnalyticsManager(); }
73. @Singleton // Escopo @Component( modules = { DataModule.class, UiModule.class } ) public interface TdcAppComponent { void inject(TdcApplication app); MainActivity inject(MainActivity activity); Application getApplication(); AnalyticsManager getAnalyticsManager(); }
74. @Singleton @Component( modules = { DataModule.class, UiModule.class } ) public interface TdcAppComponent { void inject(TdcApplication app); MainActivity inject(MainActivity activity); Application getApplication(); AnalyticsManager getAnalyticsManager(); }
75. @Singleton @Component( modules = { DataModule.class, UiModule.class } ) public interface TdcAppComponent { void inject(TdcApplication app); MainActivity inject(MainActivity activity); // Caso queira encadear Application getApplication(); AnalyticsManager getAnalyticsManager(); }
76. @Singleton @Component( modules = { DataModule.class, UiModule.class } ) public interface TdcAppComponent { void inject(TdcApplication app); MainActivity inject(MainActivity activity); Application getApplication(); AnalyticsManager getAnalyticsManager(); // Dependências visíveis } // para outros componentes*
77. @Singleton @Component( modules = { DataModule.class, UiModule.class } ) public interface TdcAppComponent { void inject(TdcApplication app); MainActivity inject(MainActivity activity); Application getApplication(); AnalyticsManager getAnalyticsManager(); }
78. @ActivityScope // Escopo personalizado @Component( modules = TdcActivityModule.class, dependencies = TdcComponent.class ) public interface TdcActivityComponent { TdcActivity inject(TdcActivity activity); TdcActivityPresenter presenter(); }
79. @Generated("dagger.internal.codegen.ComponentProcessor") public final class DaggerMainComponent implements MainComponent { private Provider<ApiService> provideApiServiceProvider; private MembersInjector<MainActivity> mainActivityMembersInjector; private DaggerMainComponent(Builder builder) { assert builder != null; initialize(builder); } public static Builder builder() { return new Builder(); } public static MainComponent create() { return builder().build(); } private void initialize(final Builder builder) { this.provideApiServiceProvider = ScopedProvider.create(MainModule_ProvideApiServiceFactory.create(builder.mainModule)); this.mainActivityMembersInjector = MainActivity_MembersInjector.create( (MembersInjector) MembersInjectors.noOp(), provideApiServiceProvider); } @Override public void inject(MainActivity activity) { mainActivityMembersInjector.injectMembers(activity); } }
80. class UserController { UserDao dao; Logger logger; Api api; public UserController() { dao = new UserDaoImpl(); api = RetrofitApi.getInstance(); logger = Logger.getForClass(UserController.class); } void doLogic() { try { User user = api.getUser(1); dao.save(user); logger.log("Success"); } catch (IOException e) { logger.logException(e); } } }
81. public class TdcApp extends Application { TdcAppComponent component; @Override public void onCreate() { component = DaggerTdcAppComponent.create(); component = DaggerTdcAppComponent.builder() .dataModule(new DataModule(this)) // Módulo com construtor .build(); // parametrizado } } Instanciando um Componente
82. Dagger 2 Escopos dinâmicos
83. Escopo = ciclo de vida do grafo de dependências (componente)
84. @Singleton @Component( modules = { DataModule.class, UiModule.class } ) public interface TdcAppComponent { void inject(TdcApplication app); MainActivity inject(MainActivity activity); Application getApplication(); AnalyticsManager getAnalyticsManager(); }
85. @ActivityScope // Escopo personalizado @Component( modules = TdcActivityModule.class, dependencies = TdcComponent.class ) public interface TdcActivityComponent { TdcActivity inject(TdcActivity activity); TdcActivityPresenter presenter(); }
86. @Scope @Retention(RetentionPolicy.RUNTIME) public @interface UserScope { } Definição de um escopo
87. Exemplo de uso Miroslaw Stanek frogermcs.github.io
88. @Singleton @Component(modules = DataModule.class) public interface TdcAppComponent { UserComponent plus(UserModule module); // não é necessário expor as dependências } Implementação
89. @UserScope @Subcomponent(modules = UserModule.class) public interface UserComponent { UserActivityComponent plus(UserActivityModule module); } Implementação
90. public class TdcApp extends Application { TdcAppComponent component; UserComponent userComponent; public UserComponent createUserComponent(User user) { userComponent = component.plus(new UserModule(user)); return userComponent; } public void releaseUserComponent() { userComponent = null; } ... } Implementação
91. Dagger 2 Outras coisas legais!
92. @Inject Lazy<SharedPreferences> prefs; void salvar() { prefs.get().edit().putString("status", "ok!").apply(); } Dependências “Preguiçosas”
93. // No módulo @Provides @Singleton @ApiUrl String provideApiUrl(Context context) { return context.getString(R.string.api_url); } @Provides @Singleton @AccessToken String provideRestAdapter(SharedPreferences prefs) { return prefs.getString("token", null); } // Na classe a ser injetada @Inject @AccessToken String accessToken; Qualificadores
94. // Declarando sua anotação @MapKey(unwrapValue = true) @interface GroupKey { String value(); } @MapKey
95. // Fornecendo dependências no módulo @Provides(type = Type.MAP) @GroupKey("um") String provideFirstValue() { return "primeiro valor"; } @Provides(type = Type.MAP) @GroupKey("dois") String provideSecondValue() { return "segundo valor"; } @MapKey
96. // Uso @Inject Map<String, String> map; // {um=primeiro valor, dois=segundo valor} • Por enquanto, só aceita Map e Set, e valores do tipo String e Enumeradores @MapKey
97. Ok! Tudo muito bonito mas...
98. O que eu ganho de fato com tudo isso?
99. Grandes benefícios • Código mais limpo e organizado • Melhorias no gerenciamento de objetos (melhor controle de singletons) • Código mais fácil de TESTAR
100. Dagger 2 e Testes • Programar orientado a interfaces - mocks • Sobrescrita de Componentes e Módulos
101. Dagger 2 e Testes @Module public class TestMainModule { @Provides // Poderíamos fazer com o Retrofit Mock! public ApiService provideApiService() { return new ApiService() { @Override public List<Repo> listRepos() { return Arrays.asList( new Repo("my-test-repo"), new Repo("another-test-repo") ); } }; } }
102. Dagger 2 e Testes @Component(modules = DebugMainModule.class) public interface TestMainComponent extends MainComponent { }
103. Dagger 2 e Espresso 2 @RunWith(AndroidJUnit4.class) public class MainActivityTest { // ... @Before public void setUp() { Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation(); MainApplication app = (MainApplication) instrumentation.getTargetContext().getApplicationContext(); app.setComponent(DaggerDebugMainComponent.create()); rule.launchActivity(new Intent()); } }
104. Dagger 2 e Robolectric 3 @RunWith(RobolectricGradleTestRunner.class) @Config(sdk = 21, constants = BuildConfig.class) public class MainActivityTest { // ... @Before public void setUp() { MainComponent component = DaggerDebugMainComponent.create(); MainApplication app = ((MainApplication) RuntimeEnvironment.application) .setComponent(component); } }
105. Dagger 2 github.com/rafaeltoledo/dagger2-tdc2015
106. Para saber mais • Site oficial - google.github.io/dagger • Dagger 2 - A New Type of Dependency Injection (Gregory Kick) - vai.la/fdwt • The Future of Dependency Injection with Dagger 2 (Jake Wharton) - vai.la/fdwy • froger_mcs Dev Blog - frogermcs.github.io
107. OBRIGADO! rafaeltoledo.net @_rafaeltoledo Desenv. Android @ Concrete Solutions estamos contratando! concretesolutions.com.br/carreira