Android
Sztylet 2

Składnia

• @Moduł
• @Component (zależności = {OtherComponent.class}, moduły = {ModuleA.class, ModuleB.class})
• DaggerMyComponent.create ()
• DaggerMyComponent.builder (). MyModule (newMyModule ()). Create ()

Uwagi

Konfiguracja składników dla aplikacji i wstrzykiwania aktywności

Podstawowy AppComponent który zależy od pojedynczego AppModule celu zapewnienia obiektów singletonowych dla całej aplikacji.

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

    void inject(App app);

    Context provideContext();

    Gson provideGson();
}

Moduł do użycia wraz z AppComponent który zapewni swoje obiekty singletonowe, np. Instancję Gson do ponownego wykorzystania w całej aplikacji.

@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;
    }
}

Podklasowa aplikacja do ustawiania sztyletu i komponentu singleton.

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;
    }
}

Teraz komponent o AppComponent działania, który zależy od AppComponent aby uzyskać dostęp do obiektów singletonów.

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

    void inject(MainActivity activity);
}

Oraz moduł ActivityModule wielokrotnego użytku, który zapewni podstawowe zależności, takie jak FragmentManager

@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();
    }
}

Łącząc wszystko razem, jesteśmy skonfigurowani i możemy wstrzyknąć naszą aktywność i upewnij się, że używasz tego samego Gson całej aplikacji!

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);
    }
}

Niestandardowe zakresy

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

Zakresy są tylko adnotacjami i w razie potrzeby możesz tworzyć własne.

Wtrysk Konstruktora

Klasy bez zależności można łatwo tworzyć za pomocą sztyletu.

public class Engine {

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

Tę klasę może zapewnić dowolny komponent. Nie ma żadnych zależności i nie ma zasięgu . Nie jest wymagany żaden dodatkowy kod.

Zależności są deklarowane jako parametry w konstruktorze. Sztylet wywoła konstruktora i dostarczy zależności, o ile można je zapewnić.

public class Car {

    private Engine engine;

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

Tę klasę może zapewnić każdy komponent, jeśli ten komponent może również zapewnić wszystkie swoje zależności - w tym przypadku Engine . Ponieważ Engine może być również wtryskiwany przez konstruktora, każdy element może zapewnić Car .

Możesz użyć iniekcji konstruktora, ilekroć wszystkie zależności mogą być dostarczone przez komponent. Składnik może zapewnić zależność, jeśli

• można go utworzyć za pomocą wstrzyknięcia konstruktora
• moduł tego elementu może to zapewnić
• może być dostarczone przez komponent nadrzędny (jeśli jest to @Subcomponent )
• może użyć obiektu odsłoniętego przez komponent, od którego jest zależny (zależności komponentu)

Używanie @Subcomponent zamiast @Component (zależności = {...})

@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);
    }
}

Jak dodać Dagger 2 w build.gradle

Od wydania Gradle 2.2 korzystanie z wtyczki android-apt nie jest już używane. Należy zastosować następującą metodę konfiguracji sztyletu 2. W przypadku starszej wersji Gradle użyj poprzedniej metody pokazanej poniżej.

Dla 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'
}

Dla Gradle <2.2

Aby użyć Dagger 2, musisz dodać wtyczkę android-apt , dodaj to do root build.gradle:

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

Następnie build.gradle modułu aplikacji powinien zawierać:

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}"
}

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

Tworzenie komponentu z wielu modułów

Dagger 2 obsługuje tworzenie komponentu z wielu modułów. Możesz utworzyć swój komponent w ten sposób:

@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);
}

Dwa moduły referencyjne GeneralPurposeModule i SpecificModule można następnie zaimplementować w następujący sposób:

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;
    }
}

Podczas fazy wstrzykiwania zależności komponent pobierze obiekty z obu modułów zgodnie z potrzebami.

To podejście jest bardzo przydatne pod względem modułowości . W tym przykładzie istnieje moduł ogólnego przeznaczenia używany do tworzenia instancji składników, takich jak obiekt Retrofit (używany do obsługi komunikacji sieciowej) i PropertiesReader (odpowiedzialny za obsługę plików konfiguracyjnych). Istnieje również specjalny moduł, który obsługuje tworzenie określonych kontrolerów i klas usług w odniesieniu do tego konkretnego komponentu aplikacji.