Je commence à utiliser la Dague 2 dans une application que je suis en développement, mais j'ai quelques questions sur la façon dont la Dague 2 fonctionne.
Je reçois le tout la logique derrière le @Fournit des méthodes et de l'annotation @Inject pour initialisation de vos dépendances, mais l'annotation @Inject pour les constructeurs de classe genre de bugs de mon esprit.
Par exemple:
Im mon application, j'ai un module défini, le ContextModule, pour récupérer le contexte de ma demande:
ContextModule.java
@Module
public class ContextModule {
private final Context context;
public ContextModule(Context context) {
this.context = context;
}
@Provides
public Context context() {
return this.context;
}
}
Ce module est utilisé par mon BaseActivityComponent:
BaseActivityComponent.java
@BaseActivityScope
@Component(modules = ContextModule.class)
public interface BaseActivityComponent {
void injectBaseActivity(BaseActivity baseActivity);
}
Jusqu'ici tout va bien.. alors j'ai une action authcontroller classe, qui dépend du contexte et des je veux de l'injecter dans mon BaseActivity. Donc, dans mon AuthControllers.class j'ai quelque chose comme:
public class AuthController {
private Context context;
@Inject
public AuthController(Context context) {
this.context = context;
}
public void auth() {
// DO STUFF WITH CONTEXT
}
}
Et je l'injecter dans mon BaseActivity comme:
public class BaseActivity extends AppCompatActivity {
@Inject
AuthController authController;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
BaseActivityComponent component = DaggerBaseActivityComponent.builder()
.contextModule(new ContextModule(this))
.build();
component.injectBaseActivity(this);
authController.auth();
}
}
Maintenant, ma question est, comment poignard sait que mon AuthControllers est une dépendance de BaseActivity? Juste en déclarant
@Inject
AuthController authController;
c'est que la même chose que si j'ai créé un ControllerModule comme:
@Module(includes = ContextModule.class)
public class ControllerModule {
@Provides
AuthController authController(Context context) {
return new AuthController(context);
}
}
Et puis, dans ma BaseActivityComponent je voudrais ajouter mon action authcontroller de lecture et de changer ma dépendance module de ControllersModule:
@BaseActivityScope
@Component(modules = ControllersModule.class)
public interface BaseActivityComponent {
void injectBaseActivity(BaseActivity baseActivity);
AuthController getAuthController();
}
Quand je l'appelle injectBaseActivity(ce), il "raconte" la dague que tous @Inject annotations sont des dépendances de ma classe, et puis il les chercheurs pour mon projet @Inject annoté constructeurs qui correspond à ce type?
J'ai pensé qu'une bonne chose à propos de Poignard 2 est que le Module de fichiers pourrait être utilisé comme une "documentation" de mes dépendances trois. Mais si seulement ajouter @Inject dans tous les constructeurs que j'ai le contrôle, ne pourrait-il pas avoir un peu de confusion à l'avenir, car vous ne savez pas ce qui dépend en réalité de quoi? (Je veux dire, vous savez de quoi dépend ce que l', il vous suffit de parcourir un grand nombre de fichiers pour vraiment savoir)
Est-il de meilleures pratiques lors de l'utilisation de @Inject annotations dans les constructeurs ou quand ajouter de l' @Fournit la méthode dans les fichiers de Modules? Je reçois à l'aide de @Inject dans le constructeur je n'ai pas besoin de modifier le constructeur de la définition dans mon fichier de Module, mais est-il un inconvénient?
Merci.
