當復仇者聯盟遇上Dagger2、RxJava和Retrofit的巧妙結合
來自： http://www.jcodecraeer.com/a/anzhuokaifa/androidkaifa/2015/0601/2963.html
-
原文鏈接 : When the Avengers meet Dagger2, RxJava and Retrofit in a clean way
-
原文作者 : Saúl M
-
譯者 : zhengxiaopeng
最近，許多文章、框架和 android 社區中的討論都出現關于測試和軟件架構方面的內容，就像上次 Droidcon Spain 上所說的，我們專注于做出健壯的程序而不是去開發特性功能。這些現象也意味著 Android 框架和當前 Android 社區的日漸成熟。
如果你是一名 Android 開發者，而到現在你還沒聽過 Dagger 2、RxJava、Retrofit 這些名詞的話你就錯過了一些東西了，這個（文章）系列將會把一些關注點放在怎么用一種 清晰架構 去綜合使用這些框架。
我剛開始的想法是僅僅寫一篇文章的，但是看到這些框架中有大量的內容所以我最終決定寫一個最少 3 篇的系列文章。
一如既往，所有的代碼都放在了 Github，所有的建議、錯誤提交和評論都歡迎，我可能沒那么多時間去回答所有問題，先說聲抱歉 ：）
依賴注入與 Dagger 2
弄懂這個框架的工作機制花費了一些時間，所以我將會根據我所學習到的內容用更加清晰的方式寫出來。
看下下面的代碼片段：
// 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 我們可以把之前的代碼改寫成這樣：
// Thor is awesome. He has a hammer!
public class Thor extends Avenger {
@Inject AvengerWeapon myAmazingHammer;
public void doAmazingThorWork () {
myAmazingHammer.hitSomeone();
}
} 我們沒有直接訪問雷神的構造方法，注入器使用了幾個指令去創建了雷神的雷錘
public class ThorHammer extends AvengerWeapon () {
@Inject public AvengerWeapon() {
initGodHammer();
}
} @Inject 注解用于告訴 Dagger 2 構造器有用于創建雷神的雷錘。
Dagger 2
Dagger 2 由 Google 開發和維護，是 Square 的 Dagger 項目的分支。
首先必須配置注解處理器，android-apt 插件就是負責這個角色，允許使用注解處理器而不將其插入到最后的 .apk 中。處理器還配置由該處理器所產生的源代碼。
build.gradle （項目的根目錄中）
dependencies {
...
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.4'
} build.gradle （你的 android module 中）
apply plugin: 'com.neenbedankt.android-apt'
dependencies {
...
apt 'com.google.dagger:dagger-compiler:2.0'
} 組件（Components）、模塊（modules）和復仇者
模塊負責提供依賴，組件負責注入它們（依賴）。
這是一個例子：
@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 注解的構造方法。
組件使用模塊去完成依賴注入，看看這個模塊的組件：
@Singleton @Component(modules = AppModule.class)
public interface AppComponent {
AvengersApplication app();
Repository dataRepository();
} 這個模塊并不由任何的 activity 或者 fragment 去調用，而是通過更復雜的模塊，以提供這些需要得到的依賴
AvengersApplication app(); Repository dataRepository();
組件必須暴露它們的依賴給圖（該模塊提供的依賴關系），也即是這個模塊提供的依賴關系必須對其它組件是可見的，其它的組件有把當前這個組件作為依賴，如果這些依賴關系是不可見的，Dagger 2 將不會注入這些要求的依賴。
下面是我們的依賴關系樹：
@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 的依賴注入，實際上就是負責繪畫的復仇者名單：
@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
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
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
...
public interface AvengersComponent extends ActivityComponent {
void inject (AvengersListActivity activity);
List<Character> avengers();
} 否則，依賴關系將不會被解決。在如下情況，presenter 與由 Dagger 2 提供的復仇者一起初始化：
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