[Android]在Dagger 2中Activities和Subcomponents的多綁定（翻譯）

以下內容為原創，歡迎轉載，轉載請注明
來自天天博客：http://www.cnblogs.com/tiantianbyconan/p/6266442.html

在Dagger 2中Activities和Subcomponents的多綁定

原文：http://frogermcs.github.io/activities-multibinding-in-dagger-2

幾個月前，在MCE^3會議中，Gregory Kick在他的演講中展示了一個提供Subcomponents（比如，為Activity）的新概念。新的方式給我們帶來了一個創建不使用AppComponent對象引用（以前時Activities Subcomponents的工廠）的方式。為了讓它成為現實，我們不得不等到了新的Dagger release版本：version 2.7。

問題

在Dagger 2.7之前，創建Subcomponent（比如，AppComponent的subcomponent MainActivityComponent）我們必須要在父Component中聲明它的工廠：

@Singleton
@Component(
    modules = {
        AppModule.class
    }
)
public interface AppComponent {
    MainActivityComponent plus(MainActivityComponent.ModuleImpl module);

    //...
}

多虧Dagger理解這個聲明，MainActivityComponent能夠訪問從AppComponent的依賴。

有了這個，MainActivity中的注入看起來如下：

@Override
protected ActivityComponent onCreateComponent() {
    ((MyApplication) getApplication()).getComponent().plus(new MainActivityComponent.ModuleImpl(this));
    component.inject(this);
    return component;
}

這個代碼的問題在於：

• Activity依賴於AppComponent（通過((MyApplication) getApplication()).getComponent())返回 - 我們是否想要去創建Subcomponent，我們需要去訪問父Component的對象）。

• AppComponent必須要去聲明所有Subcomponents（或者它們的builders），比如：MainActivityComponent plus(MainActivityComponent.ModuleImpl module);。

Modules.subcomponents

從Dagger 2.7開始，我們有了一個新的方法來聲明subcomponents的父級。@Module注解有一個可選的subcomponents屬性，它可以得到subcomponents類的列表，它們應該是安裝此module組件的子component。

Example：

@Module(
        subcomponents = {
                MainActivityComponent.class,
                SecondActivityComponent.class
        })
public abstract class ActivityBindingModule {
    //...
}

ActivityBindingModule在AppComponent中被安裝。這表示MainActivityComponent和SecondActivityComponent兩者都是AppComponent的Subcomponents。

Subcomponents的聲明在這種方法中不需要明確地在AppComponent中進行聲明（就像本章開頭的代碼）。

Activities的多綁定

讓我們來看看我們怎么樣使用Modules.subcomponents來構建Activities多綁定並且擺脫AppComponent對象傳入Activity（這在這個演講中也解釋到）。我將只瀏覽代碼中最重要的部分。整個實現已在Github中可用：Dagger2Recipes-ActivitiesMultibinding。

我們的app包含兩個屏幕：MainActivity和SecondActivity。我們想要去給它們兩者提供Subcomponents且並不傳入AppComponent對象。

讓我們從為所有Activity Components builders構建一個基本的接口來開始：

public interface ActivityComponentBuilder<M extends ActivityModule, C extends ActivityComponent> {
    ActivityComponentBuilder<M, C> activityModule(M activityModule);
    C build();
}

Subcomponents：MainActivityComponent的例子看起來如下：

@ActivityScope
@Subcomponent(
        modules = MainActivityComponent.MainActivityModule.class
)
public interface MainActivityComponent extends ActivityComponent<MainActivity> {

    @Subcomponent.Builder
    interface Builder extends ActivityComponentBuilder<MainActivityModule, MainActivityComponent> {
    }

    @Module
    class MainActivityModule extends ActivityModule<MainActivity> {
        MainActivityModule(MainActivity activity) {
            super(activity);
        }
    }
}

現在我們可以使用Subcomponents builders的Map來得到每一個Activity類的意圖builder。讓我們如下使用Multibinding特性：

@Module(
        subcomponents = {
                MainActivityComponent.class,
                SecondActivityComponent.class
        })
public abstract class ActivityBindingModule {

    @Binds
    @IntoMap
    @ActivityKey(MainActivity.class)
    public abstract ActivityComponentBuilder mainActivityComponentBuilder(MainActivityComponent.Builder impl);

    @Binds
    @IntoMap
    @ActivityKey(SecondActivity.class)
    public abstract ActivityComponentBuilder secondActivityComponentBuilder(SecondActivityComponent.Builder impl);
}

ActivityBindingModule在AppComponent中被安裝。就如它被解釋的那樣，多虧MainActivityComponent和SecondActivityComponent將會是AppComponent的Subcomponent。

現在我們可以注入Subcomponents builder的Map（比如，注入到MyApplication class）：

public class MyApplication extends Application implements HasActivitySubcomponentBuilders {

    @Inject
    Map<Class<? extends Activity>, ActivityComponentBuilder> activityComponentBuilders;

    private AppComponent appComponent;

    public static HasActivitySubcomponentBuilders get(Context context) {
        return ((HasActivitySubcomponentBuilders) context.getApplicationContext());
    }

    @Override
    public void onCreate() {
        super.onCreate();
        appComponent = DaggerAppComponent.create();
        appComponent.inject(this);
    }

