Dragger2、RxJava和Retrofit的巧妙結合

原文鏈接 : When the Avengers meet Dagger2, RxJava and Retrofit in a clean way

原文作者 : Saúl M

譯文出自 : 開發技術前線 www.devtf.cn

譯者 : zhengxiaopeng

校對者: chaossss

狀態 : 完成

依賴注入與 Dagger 2

弄懂這個框架的工作機制花費了一些時間，所以我將會根據我所學習到的內容用更加清晰的方式寫出來。

Dagger 2是基於依賴注入模式的。

看下下面的代碼片段：

``` Java
    // Thor is awesome. He has a hammer!
    public class Thor extends Avenger {
        private final AvengerWeapon myAmazingHammer;

        public Thor (AvengerWeapon anAmazingHammer) {
            myAmazingHammer = anAmazingHammer;
        }

        public void doAmazingThorWork () {
            myAmazingHammer.hitSomeone();
        }
    }
```

雷神（Thor）需要一個 復仇者武器（AvengerWeapon） 才能正確工作，依賴注入的基本思想是，如果雷神不是通過構造器創建他自己的 復仇者武器 而是在內部自己創建了出來那麼他就不能得到很多的優勢。如果雷神自己創建出雷錘將會增加耦合度。

復仇者武器（AvengerWeapon） 可以是一個接口，根據我們的邏輯可以有不同的實現和注入方式。

在 Android 中，因爲框架已經設計好了，我們並不總是能訪問構造器，Activity 和 Fragment 就是這樣的例子。

這些依賴注入器框架像 http://google.github.io/dagger/、Dagger 、Guice 可以給我們帶來便利。

使用 Dagger 2 我們可以把之前的代碼改寫成這樣：

``` Java
// Thor is awesome. He has a hammer!
    public class Thor extends Avenger {
        @Inject AvengerWeapon myAmazingHammer;

        public void doAmazingThorWork () {
            myAmazingHammer.hitSomeone();
        }
    }
```

我們沒有直接訪問雷神的構造方法，注入器使用了幾個指令去創建了雷神的雷錘

``` Java
    public class ThorHammer extends AvengerWeapon () {

        @Inject public AvengerWeapon() {

            initGodHammer();
        }
    }
```

@Inject 註解用於告訴 Dagger 2 構造器有用於創建雷神的雷錘。

Dagger 2

Dagger 2 由 Google 開發和維護，是 Square 的 Dagger 項目的分支。

首先必須配置註解處理器，android-apt 插件就是負責這個角色，允許使用註解處理器而不將其插入到最後的 .apk 中。處理器還配置由該處理器所產生的源代碼。

`build.gradle` （項目的根目錄中）

``` Gradle
dependencies {
        ...
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.4'
    }
```

`build.gradle` （你的 android module 中）

``` Gradle
apply plugin: 'com.neenbedankt.android-apt'

    dependencies {
        ...
        apt 'com.google.dagger:dagger-compiler:2.0'
    }

```

組件（Components）、模塊（modules）和復仇者

模塊負責提供依賴，組件負責注入它們（依賴）。

這是一個例子：

``` Java
@Module
public class AppModule {
    private final AvengersApplication mAvengersApplication;

    public AppModule(AvengersApplication avengersApplication) {
        this.mAvengersApplication = avengersApplication;
    }

    @Provides @Singleton 
    AvengersApplication provideAvengersAppContext () { 
        return mAvengersApplication; 
    }

    @Provides @Singleton 
    Repository provideDataRepository (RestRepository restRepository) { 
        return restRepository; 
    }
}
```

這個就是主模塊，我們感興趣的是它的依賴存在於程序的生命週期中，一個通用的上下文和一個取回信息的倉庫。

很簡單，對吧？

我們在 Dagger 2 中所說的 @Provides 註解，如果有需要則必須會創建其依賴。因此如果我們沒有給一個特別的依賴指定一個提供者（provider），Dagger 2 將會去尋找有 @Inject 註解的構造方法。

組件使用模塊去完成依賴注入，看看這個模塊的組件：

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

    AvengersApplication app();
    Repository dataRepository();
}
```

這個模塊並不由任何的 activity 或者 fragment 去調用，而是通過更復雜的模塊，以提供這些需要得到的依賴

``` Java
AvengersApplication app();
Repository dataRepository();
```

組件必須暴露它們的依賴給圖（該模塊提供的依賴關係），也即是這個模塊提供的依賴關係必須對其它組件是可見的，其它的組件有把當前這個組件作爲依賴，如果這些依賴關係是不可見的，Dagger 2 將不會注入這些要求的依賴。

下面是我們的依賴關係樹：

``` Java
@Module
public class AvengersModule {

