Android
대거 2

통사론

• @기준 치수
• @Component (종속성 = {OtherComponent.class}, 모듈 = {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();
}

싱글 톤 객체를 제공하는 AppComponent 와 함께 사용할 모듈입니다 (예 : 전체 응용 프로그램에서 다시 사용할 Gson 인스턴스).

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

이제 Singleton 객체에 액세스하기 위해 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 을 사용해야합니다!

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 plugin을 추가하고 루트 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 이라는 두 개의 참조 모듈을 다음과 같이 구현할 수 있습니다.

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 (구성 파일 처리 책임자)와 같은 구성 요소를 인스턴스화하는 데 사용되는 범용 모듈이 있습니다. 또한 특정 응용 프로그램 구성 요소와 관련하여 특정 컨트롤러 및 서비스 클래스의 인스턴스화를 처리하는 특정 모듈이 있습니다.