Click here to load reader

dagger-2 · PDF file Di 1 Capitolo 1: Iniziare con Dagger-2 2 Osservazioni 2 Versioni 2 Examples 2 Descrizione e configurazione 2 Esempio di base 3 Esempio di Android 4 Impara Dagger2

  • View
    2

  • Download
    0

Embed Size (px)

Text of dagger-2 · PDF file Di 1 Capitolo 1: Iniziare con Dagger-2 2 Osservazioni 2 Versioni 2...

  • dagger-2

    #dagger-2

  • Sommario

    Di 1

    Capitolo 1: Iniziare con Dagger-2 2

    Osservazioni 2

    Versioni 2

    Examples 2

    Descrizione e configurazione 2

    Esempio di base 3

    Esempio di Android 4

    Impara Dagger2 con un semplice esempio 5

    Perché ne abbiamo bisogno? 5

    Iniziamo con un semplice esempio 6

    Aggiungi le dipendenze di Dagger2 6

    Due semplici classi 6

    Classe del modulo 7

    Interfaccia @Component 8

    Iniettare Dipendenza in Costruttore 8

    Inject dependency in MainClass 8

    Capitolo 2: Annotazione @Named in Kotlin 9

    introduzione 9

    Examples 9

    Dichiarazione di una dipendenza qualificata 9

    Iniezione di dipendenza basata su setter 9

    Iniezione di dipendenza basata sul costruttore 9

    Titoli di coda 10

  • Di

    You can share this PDF with anyone you feel could benefit from it, downloaded the latest version from: dagger-2

    It is an unofficial and free dagger-2 ebook created for educational purposes. All the content is extracted from Stack Overflow Documentation, which is written by many hardworking individuals at Stack Overflow. It is neither affiliated with Stack Overflow nor official dagger-2.

    The content is released under Creative Commons BY-SA, and the list of contributors to each chapter are provided in the credits section at the end of this book. Images may be copyright of their respective owners unless otherwise specified. All trademarks and registered trademarks are the property of their respective company owners.

    Use the content presented in this book at your own risk; it is not guaranteed to be correct nor accurate, please send your feedback and corrections to [email protected]

    https://riptutorial.com/it/home 1

    http://riptutorial.com/ebook/dagger-2 https://archive.org/details/documentation-dump.7z mailto:[email protected]

  • Capitolo 1: Iniziare con Dagger-2

    Osservazioni

    Questa sezione fornisce una panoramica di cosa sia Dagger-2 e perché uno sviluppatore potrebbe volerlo utilizzare.

    Dovrebbe anche menzionare qualsiasi argomento di grandi dimensioni all'interno di Dagger-2 e collegarsi agli argomenti correlati. Poiché la documentazione di dagger-2 è nuova, potrebbe essere necessario creare versioni iniziali di tali argomenti correlati.

    Versioni

    Versione Data di rilascio

    2.5 2016/06/14

    2.6 2016/07/27

    2.7 2016/09/13

    2.8 2016/11/22

    2.9 2017/02/03

    2.10 2017/03/15

    Examples

    Descrizione e configurazione

    Cos'è Dagger 2?

    Il sito web si descrive come:

    Dagger è un framework di iniezione delle dipendenze completamente statico e in fase di compilazione

    La libreria semplifica la modellazione dei grafici delle dipendenze e il riutilizzo degli oggetti. Poiché la reflection viene utilizzata solo in fase di compilazione come parte dell'elaborazione dell'annotazione, Dagger 2 ha migliorato la velocità per l'iniezione delle dipendenze.

    Impostare

    1- Aggiungi supporto per l'elaborazione delle annotazioni:

    https://riptutorial.com/it/home 2

  • androide

    Script build.gradle livello build.gradle :

    repositories { mavenCentral() } dependencies { classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8' }

    Script di build.gradle livello di modulo:

    apply plugin: 'com.neenbedankt.android-apt'

    Giava

    plugins { id "net.ltgt.apt" version "0.5" }

    2- Aggiungi le dipendenze del pugnale 2

    dependencies { compile 'com.google.dagger:dagger:2.x' apt 'com.google.dagger:dagger-compiler:2.x' }

    Esempio di base

    Definire un modulo (il modello delle dipendenze e il loro grafico):

    @Module public class CoffeeModule{ @Provides public CoffeeMaker provideCoffeeMaker(){ return new CoffeeMaker(); } @Provides public Coffee provideCoffee(CoffeeMaker coffeeMaker){ return new Coffee(coffeeMaker); } }

    Definire un componente:

    @Component( modules={ CoffeeModule.class }

    https://riptutorial.com/it/home 3

  • ) interface CoffeeComponent { DeveloperActivity inject(DeveloperActivity developerActivity); }

    Inietti le dipendenze:

    class DeveloperActivity extends ...{ @Inject Coffee myCoffee; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); DaggerCoffeeComponent.builder() .coffeeModule(new CoffeeModule()) .build() .inject(); } }

    Esempio di Android

    Una delle difficoltà principali della scrittura di un'applicazione Android con Dagger è che molte classi di framework Android sono istanziate dal sistema operativo stesso, come Activity e Fragment , ma Dagger funziona meglio se può creare tutti gli oggetti iniettati. Invece, è necessario eseguire l'iniezione dei membri in un metodo del ciclo di vita. A partire dalla versione 2.10, il pugnale consente di utilizzare dagger.android che semplifica l'uso di dagger con componenti Android.

    Iniezione di oggetti Attività

    Installa AndroidInjectionModule nel componente dell'applicazione per assicurarti che tutti i binding necessari per questi tipi di base siano disponibili.

    @Component(modules = {AndroidInjectionModule.class}) public interface AppComponent {}

    1.

    Inizia scrivendo un @Subcomponent che implementa [AndroidInjector] [AndroidInjector], con un @Subcomponent.Builder che estende [AndroidInjector.Builder] [AndroidInjector.Builder]:

    @Subcomponent public interface MainActivityComponent extends AndroidInjector { @Subcomponent.Builder abstract class Builder extends AndroidInjector.Builder {} }

    2.

    Dopo aver definito il sottocomponente, aggiungerlo alla gerarchia dei componenti definendo 3.

    https://riptutorial.com/it/home 4

  • un modulo che associa il builder del sottocomponente e aggiungendolo al componente che inietta l' Application :

    @Module(subcomponents = MainActivityComponent.class) public abstract class MainActivityModule { @Binds @IntoMap @ActivityKey(MainActivity.class) abstract AndroidInjector.Factory

  • Semplifica l'accesso alle istanze condivise: fornisce un modo semplice per ottenere riferimenti ad istanze condivise, ad esempio una volta dichiarate in Dagger le nostre istanze singleton come SharedPrefrences quindi possiamo dichiarare campi con una semplice annotazione @Inject .

    Test di unità e integrazione più facili: possiamo facilmente sostituire moduli che creano risposte di rete e prendiamo in giro questo comportamento.

    Iniziamo con un semplice esempio

    La piena fonte di esempi è disponibile sul mio account GitHub.

    Aggiungi le dipendenze di Dagger2

    Prima di tutto dobbiamo aggiungere le dipendenze di Dagger2, Inserisci sotto il codice nel file build.gradle a livello di modulo.

    compile "com.google.dagger:dagger:$dagger_version" compile "com.google.dagger:dagger-android:$dagger_version" compile "com.google.dagger:dagger-android-support:$dagger_version" annotationProcessor "com.google.dagger:dagger-compiler:$dagger_version"

    Se ricevi un errore come Errore: Conflitto con dipendenza 'com.google.code.findbugs: jsr305' nel progetto ': app' dovresti aggiungere quanto segue al tuo app principale / file build.gradle.

    configurations.all { resolutionStrategy.force 'com.google.code.findbugs:jsr305:3.0.1' }

    Due semplici classi

    Abbiamo due classi (Veicolo e Motore), la classe Veicolo ha bisogno di una Classe di motori per funzionare e MainActivity ha bisogno di classe Veicolo. Useremo Dagger2 per fornire queste istanze.

    class Vehicle { private Motor motor; @Inject Vehicle(Motor motor) { this.motor = motor; } void increaseSpeed(int value) { motor.accelerate(value); } void decreaseSpeed(int value) { motor.decelerate(value); }

    https://riptutorial.com/it/home 6

    https://github.com/hanihashemi/Dagger2SimpleExample

  • void stop() { motor.brake(); } int getSpeed() { return motor.getRpm(); } }

    Classe del motore:

    class Motor { private int rpm; Motor() { this.rpm = 0; } int getRpm() { return rpm; } void accelerate(int value) { rpm += value; } void decelerate(int value) { rpm -= value; } void brake() { rpm = 0; } }

    Classe del modulo

    La classe del modulo è responsabile della fornitura di oggetti che possono essere iniettati, In questo esempio vogliamo iniettare la classe Motor alla classe Vehicle e iniettare la classe Vehicle in MainActivity, quindi dovremmo creare MyModule per fornire queste istanze.

    @Module class MyModule { @Provides @Singleton Motor provideMotor() { return new Motor(); } @Provides @Singleton Vehicle provideVehicle() { return new Vehicle(new Motor()); }

    https://riptutorial.com/it/home 7

  • }

    @Annuncio: l' oggetto restituito da questo metodo è disponibile per l'iniezione delle dipendenze.

    Interfaccia @Component

    Dagger2 ha bisogno dell'interfaccia del componente per sapere come dovrebbe creare istanze dalle nostre classi.

    @Singleton @Component(modules = {MyModule.class}) interface My

Search related