Dagger Android, tudo que você precisa entender em português. Parte-1
Olá, hoje vamos descrever pontos que é muito interessante você ter em mente quando pensa em usar injeção de dependências e Dagger Android.
Vamos ir detalhando em cada tópico para você que é iniciante no assunto, intermediário ou se já tem uma boa base poder ir pulando alguns pontos fundamentais para sua jornada no uso de DI (Inject Dependency)
Os links de toda a sequência você encontra aqui:
______________________________________________________________
Parte 1 — Os tópicos que iremos abordar nesta primeira parte são:
- Conceito de injeção de dependências.
- Exemplo de injeção de dependência manual.
- Exemplo de testes unitários com injeção manual.
- Seguindo a risca, como seria no Android.
- Dagger Android pela Google.
- Configurando o Dagger Android.
- Referências.
______________________________________________________________
Parte 2 — Na segunda parte deste assunto iremos ver na prática como por exemplo:
- Configurando um modulo como exemplo.
- Exemplo de testes unitários deste modulo.
- Exemplo de testes integrados com Espresso.
- Vantagens
- Desvantagens.
- Outros Design Patterns parecidos.
- Outras bibliotecas disponíveis.
- Repositório onde você encontra todos os exemplos.
- Referências.
______________________________________________________________
Parte 3 — E por último:
- Como fica na visão modularizada.
- Hilt!
- Referências.
______________________________________________________________
Conceito de injeção de dependências
Injeção de dependência é um Design Pattern que tem como objetivo fornecer as instâncias que a classe precisa, sem duplicar instâncias. Remover acoplamento de classes. Maior performace em não criar objetos desnecessários e facilitar também os testes tanto integrados como unitários.
O motivo de usar isto em seu projeto não é novo para o mundo de desenvolvimento de software. Backend, e outras tecnologias já utilizam este Pattern com anotações similares chamadas de “Binds” por exemplo no spring boot Java.
______________________________________________________________
Exemplo de injeção de dependência manual
Antes de sair injetando com bibliotecas disponíveis na web, é importante que você consiga visualizar como é a injeção manual. Pois assim, independente do framework que você utiliza o conceito por trás você entende.
Vamos lá, vou seguir o exemplo que o google disponibiliza em um do seus vários codelabs e descricões de tópicos e pegar uma classe carro a exemplo:
Aqui vemos que nossa classe carro tem um motor ( Engine ) para quando instânciamos um Carro ele vai pegar e no metodo start dar o start no Motor.
Beleza, aqui vemos que a classe Carro e Motor estão fortemente acoplados, e a princípio não temos como melhorar nosso Motor em algum futuro pois tem aquele tipo de motor (Engine) e só.
Fazendo a injeção manual temos que passar no construtor do Carro o motor que queremos, assim vamos diminuir o acoplamento. Isso já esta melhorando nosso código.
Agora quando vamos instânciar o objeto CarInjectredNative temos que passar no construtor dele o Motor.
Assim, a nossa visualização de código comparado a uma injeção não manual e uma injeção manual ficaria assim:
Para melhorar em questão do que as classes podem ou não ver, é recomendado que no construtor em vez de você passar a classe em sí mesma. Você passe uma interface. Pois assim, você pode ver a seguir a melhoria em questão de passagem de diferentes motores mas sempre ao final o que importa para o carro é que seja um motor e não um tipo especifico para este exemplo de motor.
Sendo assim, o próximo tópico sobre testes unitários irei mostrar como funciona o que estou querendo dizer acima.
______________________________________________________________
Exemplo de testes unitários com injeção manual
Vamos então mostrar um exemplo referente ao da classe Carro, passando uma interface em seu construtor de motor e ai sim, vêndo as vantagens que isso nos proporciona nos testes unitários.
Para nossos testes então vamos ter o seguinte cenário. Vamos validar quando passamos um motor de Ferrari e outro de Mercedes, na hora de verificarmos o getModel, para um a saída será “Meu motor é de uma Ferrari” e no caso da Mercedes “Meu motor é de uma Merecedes”
Sendo assim nossos testes ficaria assim:
Agora estamos conseguindo visualizar que posso passar qualquer instância de motores dentro do meu construtor de carro e ele verifica o comportamento pelo que realmente implementa.
O grafico para olhar isso melhor seria assim:
______________________________________________________________
Seguindo a risca, como seria no Android
Ok, mas e se quisermos fazer isso no Android? no nosso ciclo de vida lá na MainActivity por exemplo, como que fica? Ficaria ao que entendemos com os exemplos acima da seguinte maneira:
Aqui se tentarmos por exemplo adicionarmos ao construtor do onCreate a classe LoginViewModel, vamos ver que estamos quebrando a assinatura do onCreate. Então como vamos usar Injeção de dependência no Android?
Então, para isso seguindo a risca, a ferramenta que vem para nos ajudar é o:
Dagger!
Ele será a nossa caixa mágica que vai cuidar para nós todo esse trabalho que teriamos acima. Mais a frente vou mostrar um gráfico mostrando que injeção manual não é um trabalho simples de se manter em dia ao longo de grandes projetos (Já com ferramentas como Dagger, Koin, Kodein ainda assim temos dificuldades)
Contando um pouco da história do Dagger, bom, ele vem do time do Square que é parceiro do Google e começou lá com seu Dagger 1. Depois criaram o Dagger 2 que também não é muito claro para novos desenvolvedores, então o Google cria o Dagger.Android para facilitar um pouco o proceso(Atualmente foi lançado o Hilt, que vou recomendar uma leitura para você aqui mesmo do Android Dev Brasil) Que seria uma maneira de tentar facilitar o aprendizado desta biblioteca que funciona a base de Anotações de processos (Seguir uma receita de bolo para seu código ser gerado no build)
______________________________________________________________
Dagger Android pela Google
O google no ano de 2019 no google IO lançou a seguinte apresentação:
Nele resumindo você tem uma ideia de qual tamanho é bom começar a colocar injeção de dependências não manuais (usando dagger)
A curva de aprendizado que eles veem na comunidade android:
E ai mostram como é mais “Fácil” usar o Dagger.
Eu troquei uma ideia com o Manuel Vivo no Twitter sobre escrever sobre esse assunto em portugues,
Meu inglês não é dos melhores mas deu para ter essa aproximação o que é muito bacana.
______________________________________________________________
Concluindo a primeira parte deste assunto
Bom, ficamos por aqui nesse primeiro assunto para não se estender muito.
Na segunda parte vamos ver como configurar um projeto e mais a frente como seria em uma versão com modularização. Valeu, espero que tenha gostado. Deixe seu joinha e acompanhe-me na próxima jornada que temos pela frente, abraço!
______________________________________________________________
Referências
https://developer.android.com/training/dependency-injection?hl=pt-br
