Android
Dolch 2

Syntax

• @Modul
• @Component (Abhängigkeiten = {OtherComponent.class}, modules = {ModuleA.class, ModuleB.class})
• DaggerMyComponent.create ()
• DaggerMyComponent.builder (). MyModule (newMyModule ()). Create ()

Bemerkungen

Komponenteneinrichtung für Applikation und Aktivitätsinjektion

Eine grundlegende AppComponent , die von einem einzelnen AppModule , um anwendungsweite Singleton-Objekte bereitzustellen.

@Singleton
@Component(modules = AppModule.class)
public interface AppComponent {

    void inject(App app);

    Context provideContext();

    Gson provideGson();
}

Ein Modul, das zusammen mit AppComponent wird und dessen Einzelobjekte bereitstellt, z. B. eine Gson Instanz, die in der gesamten Anwendung wiederverwendet werden kann.

@Module
public class AppModule {

    private final Application mApplication;

    public AppModule(Application application) {
        mApplication = application;
    }

    @Singleton
    @Provides
    Gson provideGson() {
        return new Gson();
    }

    @Singleton
    @Provides
    Context provideContext() {
        return mApplication;
    }
}

Eine untergeordnete Anwendung zum Einrichten von Dolch und der Einzelkomponente.

public class App extends Application {

    @Inject
    AppComponent mAppComponent;

    @Override
    public void onCreate() {
        super.onCreate();

        DaggerAppComponent.builder().appModule(new AppModule(this)).build().inject(this);
    }

    public AppComponent getAppComponent() {
        return mAppComponent;
    }
}

Jetzt eine Komponente mit Aktivitätsbereich, die von der AppComponent abhängig ist, um Zugriff auf die Einzelobjekte zu erhalten.

@ActivityScope
@Component(dependencies = AppComponent.class, modules = ActivityModule.class)
public interface MainActivityComponent {

    void inject(MainActivity activity);
}

Und ein wiederverwendbares ActivityModule , das grundlegende Abhängigkeiten wie einen FragmentManager bereitstellt

@Module
public class ActivityModule {

    private final AppCompatActivity mActivity;

    public ActivityModule(AppCompatActivity activity) {
        mActivity = activity;
    }

    @ActivityScope
    public AppCompatActivity provideActivity() {
        return mActivity;
    }


    @ActivityScope
    public FragmentManager provideFragmentManager(AppCompatActivity activity) {
        return activity.getSupportFragmentManager();
    }
}

Wenn wir alles zusammenstellen, sind wir aufgestellt und können unsere Aktivitäten Gson lassen.

public class MainActivity extends AppCompatActivity {

    @Inject
    Gson mGson;

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

        DaggerMainActivityComponent.builder()
                .appComponent(((App)getApplication()).getAppComponent())
                .activityModule(new ActivityModule(this))
                .build().inject(this);
    }
}

Benutzerdefinierte Bereiche

@Scope
@Documented
@Retention(RUNTIME)
public @interface ActivityScope {
}

Bereiche sind lediglich Anmerkungen und Sie können bei Bedarf eigene erstellen.

Konstruktorinjektion

Klassen ohne Abhängigkeiten können einfach mit dem Dolch erstellt werden.

public class Engine {

    @Inject // <-- Annotate your constructor.
    public Engine() {
    }
}

Diese Klasse kann von jeder Komponente bereitgestellt werden. Es hat selbst keine Abhängigkeiten und ist nicht im Geltungsbereich . Es ist kein weiterer Code notwendig.

Abhängigkeiten werden im Konstruktor als Parameter deklariert. Dagger ruft den Konstruktor auf und liefert die Abhängigkeiten, sofern diese Abhängigkeiten bereitgestellt werden können.

public class Car {

    private Engine engine;

    @Inject
    public Car(Engine engine) {
        this.engine = engine;
    }
}

Diese Klasse kann von jeder Komponente bereitgestellt werden, wenn diese Komponente auch alle ihre Abhängigkeiten bereitstellen kann. Engine in diesem Fall. Da der Engine auch Konstruktor eingespritzt werden kann, kann jede Komponente ein Car bereitstellen.

Sie können die Konstruktorinjektion immer dann verwenden, wenn alle Abhängigkeiten von der Komponente bereitgestellt werden können. Eine Komponente kann eine Abhängigkeit bereitstellen, wenn

• Es kann es mit Konstruktorinjektion erstellen
• ein Modul der Komponente kann es bereitstellen
• es kann von der übergeordneten Komponente bereitgestellt werden (wenn es sich um eine @Subcomponent )
• Es kann ein Objekt verwenden, das von einer Komponente verfügbar gemacht wird, von der es abhängig ist (Abhängigkeit von Komponenten).

