Injection de dépendances avec Dagger 2 sur Android

L’injection de dépendances est un modèle de conception logicielle visant à rendre nos applications faiblement couplées, extensibles et maintenables. Dans ce didacticiel, vous apprendrez à gérer l’injection de dépendances à l’aide de Dagger 2.

introduction

Lorsque vous avez un objet qui a besoin ou dépend d’un autre objet pour faire son travail, vous avez une dépendance. Les dépendances peuvent être résolues en laissant l’objet dépendant créer la dépendance ou en demandant à un objet usine d’en créer une. Dans le contexte de l’injection de dépendances, cependant, les dépendances sont fournies à la classe qui a besoin de la dépendance pour éviter que la classe elle-même ne les crée. De cette façon, vous créez un logiciel faiblement couplé et hautement maintenable.

Ce tutoriel utilise la dernière version de Dagger, Dague 2. Au moment de la rédaction de cet article, Dagger 2 n’est pas encore officiellement sorti et est en phase pré-alpha. Cependant, il est utilisable et stable. Vous pouvez visiter Dagger sur GitHub pour avoir des nouvelles du projet et des dates possibles de sortie officielle.

Conditions préalables

Vous aurez besoin de la dernière version d’Android Studio installée sur votre machine de développement, que vous pouvez télécharger à partir du Site Web des développeurs Android.

1. API Dagger 2

Dagger 2 expose un certain nombre d’annotations spéciales:

• @Module pour les classes dont les méthodes fournissent des dépendances
• @Provides pour les méthodes dans @Module Des classes
• @Inject pour demander une dépendance (un constructeur, un champ ou une méthode)
• @Component est une interface de pont entre les modules et l’injection

Ce sont les annotations les plus importantes que vous devez connaître pour démarrer avec l’injection de dépendances à l’aide de Dagger 2. Je vais vous montrer comment les utiliser dans une application Android simple.

2. Flux de travail de Dagger 2

Pour implémenter correctement Dagger 2, vous devez suivre ces étapes:

1. Identifiez les objets dépendants et leurs dépendances.
2. Créez une classe avec le @Module annotation, à l’aide de @Provides annotation pour chaque méthode qui renvoie une dépendance.
3. Demandez des dépendances dans vos objets dépendants à l’aide du @Inject annotation.
4. Créez une interface à l’aide du @Component annotation et ajoutez les classes avec @Module annotation créée à la deuxième étape.
5. Créez un objet du @Component interface pour instancier l’objet dépendant avec ses dépendances.

L’analyse des dépendances passe du moment de l’exécution au moment de la compilation. Cela signifie que vous êtes averti des problèmes possibles pendant la phase de développement, contrairement à d’autres bibliothèques, telles que Guice. Avant d’utiliser la bibliothèque Dagger 2, vous devez préparer votre installation Android Studio pour accéder aux classes générées.

3. Configuration de l’environnement Android Studio

Étape 1

Créez une nouvelle application à l’aide d’Android Studio et donnez-lui un nom. J’ai nommé mon projet TutsplusDague.

Étape 2

Met le SDK minimum pour que le projet API 10 pour atteindre autant d’appareils que possible.

Étape 3

Choisir la Vide mise en page de l’activité que vous créez. Pour ce didacticiel, vous n’avez pas besoin d’une mise en page spéciale.

Étape 4

Nommez l’activité MainActivity et cliquez terminer.

Une fois le projet créé, vous devez apporter quelques modifications aux fichiers gradle. Faisons ces changements à l’étape suivante.

4. Configuration de la configuration de Gradle

Étape 1

Nous devons modifier le projet build.gradle fichier comme indiqué ci-dessous.

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:1.0.0'
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.4'
    }
}

allprojects {
    repositories {
        mavenCentral()
        maven{
            url 'https://oss.sonatype.org/content/repositories/snapshots/'
        }
    }
}

Prenons un moment pour voir les changements que nous avons apportés:

• dépendances: Dans cette section, j’ai ajouté un plugin qui va être utile pour accéder au code généré par Dagger. Si vous ne le faites pas, vous verrez des erreurs en vous référant à ces nouvelles classes.
• tous les projets: Ce changement est nécessaire car les bibliothèques que nous allons utiliser sont actuellement en pré-alpha, et c’est le seul endroit disponible si vous souhaitez y accéder en utilisant Maven. Vous pouvez essayer de télécharger le Dague et Compilateur Dagger bibliothèques de Sonatype, mais ce tutoriel est basé sur les référentiels Maven.

Étape 2

Ouvert build.gradle dans le dossier de l’application de votre projet et modifiez-le comme indiqué ci-dessous.

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

