A arquitetura de apps recomendada do Android incentiva a divisão do código em classes para tirar proveito da separação de preocupações, um princípio em que cada classe da hierarquia tem uma única responsabilidade definida. Isso leva a classes menores e mais numerosas, que precisam ser conectadas para atender às dependências umas das outras.
![Os apps Android geralmente são compostos por muitas classes, e algumas delas
dependem umas das outras.](https://developer.android.com/static/topic/libraries/architecture/images/final-architecture.png?authuser=5&hl=pt)
As dependências entre as classes podem ser representadas como um gráfico, em que cada
classe se conecta às classes de que depende. A representação de todas as
classes e as respectivas dependências representam o gráfico do aplicativo.
Na Figura 1, é possível ver uma abstração do gráfico do aplicativo.
Quando uma classe A (ViewModel
) depende de uma classe B (Repository
), há
uma linha que aponta de A para B, representando essa dependência.
A injeção de dependências ajuda a fazer essas conexões e permite que você troque
implementações para testes. Por exemplo, ao testar um ViewModel
que depende de um repositório, você pode transmitir implementações diferentes de
Repository
com falsificações ou simulações para testar os casos diferentes.
Conceitos básicos da injeção manual de dependências
Esta seção aborda como aplicar a injeção manual de dependências em um cenário real de um app Android. Ela usa uma abordagem iterada de como é possível começar a usar a injeção de dependências no seu app. Essa abordagem melhora até chegar a um ponto muito parecido com o que o Dagger geraria automaticamente para você. Para ver mais informações sobre o Dagger, consulte Princípios básicos do Dagger.
Considere um fluxo como um grupo de telas no app, correspondente a um recurso. Login, registro e finalizações de compra são exemplos de fluxos.
Ao cobrir um fluxo de login para um app Android típico, o LoginActivity
depende de LoginViewModel
, que, por sua vez, depende de UserRepository
.
Em seguida, UserRepository
depende de um UserLocalDataSource
e um
UserRemoteDataSource
, que, por sua vez, depende de um serviço de
Retrofit
.
![](https://developer.android.com/static/images/training/dependency-injection/2-application-graph.png?authuser=5&hl=pt)
LoginActivity
é o ponto de entrada para o fluxo de login, e o usuário
interage com a atividade. Assim, LoginActivity
precisa criar o
LoginViewModel
com todas as respectivas dependências.
As classes Repository
e DataSource
do fluxo têm esta aparência:
Kotlin
class UserRepository( private val localDataSource: UserLocalDataSource, private val remoteDataSource: UserRemoteDataSource ) { ... } class UserLocalDataSource { ... } class UserRemoteDataSource( private val loginService: LoginRetrofitService ) { ... }
Java
class UserLocalDataSource { public UserLocalDataSource() { } ... } class UserRemoteDataSource { private final Retrofit retrofit; public UserRemoteDataSource(Retrofit retrofit) { this.retrofit = retrofit; } ... } class UserRepository { private final UserLocalDataSource userLocalDataSource; private final UserRemoteDataSource userRemoteDataSource; public UserRepository(UserLocalDataSource userLocalDataSource, UserRemoteDataSource userRemoteDataSource) { this.userLocalDataSource = userLocalDataSource; this.userRemoteDataSource = userRemoteDataSource; } ... }
Veja a aparência de LoginActivity
:
Kotlin
class LoginActivity: Activity() { private lateinit var loginViewModel: LoginViewModel override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // In order to satisfy the dependencies of LoginViewModel, you have to also // satisfy the dependencies of all of its dependencies recursively. // First, create retrofit which is the dependency of UserRemoteDataSource val retrofit = Retrofit.Builder() .baseUrl("https://example.com") .build() .create(LoginService::class.java) // Then, satisfy the dependencies of UserRepository val remoteDataSource = UserRemoteDataSource(retrofit) val localDataSource = UserLocalDataSource() // Now you can create an instance of UserRepository that LoginViewModel needs val userRepository = UserRepository(localDataSource, remoteDataSource) // Lastly, create an instance of LoginViewModel with userRepository loginViewModel = LoginViewModel(userRepository) } }
Java
public class MainActivity extends Activity { private LoginViewModel loginViewModel; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // In order to satisfy the dependencies of LoginViewModel, you have to also // satisfy the dependencies of all of its dependencies recursively. // First, create retrofit which is the dependency of UserRemoteDataSource Retrofit retrofit = new Retrofit.Builder() .baseUrl("https://example.com") .build() .create(LoginService.class); // Then, satisfy the dependencies of UserRepository UserRemoteDataSource remoteDataSource = new UserRemoteDataSource(retrofit); UserLocalDataSource localDataSource = new UserLocalDataSource(); // Now you can create an instance of UserRepository that LoginViewModel needs UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource); // Lastly, create an instance of LoginViewModel with userRepository loginViewModel = new LoginViewModel(userRepository); } }
Há problemas com essa abordagem:
Há muitos códigos boilerplate. Caso sua intenção fosse criar outra instância de
LoginViewModel
em outra parte do código, haveria duplicação de código.Dependências precisam ser declaradas em ordem. É obrigatório instanciar o
UserRepository
antes doLoginViewModel
para a criação.É difícil reutilizar objetos. Caso sua intenção fosse reutilizar o
UserRepository
em vários recursos, seria necessário fazer com que ele seguisse o padrão singleton. O padrão singleton dificulta a testagem, já que todos os testes compartilham a mesma instância singleton.
Como gerenciar dependências com um contêiner
Para resolver o problema de reutilização de objetos, você pode criar a própria
classe de contêiner de dependências, que pode ser usada para conseguir dependências. Todas as instâncias
fornecidas por esse contêiner podem ser públicas. No exemplo, como você só precisa de
uma instância de UserRepository
, é possível tornar as dependências particulares, com a
opção de fazer com que elas sejam públicas no futuro caso precisem ser fornecidas:
Kotlin
// Container of objects shared across the whole app class AppContainer { // Since you want to expose userRepository out of the container, you need to satisfy // its dependencies as you did before private val retrofit = Retrofit.Builder() .baseUrl("https://example.com") .build() .create(LoginService::class.java) private val remoteDataSource = UserRemoteDataSource(retrofit) private val localDataSource = UserLocalDataSource() // userRepository is not private; it'll be exposed val userRepository = UserRepository(localDataSource, remoteDataSource) }
Java
// Container of objects shared across the whole app public class AppContainer { // Since you want to expose userRepository out of the container, you need to satisfy // its dependencies as you did before private Retrofit retrofit = new Retrofit.Builder() .baseUrl("https://example.com") .build() .create(LoginService.class); private UserRemoteDataSource remoteDataSource = new UserRemoteDataSource(retrofit); private UserLocalDataSource localDataSource = new UserLocalDataSource(); // userRepository is not private; it'll be exposed public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource); }
Como essas dependências são usadas em todo o aplicativo, elas precisam
ser colocadas em um lugar comum que todas as atividades possam usar:
a classe Application
. Crie uma classe Application
personalizada contendo uma instância de AppContainer
.
Kotlin
// Custom Application class that needs to be specified // in the AndroidManifest.xml file class MyApplication : Application() { // Instance of AppContainer that will be used by all the Activities of the app val appContainer = AppContainer() }
Java
// Custom Application class that needs to be specified // in the AndroidManifest.xml file public class MyApplication extends Application { // Instance of AppContainer that will be used by all the Activities of the app public AppContainer appContainer = new AppContainer(); }
Agora, você pode receber a instância de AppContainer
do aplicativo e
o compartilhado da instância de UserRepository
:
Kotlin
class LoginActivity: Activity() { private lateinit var loginViewModel: LoginViewModel override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // Gets userRepository from the instance of AppContainer in Application val appContainer = (application as MyApplication).appContainer loginViewModel = LoginViewModel(appContainer.userRepository) } }
Java
public class MainActivity extends Activity { private LoginViewModel loginViewModel; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // Gets userRepository from the instance of AppContainer in Application AppContainer appContainer = ((MyApplication) getApplication()).appContainer; loginViewModel = new LoginViewModel(appContainer.userRepository); } }
Dessa forma, você não tem um UserRepository
singleton. Em vez disso, você tem um
AppContainer
compartilhado por todas as atividades que contêm objetos do gráfico
e que criam instâncias desses objetos que outras classes podem consumir.
Se LoginViewModel
for necessário em mais lugares no aplicativo, é recomendável ter um
local centralizado onde você possa criar instâncias de
LoginViewModel
. É possível mover a criação de LoginViewModel
para o contêiner e fornecer
novos objetos desse tipo com uma fábrica. O código de uma LoginViewModelFactory
tem esta aparência:
Kotlin
// Definition of a Factory interface with a function to create objects of a type interface Factory<T> { fun create(): T } // Factory for LoginViewModel. // Since LoginViewModel depends on UserRepository, in order to create instances of // LoginViewModel, you need an instance of UserRepository that you pass as a parameter. class LoginViewModelFactory(private val userRepository: UserRepository) : Factory{ override fun create(): LoginViewModel { return LoginViewModel(userRepository) } }
Java
// Definition of a Factory interface with a function to create objects of a type public interface Factory<T> { T create(); } // Factory for LoginViewModel. // Since LoginViewModel depends on UserRepository, in order to create instances of // LoginViewModel, you need an instance of UserRepository that you pass as a parameter. class LoginViewModelFactory implements Factory{ private final UserRepository userRepository; public LoginViewModelFactory(UserRepository userRepository) { this.userRepository = userRepository; } @Override public LoginViewModel create() { return new LoginViewModel(userRepository); } }
Você pode incluir a classe LoginViewModelFactory
no AppContainer
e fazer com que
LoginActivity
a consuma:
Kotlin
// AppContainer can now provide instances of LoginViewModel with LoginViewModelFactory class AppContainer { ... val userRepository = UserRepository(localDataSource, remoteDataSource) val loginViewModelFactory = LoginViewModelFactory(userRepository) } class LoginActivity: Activity() { private lateinit var loginViewModel: LoginViewModel override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // Gets LoginViewModelFactory from the application instance of AppContainer // to create a new LoginViewModel instance val appContainer = (application as MyApplication).appContainer loginViewModel = appContainer.loginViewModelFactory.create() } }
Java
// AppContainer can now provide instances of LoginViewModel with LoginViewModelFactory public class AppContainer { ... public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource); public LoginViewModelFactory loginViewModelFactory = new LoginViewModelFactory(userRepository); } public class MainActivity extends Activity { private LoginViewModel loginViewModel; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // Gets LoginViewModelFactory from the application instance of AppContainer // to create a new LoginViewModel instance AppContainer appContainer = ((MyApplication) getApplication()).appContainer; loginViewModel = appContainer.loginViewModelFactory.create(); } }
Essa abordagem é melhor do que a anterior, mas ainda há alguns desafios que precisam ser considerados:
Você precisa gerenciar o
AppContainer
por conta própria, criando instâncias para todas as dependências manualmente.Ainda há muito código boilerplate. Você precisa criar fábricas ou parâmetros manualmente, dependendo de querer reutilizar um objeto ou não.
Como gerenciar dependências em fluxos de aplicativos
O AppContainer
se torna complicado quando você quer incluir mais funcionalidades
no projeto. Quando o app fica maior e você começa a apresentar diferentes
fluxos de recursos, surgem ainda mais problemas:
Quando há fluxos diferentes, é recomendável que os objetos estejam no escopo de cada um. Por exemplo, ao criar
LoginUserData
, que pode consistir no nome de usuário e senha usados somente no fluxo de login, não convém persistir dados do fluxo de login antigo de um usuário diferente. É recomendável criar uma nova instância para cada novo fluxo. Para isso, crie objetosFlowContainer
dentro doAppContainer
, conforme demonstrado no próximo exemplo de código.Otimizar o gráfico do aplicativo e os contêineres de fluxo também pode ser difícil. É preciso lembrar de excluir instâncias que não são necessárias, dependendo do fluxo em uso.
Imagine que você tenha um fluxo de login que consiste em uma atividade (LoginActivity
)
e vários fragmentos (LoginUsernameFragment
e LoginPasswordFragment
).
Essas visualizações buscam:
acessar a mesma instância de
LoginUserData
, que precisa ser compartilhada até que o fluxo de login seja concluído;criar uma nova instância de
LoginUserData
quando o fluxo começa novamente.
É possível fazer isso usando um contêiner de fluxo de login. Esse contêiner precisa ser criado quando o fluxo de login é iniciado e removido da memória ao fim do fluxo.
Veja como adicionar um LoginContainer
ao exemplo de código. Convém criar várias instâncias
de LoginContainer
no app. Portanto, em vez de torná-lo um singleton,
crie uma classe com as dependências necessárias para o fluxo de login
do AppContainer
.
Kotlin
class LoginContainer(val userRepository: UserRepository) { val loginData = LoginUserData() val loginViewModelFactory = LoginViewModelFactory(userRepository) } // AppContainer contains LoginContainer now class AppContainer { ... val userRepository = UserRepository(localDataSource, remoteDataSource) // LoginContainer will be null when the user is NOT in the login flow var loginContainer: LoginContainer? = null }
Java
// Container with Login-specific dependencies class LoginContainer { private final UserRepository userRepository; public LoginContainer(UserRepository userRepository) { this.userRepository = userRepository; loginViewModelFactory = new LoginViewModelFactory(userRepository); } public LoginUserData loginData = new LoginUserData(); public LoginViewModelFactory loginViewModelFactory; } // AppContainer contains LoginContainer now public class AppContainer { ... public UserRepository userRepository = new UserRepository(localDataSource, remoteDataSource); // LoginContainer will be null when the user is NOT in the login flow public LoginContainer loginContainer; }
Depois que você consegue um contêiner específico para um fluxo, é preciso decidir quando criar
e excluir a instância do contêiner. Como o fluxo de login é autossuficiente em
uma atividade (LoginActivity
), ela gerencia o ciclo de vida
desse contêiner. LoginActivity
pode criar a instância em onCreate()
e
excluí-la em onDestroy()
.
Kotlin
class LoginActivity: Activity() { private lateinit var loginViewModel: LoginViewModel private lateinit var loginData: LoginUserData private lateinit var appContainer: AppContainer override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) appContainer = (application as MyApplication).appContainer // Login flow has started. Populate loginContainer in AppContainer appContainer.loginContainer = LoginContainer(appContainer.userRepository) loginViewModel = appContainer.loginContainer.loginViewModelFactory.create() loginData = appContainer.loginContainer.loginData } override fun onDestroy() { // Login flow is finishing // Removing the instance of loginContainer in the AppContainer appContainer.loginContainer = null super.onDestroy() } }
Java
public class LoginActivity extends Activity { private LoginViewModel loginViewModel; private LoginData loginData; private AppContainer appContainer; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); appContainer = ((MyApplication) getApplication()).appContainer; // Login flow has started. Populate loginContainer in AppContainer appContainer.loginContainer = new LoginContainer(appContainer.userRepository); loginViewModel = appContainer.loginContainer.loginViewModelFactory.create(); loginData = appContainer.loginContainer.loginData; } @Override protected void onDestroy() { // Login flow is finishing // Removing the instance of loginContainer in the AppContainer appContainer.loginContainer = null; super.onDestroy(); } }
Como em LoginActivity
, os fragmentos de login podem acessar o LoginContainer
pelo
AppContainer
e usar a instância compartilhada de LoginUserData
.
Como neste caso você está lidando com a lógica do ciclo de vida da visualização, é recomendável usar a observação do ciclo de vida.
Conclusão
A injeção de dependências é uma boa técnica para criar apps Android escalonáveis e testáveis. Use contêineres como uma maneira de compartilhar instâncias de classes em diferentes partes do app e como um local centralizado para criar instâncias de classes usando fábricas.
Quando o aplicativo ficar maior, vai ser necessário programar muitos códigos boilerplate (como fábricas), que podem ser propensos a erros. Também é preciso gerenciar o escopo e ciclo de vida dos contêineres, otimizando e descartando os que não são mais necessários para liberar memória. Fazer isso incorretamente pode levar a bugs e vazamentos de memória sutis no app.
Na seção sobre o Dagger, você vai aprender a usar esse framework para automatizar esse processo e gerar o mesmo código que você teria programado manualmente.