Verwendung von @Subcomponent anstelle von @Component (Abhängigkeiten = {...})

@Singleton
@Component(modules = AppModule.class)
public interface AppComponent {
    void inject(App app);

    Context provideContext();
    Gson provideGson();

    MainActivityComponent mainActivityComponent(ActivityModule activityModule);
}

@ActivityScope
@Subcomponent(modules = ActivityModule.class)
public interface MainActivityComponent {
    void inject(MainActivity activity);
}

public class MainActivity extends AppCompatActivity {

    @Inject
    Gson mGson;

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

        ((App)getApplication()).getAppComponent()
                .mainActivityComponent(new ActivityModule(this)).inject(this);
    }
}

So fügen Sie Dagger 2 in build.gradle hinzu

Seit der Veröffentlichung von Gradle 2.2 wird das Plug-in für Android-apt nicht mehr verwendet. Die folgende Methode zum Einrichten von Dolch 2 sollte verwendet werden. Verwenden Sie für ältere Versionen von Gradle die zuvor gezeigte Methode.

Für Gradle> = 2.2

dependencies {
    // apt command comes from the android-apt plugin
    annotationProcessor 'com.google.dagger:dagger-compiler:2.8'
    compile 'com.google.dagger:dagger:2.8'
    provided 'javax.annotation:jsr250-api:1.0'
}

Für Gradle <2.2

Um Dagger 2 verwenden zu können, müssen Sie das android-apt Plugin hinzufügen. Fügen Sie dies dem root build.gradle hinzu:

buildscript {
    dependencies {
        classpath 'com.android.tools.build:gradle:2.1.0'
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
    }
}

Das build.gradle des Anwendungsmoduls sollte dann Folgendes enthalten:

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

android {
    …
}

final DAGGER_VERSION = '2.0.2'
dependencies {
    …

    compile "com.google.dagger:dagger:${DAGGER_VERSION}"
    apt "com.google.dagger:dagger-compiler:${DAGGER_VERSION}"
}

Referenz: https://github.com/codepath/android_guides/wiki/Dependency-Injection-with-Dagger-2

Eine Komponente aus mehreren Modulen erstellen

Dolch 2 unterstützt das Erstellen einer Komponente aus mehreren Modulen. Sie können Ihre Komponente auf diese Weise erstellen:

@Singleton
@Component(modules = {GeneralPurposeModule.class, SpecificModule.class})
public interface MyMultipleModuleComponent {
    void inject(MyFragment myFragment);
    void inject(MyService myService);
    void inject(MyController myController);
    void inject(MyActivity myActivity);
}

Die zwei Referenzmodule GeneralPurposeModule und SpecificModule können dann wie folgt implementiert werden:

GeneralPurposeModule.java

@Module
public class GeneralPurposeModule {
    @Provides
    @Singleton
    public Retrofit getRetrofit(PropertiesReader propertiesReader, RetrofitHeaderInterceptor headerInterceptor){
        // Logic here...
        return retrofit;
    }

    @Provides
    @Singleton
    public PropertiesReader getPropertiesReader(){
        return new PropertiesReader();
    }

    @Provides
    @Singleton
    public RetrofitHeaderInterceptor getRetrofitHeaderInterceptor(){
         return new RetrofitHeaderInterceptor();
    }
}

SpecificModule.java

@Singleton
@Module
public class SpecificModule {
    @Provides @Singleton
    public RetrofitController getRetrofitController(Retrofit retrofit){
        RetrofitController retrofitController = new RetrofitController();
        retrofitController.setRetrofit(retrofit);
        return retrofitController;
    }

    @Provides @Singleton
    public MyService getMyService(RetrofitController retrofitController){
        MyService myService = new MyService();
        myService.setRetrofitController(retrofitController);
        return myService;
    }
}

Während der Abhängigkeitseingriffsphase entnimmt die Komponente den beiden Objekten Objekte entsprechend den Anforderungen.

Dieser Ansatz ist im Hinblick auf die Modularität sehr nützlich. In dem Beispiel gibt es ein Universalmodul, das zum Instanziieren von Komponenten verwendet wird, wie z. B. das Retrofit Objekt (zur Verarbeitung der Netzwerkkommunikation) und ein PropertiesReader (für die Verarbeitung von Konfigurationsdateien). Es gibt auch ein spezielles Modul, das die Instantiierung bestimmter Controller und Serviceklassen in Bezug auf diese bestimmte Anwendungskomponente abwickelt.