android {
    compileSdkVersion 21
    buildToolsVersion "21.1.2"

    defaultConfig {
        applicationId "com.androidheroes.tutsplusdagger"
        minSdkVersion 10
        targetSdkVersion 21
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:21.0.3'

    compile 'com.google.dagger:dagger:2.0-SNAPSHOT'
    apt 'com.google.dagger:dagger-compiler:2.0-SNAPSHOT'
    provided 'org.glassfish:javax.annotation:10.0-b28'
}

Au début du fichier, j’applique le nouveau plugin. Assurez-vous de mettre le nouveau plugin (com.neenbedankt.android-apt) ci-dessous ou après le plugin Android. Si vous ne le faites pas, des erreurs s’afficheront lors de la tentative de synchronisation du projet avec les fichiers gradle.

Dans dépendances J’ai ajouté:

• dague bibliothèque
• dague-compilateur pour la génération de code
• javax.annotation pour les annotations supplémentaires requises en dehors de Dagger

Après avoir mis à jour la configuration de Dagger, vous pouvez synchroniser le projet avec les fichiers gradle en cliquant sur le bouton en haut.

À ce stade, vous disposez d’un projet vide prêt à être utilisé dans votre application. Si vous voyez des erreurs, assurez-vous d’avoir correctement suivi les étapes ci-dessus. Nous pouvons maintenant procéder à la mise en œuvre de notre exemple de projet.

5. Implémentation de Dagger 2

Étape 1: identifier les objets dépendants

Pour ce tutoriel, je vais travailler avec deux classes, Vehicle et Motor. Motor est la classe indépendante et Vehicle est la classe dépendante. Je vais commencer à créer ce modèle dans un nouveau package appelé model.

C’est ce que le Motor la classe ressemble à:

package com.androidheroes.tutsplusdagger.model;

/**
 * Created by kerry on 14/02/15.
 */
public class Motor {

    private int rpm;

    public Motor(){
        this.rpm = 0;
    }

    public int getRpm(){
        return rpm;
    }

    public void accelerate(int value){
        rpm = rpm + value;
    }

    public void brake(){
        rpm = 0;
    }
}

Cette classe n’a qu’un seul attribut appelé rpm, que je vais modifier via le accelerate et brake méthodes. Et je vais vérifier la valeur actuelle en utilisant le getRpm méthode.

C’est ce que le Vehicle la classe ressemble à:

package com.androidheroes.tutsplusdagger.model;

/**
 * Created by kerry on 14/02/15.
 */
public class Vehicle {

    private Motor motor;

    public Vehicle(Motor motor){
        this.motor = motor;
    }

    public void increaseSpeed(int value){
        motor.accelerate(value);
    }

    public void stop(){
        motor.brake();
    }

    public int getSpeed(){
        return motor.getRpm();
    }
}

Dans cette classe, vous pouvez voir que je ne crée pas un nouvel objet du Motor classe, même si j’utilise ses méthodes. Dans une application du monde réel, cette classe devrait avoir plus de méthodes et d’attributs, mais gardons les choses simples pour le moment.

Étape 2: créer @Module Classe

Vous devez maintenant créer une classe avec le @Module
annotation. Cette classe va fournir les objets dont vous aurez besoin avec ses dépendances satisfaites. Pour cela, vous devez créer un nouveau package (juste pour le garder dans l’ordre), nommez-le module et ajoutez une nouvelle classe à l’intérieur comme suit:

package com.androidheroes.tutsplusdagger.module;

import com.androidheroes.tutsplusdagger.model.Motor;
import com.androidheroes.tutsplusdagger.model.Vehicle;

import javax.inject.Singleton;

import dagger.Module;
import dagger.Provides;

/**
 * Created by kerry on 14/02/15.
 */

@Module
public class VehicleModule {

    @Provides @Singleton
    Motor provideMotor(){
        return new Motor();
    }

    @Provides @Singleton
    Vehicle provideVehicle(){
        return new Vehicle(new Motor());
    }
}

Comme je l’ai spécifié dans Étape 1, Vehicle Besoins
Motor pour fonctionner correctement. C’est pourquoi vous devez créer deux fournisseurs, un pour Motor (le modèle indépendant) et un autre pour Vehicle
(indiquant sa dépendance).

N’oubliez pas que chaque fournisseur (ou méthode) doit avoir le
@Provides annotation et la classe doit avoir le @Module annotation. le @Singleton l’annotation indique qu’il n’y aura qu’une seule instance de l’objet.

Étape 3: Demander des dépendances dans les objets dépendants

Maintenant que vous avez les fournisseurs pour vos différents modèles, vous devez les demander. Tout comme Vehicle Besoins Motor, vous devez ajouter le @Inject annotation dans le Vehicle constructeur comme suit:

@Inject
public Vehicle(Motor motor){
    this.motor = motor;
}

Vous pouvez utiliser le @Inject annotation pour demander des dépendances dans le constructeur, les champs ou les méthodes. Dans ce cas, je garde l’injection dans le constructeur.

Étape 4: De liaison
@Modules Avec @Inject

La connexion entre le fournisseur de dépendances, @Module, et les classes qui les demandent via @Inject est fait en utilisant @Component, qui est une interface:

package com.androidheroes.tutsplusdagger.component;

import com.androidheroes.tutsplusdagger.model.Vehicle;
import com.androidheroes.tutsplusdagger.module.VehicleModule;

import javax.inject.Singleton;

import dagger.Component;

/**
 * Created by kerry on 14/02/15.
 */

@Singleton
@Component(modules = {VehicleModule.class})
public interface VehicleComponent {

    Vehicle provideVehicle();

}

À côté de la @Component annotation, vous devez spécifier les modules qui seront utilisés – dans ce cas, j’utilise VehicleModule, que nous avons créé plus tôt. Si vous avez besoin d’utiliser plus de modules, ajoutez-les simplement en utilisant une virgule comme séparateur.

Dans l’interface, ajoutez des méthodes pour chaque objet dont vous avez besoin et il vous en donnera automatiquement une avec toutes ses dépendances satisfaites. Dans ce cas, je n’ai besoin que d’un
Vehicle objet, c’est pourquoi il n’y a qu’une seule méthode.

Étape 5: Utilisation @Component Interface pour obtenir des objets

Maintenant que chaque connexion est prête, vous devez obtenir une instance de cette interface et appeler ses méthodes pour obtenir l’objet dont vous avez besoin. Je vais l’implémenter dans le onCreate méthode dans le MainActivity comme suit:

package com.androidheroes.tutsplusdagger;

import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.widget.Toast;

import com.androidheroes.tutsplusdagger.component.Dagger_VehicleComponent;
import com.androidheroes.tutsplusdagger.component.VehicleComponent;
import com.androidheroes.tutsplusdagger.model.Vehicle;
import com.androidheroes.tutsplusdagger.module.VehicleModule;

public class MainActivity extends ActionBarActivity {

    Vehicle vehicle;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        VehicleComponent component = Dagger_VehicleComponent.builder().vehicleModule(new VehicleModule()).build();

        vehicle = component.provideVehicle();

        Toast.makeText(this, String.valueOf(vehicle.getSpeed()), Toast.LENGTH_SHORT).show();
    }
}

