IT knowledge base
CTRL+F per cercare la tua parola chiave

Dagger 2 per sviluppatori Android inesperti. Iniezione di dipendenza. Parte 2

Questo articolo è la terza parte di una serie di articoli, destinati, secondo l'autore, a coloro che non riescono a capire come gestire l' iniezione di dipendenza e il framework Dagger 2 , o semplicemente lo faranno. Scritto in originale il 1 dicembre 2017. Traduzione gratis.
Immagine
Questo è il terzo articolo della serie Dagger 2 per sviluppatori Android principianti. ... Se non hai letto i precedenti, allora sei qui .

Serie di articoli

All'inizio della serie

Nell'ultimo articolo, abbiamo esaminato più da vicino le dipendenze e l'iniezione di dipendenza. Abbiamo anche visto un esempio: una battaglia di bastardi, in cui abbiamo creato una classeWar con dipendenze dure .

Usando il vetro del drago

Ricordiamo l'esempio discusso in precedenza: la battaglia dei bastardi. in classeWar ci sono due legami forti:Boltons eStarks ...
public class War {
    private Starks starks;
    private Boltons boltons;

    public War(){
        starks = new Starks();
        boltons = new Boltons();

        starks.prepareForWar();
        starks.reportForWar();
        boltons.prepareForWar();
        boltons.reportForWar();
    }
}
È ora di usare il vetro del drago e distruggere gli Estranei. Sì, utilizzeremo l'iniezione di dipendenza per eliminare i collegamenti forti.
Ricordiamo l'idea dell'iniezione di dipendenza. La classe non deve creare altre classi. Invece, deve ricevere dipendenze dall'esterno. Prendiamo le dipendenzeBoltons eStarks all'esterno, tramite il costruttore di classiWar ...
public class War {
    private Starks starks;
    private Boltons boltons;
    
    // Dependency Injection (DI) - getting dependencies from elsewhere through the constructor
    public War (Starks starks, Boltons boltons) {
        this.starks = starks;
        this.boltons = boltons;
    }

    public void prepare () {
        starks.prepareForWar ();
        boltons.prepareForWar ();
    }

    public void report () {
        starks.reportForWar ();
        boltons.reportForWar ();
    }
}
L'esempio sopra è un'opzione di iniezione delle dipendenze del costruttore. Probabilmente stai pensando ora che lo stai facendo tutto il tempo nei tuoi progetti. Esatto, molte persone usano il concetto di iniezione di dipendenza senza rendersene conto.
ClasseWar deve sapere non solo come svolgere un determinato compito, ma anche dove cercare le classi di cui ha bisogno per svolgere i suoi compiti. Se forniamo tutto ciò di cui la nostra classe ha bisogno per lavorare all'esterno, ci liberiamo dei problemi discussi in precedenza. La classe può lavorare facilmente con qualsiasi istanza di altre classi di cui ha bisogno per svolgere i suoi compiti e verrà semplicemente testata isolatamente da esse. In un'applicazione che usa l'inserimento delle dipendenze, gli oggetti non cercheranno mai le dipendenze né le creeranno internamente. Tutte le dipendenze sono fornite o incorporate in esso pronte per l'uso.
Ad un certo punto, ovviamente, qualcuno deve istanziare le classi di dipendenza e fornirle agli oggetti che ne hanno bisogno. In genere, questo lavoro viene eseguito nel punto di ingresso dell'applicazione. In una normale applicazione Java, ad esempio, tale codice può essere trovato all'interno del metodomain() come mostrato di seguito. Su Android, questo viene solitamente eseguito nel metodoonCreate() all'interno dell'attività .
public class BattleOfBastards {

    public static void main(String[] args){
        Starks starks = new Starks();
        Boltons boltons = new Boltons();

        War war = new War(starks,boltons);
        war.prepare();
        war.report();
    }
}
In classeBattleOfBastards creiamo dipendenzeBoltons eStarks e iniettare da attraverso il costruttore nella classeWar ... Classe dipendenteWar dipende dalle dipendenzeBoltons eStarks ...
È tempo di apprezzare te stesso e festeggiare. Sì, abbiamo distrutto gli Estranei (legami forti)! Spero che tu capisca il concetto di ciò che stiamo cercando di analizzare.

Sommario

In questo articolo, ci siamo resi conto che una classe non dovrebbe creare dipendenze al suo interno. Invece, dovrebbe riceverli dall'esterno.
Abbiamo anche visto in azione un semplice piano di iniezione delle dipendenze. Abbiamo preso un esempio dalla battaglia dei bastardi e abbiamo cercato di eliminare i legami forti con l'iniezione di dipendenza.
media
Immagine

Qual è il prossimo?

Nel prossimo articolo discuteremo della libreria Dagger 2. Diamo un'occhiata alle annotazioni e a come Dagger 2 renderà più facile l'iniezione delle dipendenze di fronte a progetti più complessi e confusi. Il prossimo articolo uscirà tra una settimana.