    @Provides @Activity
    List<Character> provideAvengers() {

        List<Character> avengers = new ArrayList<>(6);

        avengers.add(new Character(
            "Iron Man", R.drawable.thumb_iron_man, 1009368));

        avengers.add(new Character(
            "Thor", R.drawable.thumb_thor, 1009664));

        avengers.add(new Character(
            "Captain America", R.drawable.thumb_cap,1009220));

        avengers.add(new Character(
            "Black Widow", R.drawable.thumb_nat, 1009189));

        avengers.add(new Character(
            "Hawkeye", R.drawable.thumb_hawkeye, 1009338));

        avengers.add(new Character(
            "Hulk", R.drawable.thumb_hulk, 1009351));

        return avengers;
    }
}
```

這個模塊將會用於一個特別的 activity 的依賴注入，實際上就是負責繪畫的復仇者名單：

``` Java
@Activity 
@Component(
    dependencies = AppComponent.class, 
    modules = {
        AvengersModule.class, 
        ActivityModule.class
    }
)
public interface AvengersComponent extends ActivityComponent {

    void inject (AvengersListActivity activity);
    List<Character> avengers();
}
```

再次，我們暴露出我們的依賴：List<Character> 給其它的組件，在這種情況下出現了一個新方法：void inject (AvengersListActivity activity) 。在此方法被調用時，這些依賴關係將可被消耗，將會被注入給 AvengerListActivity 。

結合所有

我們的類 AvengersApplication，將負責提供應用到其他組件的組件，注意，僅僅提供組件而不會用於注入依賴。

再次提醒的是 Dagger 2 是在編譯時生成必要的元素，如果你沒有構建項目你是找不到 DaggerAppComponent 類的。

Dagger 2 從你的組件中生成的類的格式：Dagger$${YourComponent}. 。

`AvengersApplication.java`
``` Java
public class AvengersApplication extends Application {

    private AppComponent mAppComponent;

    @Override
    public void onCreate() {

        super.onCreate();
        initializeInjector();
    }

    private void initializeInjector() {

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

    public AppComponent getAppComponent() {

        return mAppComponent;
    }
}
```

`AvengersListActivity.java`
``` Java
public class AvengersListActivity extends Activity 
    implements AvengersView {

    @InjectView(R.id.activity_avengers_recycler) 
    RecyclerView mAvengersRecycler;

    @InjectView(R.id.activity_avengers_toolbar) 
    Toolbar mAvengersToolbar;

    @Inject 
    AvengersListPresenter mAvengersListPresenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_avengers_list);
        ButterKnife.inject(this);

        initializeToolbar();
        initializeRecyclerView();
        initializeDependencyInjector();
        initializePresenter();
    }

    private void initializeDependencyInjector() {

        AvengersApplication avengersApplication = 
            (AvengersApplication) getApplication();

        DaggerAvengersComponent.builder()
            .avengersModule(new AvengersModule())
            .activityModule(new ActivityModule(this))
        .appComponent(avengersApplication.getAppComponent())
            .build().inject(this);
    }
```

當 initializeDependencyInjector() 中執行到 .inject(this) 中時 Dagger 2 就會開始工作並提供必要的依賴關係，請記住 Dagger 2 在注入時是嚴格執行的，我要說的意思是組件必須是 完全相同 的組件類，此組件類負責調用 inject() 方法。

`AvengersComponent.java`
``` Java
...
public interface AvengersComponent extends ActivityComponent {

    void inject (AvengersListActivity activity);
    List<Character> avengers();
}
```

否則，依賴關係將不會被解決。在如下情況，presenter 與由 Dagger 2 提供的復仇者一起初始化：

``` Java
public class AvengersListPresenter implements Presenter, RecyclerClickListener {

    private final List<Character> mAvengersList;
    private final Context mContext;
    private AvengersView mAvengersView;
    private Intent mIntent;

    @Inject public AvengersListPresenter (List<Character> avengers, Context context) {

        mAvengersList = avengers;
        mContext = context;
    }
```

Dagger 2 將會解決這個 presenter，因爲其有 @Inject 註解。該構造方法的參數由 Dagger 2 解決，因爲它知道怎麼去構建它，這得益於這個模塊中的 @Provides 方法。

總結

像 Dagger 2 這樣，使用好了依賴注入器，其力量是無可爭辯的，想象下根據該框架提供的 API 級別你可以有不同的策略，其可能性是無止境的。

資源

Chiu-Ki Chan - Dagger 2 + Espresso + Mockito
Fernando Cejas - Tasting Dagger 2 on Android
Google Developers - Dagger 2, A new type of dependency injection
Mike Gouline - Dagger 2, Even sharper, less square

Dragger2、RxJava和Retrofit的巧妙結合