Android
ダガー2

構文

• @Module
• @Component（依存関係= {OtherComponent.class}、modules = {ModuleA.class、ModuleB.class}）
• DaggerMyComponent.create（）
• DaggerMyComponent.builder（）。myModule（newMyModule（））。create（）

備考

アプリケーションおよびアクティビティ注入のためのコンポーネント設定

アプリケーション全体のシングルトンオブジェクトを提供する単一のAppModuleに依存する基本的なAppComponent 。

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

    void inject(App app);

    Context provideContext();

    Gson provideGson();
}

アプリケーション全体で再利用するためのGsonインスタンスなど、そのシングルトンオブジェクトを提供するAppComponentと共に使用するモジュール。

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

ダガーとシングルトンコンポーネントをセットアップするためのサブクラス化されたアプリケーション。

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

今、 AppComponentオブジェクトへのアクセスを得るためにAppComponentに依存するアクティビティスコープ付きコンポーネント。

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

    void inject(MainActivity activity);
}

また、 FragmentManagerような基本的な依存関係を提供する再利用可能なActivityModule

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

すべてをまとめると、私たちはGsonていて、私たちの活動を注入することができ、アプリ全体に同じGsonを使用するようにすることができます！

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

カスタムスコープ

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

スコープは単なる注釈であり、必要に応じて独自のものを作成できます。

コンストラクタインジェクション

依存関係のないクラスは、短剣で簡単に作成できます。

public class Engine {

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

このクラスは、 任意のコンポーネントによって提供されます。 依存関係自体はなく、有効範囲もありません 。それ以上のコードは必要ありません。

依存関係は、コンストラクタのパラメータとして宣言されます。 Daggerは、依存関係を提供できる限り、コンストラクタを呼び出して依存関係を提供します。

public class Car {

    private Engine engine;

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

このクラスは、このコンポーネントがすべての依存関係（この場合はEngine提供できる場合 、すべてのコンポーネントによって提供されることができます。 Engineはコンストラクタにも注入できるので、 どのコンポーネントでもCarを提供できます。

すべての依存関係をコンポーネントが提供できるときはいつでも、コンストラクタインジェクションを使用できます。コンポーネントは依存関係を提供できます。

• コンストラクタインジェクションを使用して作成できます
• コンポーネントのモジュールがそれを提供することができます
• 親コンポーネント（ @Subcomponent場合）によって提供することができます。
• 依存するコンポーネントによって公開されるオブジェクトを使用することができます（コンポーネントの依存関係）

@Componentの代わりに@Subcomponentを使用する（依存関係= {...}）

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

build.gradleでDagger 2を追加する方法

Gradle 2.2がリリースされて以来、android-aptプラグインの使用は廃止されました。 Dagger 2を設定するには、以下の方法を使用する必要があります。古いバージョンのGradleの場合は、以下の前の方法を使用します。

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

Gradle <2.2の場合

Dagger 2を使用するには、 android-aptプラグインを追加する必要があります。これをルートbuild.gradleに追加してください：

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

次に、アプリケーション・モジュールのbuild.gradleには以下が含まれている必要があります。

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

リファレンス： https : //github.com/codepath/android_guides/wiki/Dependency-Injection-with-Dagger-2

複数のモジュールからコンポーネントを作成する

Dagger 2では、複数のモジュールからコンポーネントを作成することができます。このようにコンポーネントを作成することができます。

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

GeneralPurposeModuleとSpecificModuleという2つの参照モジュールは、次のように実装できます。

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

依存性注入フェーズでは、コンポーネントは必要に応じて両方のモジュールからオブジェクトを取得します。

このアプローチは、 モジュール性の点で非常に有用です。この例では、 Retrofitオブジェクト（ネットワーク通信の処理に使用）やPropertiesReader （構成ファイルの処理）などのコンポーネントをインスタンス化する汎用モジュールがあります。その特定のアプリケーションコンポーネントに関連して、特定のコントローラとサービスクラスのインスタンス化を処理する特定のモジュールもあります。