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 将不會注入這些要求的依賴。

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

Dragger2、RxJava和Retrofit的巧妙結合

``` 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的巧妙結合