    @Override
    public ActivityComponentBuilder getActivityComponentBuilder(Class<? extends Activity> activityClass) {
        return activityComponentBuilders.get(activityClass);
    }
}

我們創建了HashActivitySubcomponentBuilders接口作為額外的抽象（因為builders的Map不一定是注入到Appliction類的）：

public interface HasActivitySubcomponentBuilders {
    ActivityComponentBuilder getActivityComponentBuilder(Class<? extends Activity> activityClass);
}

然后最后在Activity class中進行注入的實現：

public class MainActivity extends BaseActivity {

    //...

    @Override
    protected void injectMembers(HasActivitySubcomponentBuilders hasActivitySubcomponentBuilders) {
        ((MainActivityComponent.Builder) hasActivitySubcomponentBuilders.getActivityComponentBuilder(MainActivity.class))
                .activityModule(new MainActivityComponent.MainActivityModule(this))
                .build().injectMembers(this);
    }
}

它非常類似於我們的第一個實現，但如上，最重要的事是我們不再傳入ActivityComponent對象到我們的Activities中。

用例example —— instrumentation tests mocking

除了解耦和解決循環依賴（Activity <-> Application），這不是一個大的問題，尤其是在較小的項目/團隊中，讓我們思考一個這個實現有幫助的真實用例 —— 在instrumentation testing中的mocking依賴。

目前在Android Instrumentation測試中mocking依賴最著名的方式之一是使用DaggerMock（Github 項目地址）。雖然DaggerMock是一個強大的工具，但是非常難理解它面具之下是怎么工作的。其中有一些反射代碼不容易被追蹤。

在Activity中直接構建Subcomponent，而不需要訪問AppComponent類給了我們一個方式來測試單獨的Activity並從我們app的其它部分解耦。

聽起來很酷，現在我們來看下代碼。

在我們的instrumentation test中使用Applicaton類：

public class ApplicationMock extends MyApplication {

    public void putActivityComponentBuilder(ActivityComponentBuilder builder, Class<? extends Activity> cls) {
        Map<Class<? extends Activity>, ActivityComponentBuilder> activityComponentBuilders = new HashMap<>(this.activityComponentBuilders);
        activityComponentBuilders.put(cls, builder);
        this.activityComponentBuilders = activityComponentBuilders;
    }
}

putActivityComponentBuilder()方法給我們一個對給定Activity類替換ActivityComponentBuilder的實現的方法。

現在來看下我們Espresso Instrumentation Test例子：

@RunWith(AndroidJUnit4.class)
public class MainActivityUITest {

    @Rule
    public MockitoRule mockitoRule = MockitoJUnit.rule();

    @Rule
    public ActivityTestRule<MainActivity> activityRule = new ActivityTestRule<>(MainActivity.class, true, false);

    @Mock
    MainActivityComponent.Builder builder;
    @Mock
    Utils utilsMock;

    private MainActivityComponent mainActivityComponent = new MainActivityComponent() {
        @Override
        public void injectMembers(MainActivity instance) {
            instance.mainActivityPresenter = new MainActivityPresenter(instance, utilsMock);
        }
    };

    @Before
    public void setUp() {
        when(builder.build()).thenReturn(mainActivityComponent);
        when(builder.activityModule(any(MainActivityComponent.MainActivityModule.class))).thenReturn(builder);

        ApplicationMock app = (ApplicationMock) InstrumentationRegistry.getTargetContext().getApplicationContext();
        app.putActivityComponentBuilder(builder, MainActivity.class);
    }

一步一步來：

• 我們提供了MainActivityComponent.Builder的Mock和所有我們必須要mock的依賴（在本例中只是Utils）。我們mockedBuilder返回一個MainActivityComponent的一個自定義實現，它用於注入MainActivityPresenter（其中使用了mocked Utils）。

• 然后我們的MainActivityComponent.Builder替換了在MyApplication（28行）中被注入的原始Builder：app.putActivityComponentBuilder(builder, MainActivity.class);

• 最后測試 —— 我們mockUtil.getHardcodedText()方法。注入過程發生在Activity被創建（36行）：activityRule.launchActivity(new Intent());接着在最后我們使用Espresso來檢驗結果。

以上就是全部。如你所見，幾乎一切都發生在MainActivityUITest類中，而且代碼相當簡單和可讀。

源碼

如果你想自己去測試這個實現，源碼與工作例子展示怎么去創建Activities Multibinding和在Instrumentation Tests中mock依賴見Github：Dagger2Recipes-ActivitiesMultibinding

感謝閱讀！

作者

Miroslaw Stanek

Head of Mobile Development @ Azimo

> __[Android]使用Dagger 2依賴注入 - DI介紹（翻譯）:__

> __[Android]使用Dagger 2依賴注入 - API（翻譯）:__

> __[Android]使用Dagger 2依賴注入 - 自定義Scope（翻譯）:__

> __[Android]使用Dagger 2依賴注入 - 圖表創建的性能（翻譯）:__

> __[Android]Dagger2Metrics - 測量DI圖表初始化的性能（翻譯）:__

> __[Android]使用Dagger 2進行依賴注入 - Producers（翻譯）:__

> __[Android]在Dagger 2中使用RxJava來進行異步注入（翻譯）:__

> __[Android]使用Dagger 2來構建UserScope（翻譯）:__

> __[Android]在Dagger 2中Activities和Subcomponents的多綁定（翻譯）:__