Lorsque vous essayez de créer un nouvel objet de l’interface avec le @Component annotation, vous devez le faire en utilisant le préfixe Dagger_<NameOfTheComponentInterface>, dans ce cas Dagger_VehicleComponent, puis utilisez le builder méthode pour appeler chaque module à l’intérieur.

Vous pouvez voir que la magie a lieu à la ligne 23. Vous ne demandez qu’un seul objet de la classe Vehicle et la bibliothèque est chargée de satisfaire toutes les dépendances dont cet objet a besoin. Encore une fois, vous pouvez voir qu’il n’y a pas de nouvelle instanciation d’un autre objet – tout est géré par la bibliothèque.

Vous pouvez maintenant exécuter l’application et l’essayer sur votre appareil ou dans un émulateur. Si vous avez suivi le tutoriel étape par étape, vous verrez un Toast message indiquant la valeur initiale ou le rpm variable.

Dans le projet joint, vous pouvez voir une interface utilisateur personnalisée pour le MainActivity classe, dans laquelle vous pouvez modifier la valeur de rpm variable en appuyant sur les boutons à l’écran.

Conclusion

L’injection de dépendances est un modèle que vous devrez implémenter tôt ou tard dans vos propres applications. Avec Dagger 2, vous disposez d’une bibliothèque facile à utiliser pour l’implémenter. J’espère que vous avez trouvé ce tutoriel utile, et n’oubliez pas de le partager si vous l’avez aimé.

Un excellent moyen de s’améliorer en tant que développeur Android est d’utiliser Modèles d’applications Android pour démarrer vos projets. Vous pouvez trouver des modèles pour Jeux ou d’autres applications, individuelles Éléments de l’interface utilisateur, et beaucoup plus.

Ou si vous voulez quelque chose de complètement personnalisé selon vos spécifications, vous pouvez embaucher un Développeur Android sur Envato Studio pour tout faire, des ajustements et des corrections de bogues à la création d’une application complète à partir de zéro.