[JAVA] Dagger2 - Injection de dépendance Android

Qu'est-ce que DI

Injection de dipendance (DI), "injection d'objets".

En bref, permettre aux dépendances d'être remplacées librement facilite l'exécution des tests (insert mock) et la gestion de chaque objet individuellement.

Le besoin de DI sur Android

Par exemple, si vous souhaitez stocker des données dans SharedPreferences, son exécution sans DI instanciera, stockera et récupérera les données de SharedPreferences, qui doivent toutes être décrites de manière similaire à une activité.

Si l'application se développe de cette façon, elle peut être irréparable dans le pire des cas.

Ainsi, au lieu d'instancier SharedPreferences dans l'activité à chaque fois, injectez-la depuis une autre classe.

Qu'est-ce que Dagger2?

Une bibliothèque développée par les développeurs Square en 2012.

Dagger1 a été utilisé pour créer une instance de la classe et injecter des dépendances via Reflection. Plus tard, en collaboration avec l'équipe de développement de Google, Dagger 2 a été introduit avec une version beaucoup plus rapide qui n'utilise pas Reflections.

Dagger2 est une infrastructure d'injection dépendante d'Android au moment de la compilation qui utilise Java Specification Request (JSR) 330 et utilise un processeur d'annotation.

Les annotations de base utilisées dans Dagger2 sont les suivantes.

@Module: une classe qui construit des objets qui sont finalement fournis en tant que dépendances @Provides: utilisé dans les méthodes de la classe Module qui renvoient des objets @Inject: indique qu'une dépendance a été demandée (utilisée dans le constructeur / champ / méthode) @Component: classe de pont pour passer des dépendances aux classes demandant le module @Singleton: indique de créer une seule instance dans une dépendance

Sample

main_activity.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="https://schemas.android.com/apk/res/android"
    xmlns:app="https://schemas.android.com/apk/res-auto"
    xmlns:tools="https://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.journaldev.dagger2.MainActivity">

    <EditText
        android:id="@+id/inUsername"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_margin="8dp"
        android:hint="Username" />

    <EditText
        android:id="@+id/inNumber"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_below="@+id/inUsername"
        android:layout_margin="8dp"
        android:inputType="number"
        android:hint="Number" />

    <Button
        android:id="@+id/btnSave"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="SAVE"
        android:layout_below="@+id/inNumber"
        android:layout_toLeftOf="@+id/btnGet"
        android:layout_toStartOf="@+id/btnGet"
        android:layout_marginRight="8dp"
        android:layout_marginEnd="8dp" />

    <Button
        android:id="@+id/btnGet"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="GET"
        android:layout_below="@+id/inNumber"
        android:layout_alignRight="@+id/inNumber"
        android:layout_alignEnd="@+id/inNumber" />

</RelativeLayout>

Définir les dépendances avec Module

SharedPrefModule.java

package com.journaldev.dagger2;

import android.content.Context;
import android.content.SharedPreferences;
import android.preference.PreferenceManager;
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;

@Module
public class SharedPrefModule {
    private Context context;

    public SharedPrefModule(Context context) {
        this.context = context;
    }

    @Singleton
    @Provides
    public Context provideContext() {
        return context;
    }

    @Singleton
    @Provides
    public SharedPreferences provideSharedPreferences(Context context) {
        return PreferenceManager.getDefaultSharedPreferences(context);
    }
}

Définition des objets passés aux classes dépendantes dans Component

MyComponent.java

package com.journaldev.dagger2;

import javax.inject.Singleton;
import dagger.Component;

@Singleton
@Component(modules = {SharedPrefModule.class})
public interface MyComponent {
    void inject(MainActivity activity);
}

Écrivez @inject là où il est nécessaire dans la dépendance (injecté là)

MainActivity.java

package com.journaldev.dagger2;

import android.content.SharedPreferences;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;

import javax.inject.Inject;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {


    EditText inUsername, inNumber;
    Button btnSave, btnGet;
    private MyComponent myComponent;
    @Inject
    SharedPreferences sharedPreferences;

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

        initViews();
        myComponent = DaggerMyComponent.builder().sharedPrefModule(new SharedPrefModule(this)).build();
        myComponent.inject(this);


    }

    private void initViews() {
        btnGet = findViewById(R.id.btnGet);
        btnSave = findViewById(R.id.btnSave);
        inUsername = findViewById(R.id.inUsername);
        inNumber = findViewById(R.id.inNumber);
        btnSave.setOnClickListener(this);
        btnGet.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {

            case R.id.btnGet:
                inUsername.setText(sharedPreferences.getString("username", "default"));
                inNumber.setText(sharedPreferences.getString("number", "12345"));
                break;
            case R.id.btnSave:
                SharedPreferences.Editor editor = sharedPreferences.edit();
                editor.putString("username", inUsername.getText().toString().trim());
                editor.putString("number", inNumber.getText().toString().trim());
                editor.apply();
                break;

        }
    }
}

à la fin

C'est approximatif, mais ce qui précède est l'explication de Dagger2. Je vais le mettre à jour à l'avenir.