[JAVA] Super rugueux! Comment installer Dagger2

À propos de DI

Je pense qu'il y a plusieurs articles, donc je vais l'omettre! En gros, une méthode d'injection d'instances de l'extérieur de la classe pour réduire le degré de couplage! Si vous préparez une interface et l'injectez dedans, elle sera plus facile à tester.

Masakari est le bienvenu! !! !! S'il vous plaît laissez-moi savoir si quelque chose ne va pas ou s'il manque ...!

Où ça se coince

Je voudrais présenter les points sur lesquels je suis resté bloqué lors de son introduction sur Android en premier.

Ce qui est coincé

Il n'y avait pas assez de moyen de spécifier la dépendance dans Gradle et je spécifiais la dépendance qui n'est pas nécessaire à ce stade.

Comment as-tu fait une erreur

Dagger2 Official #How do I get it? J'ai écrit uniquement les dépendances écrites ici, pas les dépendances Java.

Méthode d'introduction

Il était plus rapide de regarder Github Read Me que celui officiel. ..

Ajoutez le code suivant pour graduer sous l'application et synchroniser.

dependencies {
    ...
    compile 'com.google.dagger:dagger:2.14.1'
    annotationProcessor 'com.google.dagger:dagger-compiler:2.14.1'
}

Vous pouvez maintenant injecter l'instance en externe. Cela suffit lorsque vous souhaitez séparer les connaissances externes (WebAPI, etc.) et la couche infrastructure (référentiel). Je n'ai pas cherché à savoir quand dagger.android peut être utilisé, alors faites-moi savoir si vous aimez m (_ _) m

En gros comment injecter

Créez simplement un module, définissez ce que vous voulez injecter dans le composant et spécifiez @ Inject. Prend en charge l'injection de champ et de constructeur.

Vous pouvez considérer Module comme un soi-disant conteneur DI (devrait). L'idée est de couper la génération d'instances séparément et de les gérer en un seul endroit.

Commencez par créer un module.

//C'est une bonne idée d'ajouter Module au suffixe.
@Module
public class InfrastructureModule {
    //C'est une bonne idée d'ajouter fournir au préfixe.
    @singleton
    @provide
    public RepositoryInterafce provideXYZRepository() {
        return new XYZRepository();
    }
}

Je l'écris comme ça. Si vous spécifiez @ Singleton, Dagger gérera la génération comme un singleton.

Ensuite, créez un composant.

Le composant est une interface qui définit où injecter tout module que vous créez. Écrivez comme ça.

//C'est une bonne idée d'ajouter un composant au suffixe.
//Parce qu'il gère les instances singleton@Spécifiez Singleton. Sinon, la compilation lèvera une erreur.
@Singleton
@Component(Modules = {InfrastructureModule.class})
public class InfrastructureComponent {
    //Le nom de la méthode doit être inject. C'est plein de manières, mais si vous vous y habituez, vous pouvez jouer les muscles du cerveau! w
    void inject(FugaHoge fugaHoge);
    void inject(FooBar fooBar);
}

Après cela, ajoutez @ Inject et injectez-le en tant que champ ou constructeur.

public class FugaHoge {
  
   //Essayez l'injection sur le terrain
   @Inject RepositoryInterface repository;

   public FugaHoge() {
        //Si vous exécutez Rebuild, préfixez:L'entité composant de Dagger est générée automatiquement.
        //Injectez dans le constructeur.
        DaggerInfrastructureComponent.create().inject(this);
   }
}

Cela injectera l'instance dans repository.

fin.