O punhal 2 é elementar (parte 1)

Conteúdo

1. 1. Introdução
2. O que é injeção de dependência, exemplo de dependência
3. Adaga 2 - Introdução
4. Primeiro uso do Dagger 2

1. Introdução

O artigo não foi escrito por um programador avançado com as mesmas palavras comuns e compreensíveis.
Este artigo usa o código de exemplo Kotlin. Adaga versão 2.17. Um exemplo pode ser baixado no final do artigo.

O que é injeção de dependência?

Injeção de Dependência (injeção ou injeção de dependência) é a dependência de uma classe em outra. isto é para a operação completa de uma classe, é necessária a inicialização da outra (sua) classe.

Por exemplo, a classe Car (carro) não pode funcionar sem a classe Engine, que por sua vez não pode funcionar sem a classe Fuel. É assim:

class Car(private var engine: Engine) class Engine ( private var fuel: Fuel) class Fuel(){ private val fuel = if(BuildConfig.DEBUG){ “benzine” } else { “diesel” } } 

Neste exemplo, a classe Car depende da classe Engine e, por sua vez, depende da classe Fuel.

Adaga 2 - Introdução

O Dagger é uma biblioteca que ajuda a implementar a injeção de dependência:. Esta é uma biblioteca do google. Documentação detalhada está disponível aqui .

Prós da adaga:

• Eu tenho que escrever menos código padrão.
• Ajuda a estruturar dependências.
• Simplifica bastante o trabalho quando existem muitas dependências
• O código se torna fácil de ler.

Contras da adaga:

• Falta de documentação detalhada
• Dagger tenta entender as intenções do desenvolvedor usando anotações. Fica complicado quando ele não entende você corretamente
• punhal gera código que é tão difícil de detectar

Primeiro uso do Dagger 2

Primeiro de tudo, você precisa adicionar punhal ao aplicativo. Eu sei 2 métodos como fazê-lo
1. Abra build.gradle (App) e adicione um rastreio.

1.1 No topo da seção de declaração do plugin

 apply plugin: 'kotlin-kapt' 

1.2 na seção dependências

 { ... kapt "com.google.dagger:dagger-compiler:$dagger_version" implementation "com.google.dagger:dagger:$dagger_version" } 

Eu especifico a versão do punhal (dagger_version) na seção

 ext { dagger_version = '2.17' } 

Se não for esse o caso, a seção precisará ser adicionada acima da seção android.

2. Adicione o repositório Maven através da estrutura do projeto - dependências - adicione dependências da biblioteca

Depois de sincronizar o projeto, estamos prontos para implementar dependências usando o punhal.

Primeiro, crie as classes Car, Engine e Fuel:

 class Car constructor(private var engine: Engine) class Engine constructor(private var fuel: Fuel) class Fuel { private val fuelType = if(BuildConfig.DEBUG){ "benzine" }else{ "diesel" } } 

Antes dos construtores das classes Carro, Motor e Combustível, adicionamos a anotação Injeção do punhal, permitindo que o punhal entenda que essas classes devem ser implementadas, se necessário. Temos o rastro.

 class Car @Inject constructor(private var engine: Engine) class Engine @Inject constructor(private var fuel: Fuel) class Fuel @Inject constructor() { private val fuelType = if(BuildConfig.DEBUG){ "benzine" }else{ "diesel" } } 

O Dagger precisa saber como criar todos os objetos que ele precisa implementar. Para listar todas as classes que implementamos (Injetar), é usada a anotação Component , que é declarada para a interface (DaggerComponent).

É assim:

 @Component interface DaggerComponent { fun getCar(): Car fun getEngine(): Engine fun getFuel(): Fuel } 

Ao declarar métodos de componentes, não são os nomes dos métodos que são importantes, mas a classe que eles retornam.

Nesta etapa, você precisa criar um projeto (Build - Rebuild project). Depois disso, o punhal irá gerar as classes e a fábrica necessárias para inicializar os componentes. O nome da fábrica coincidirá com o nome da interface na qual inicializamos as classes para o punhal, exceto que o prefixo “Punhal” será adicionado, ou seja, na saída, obtemos a classe DaggerDaggerComponent.

 // Generated by Dagger (https://google.imtqy.com/dagger). package com.example.dagger2; public final class DaggerDaggerComponent implements DaggerComponent { private DaggerDaggerComponent(Builder builder) {} public static Builder builder() { return new Builder(); } public static DaggerComponent create() { return new Builder().build(); } @Override public Car getCar() { return new Car(getEngine()); } @Override public Engine getEngine() { return new Engine(new Fuel()); } @Override public Fuel getFuel() { return new Fuel(); } public static final class Builder { private Builder() {} public DaggerComponent build() { return new DaggerDaggerComponent(this); } } } 

Está tudo pronto. Vamos tentar criar um campo de carro do tipo Car em MainActivity:

 private var car: Car = DaggerDaggerComponent.create().getCar() 

Ao iniciar o aplicativo, você pode garantir que o campo do carro seja inicializado ao acessá-lo

Código fonte