Android常用開源工具（1）-Dagger2入門
介紹
Dagger 2是一種依賴注入的框架，能夠在編譯時自動生成出一些程式碼，這些程式碼可以幫助對應的例項初始化。
舉個具體的例子，一個容器裡面裝的是蘋果，不用Dagger2的情況下我們應該這麼寫：
public class Container{
Fruit f=new Apple(color,size);
...
}上面例子面臨著一個問題，Container依賴了Apple實現，如果某一天需要修改Apple為Banana，那麼你一定得改Container的程式碼。有沒有一種方法可以不改Container呢？
可以使用Dagger2，我們可以把程式碼改成
public 這樣，Container的成員變數就自動初始化成Apple例項了，Container不用關心具體用哪個Fruit的實現，也不用關心到底用什麼顏色多大的蘋果。假如某一天要把蘋果替換成香蕉，Container的程式碼是完全不需要改動的。從某種意義上說，Dagger2就是一個幫你寫工廠程式碼的工具。當然Dagger2的功能比工廠模式更加強大。
結構
Dagger2要實現一個完整的依賴注入，必不可少的元素有三種，Module，Component,Container。
- Container就是可以被注入的容器，具體對應上文例子中的Container，Container擁有需要被初始化的元素。需要被初始化的元素必須標上@Inject，只有被標上@Inject的元素才會被自動初始化。@Inject在Dagger2中一般標記構造方法與成員變數。
- Module 可以說就是依賴的原材料的製造工廠，所有需要被注入的元素的實現都是從Module生產的。
- 有了可以被注入的容器Container，也有了提供依賴物件的Module。我們必須將依賴物件注入到容器中，這個過程由Component來執行。Component將Module中產生的依賴物件自動注入到Container中。
簡單的例子
配置
project的build.gradle新增
dependencies {
... // 其他classpath
classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8' module的build.gradle新增
// 新增其他外掛
apply plugin: 'com.neenbedankt.android-apt'//新增apt命令
dependencies {
apt 'com.google.dagger:dagger-compiler:2.0.2' //指定註解處理器
compile 'com.google.dagger:dagger:2.0.2' //dagger公用api
provided 'org.glassfish:javax.annotation:10.0-b28' //新增android缺失的部分javax註解
}實現
實現Module
Module其實就是一個依賴的製造工廠。我們只需要為其新增製造依賴的方法即可，繼續上文實現蘋果容器的例子。
@Module //1 註明本類屬於Module
public class FruitModule{
@Provides //2 註明該方法是用來提供依賴物件的特殊方法
public Fruit provideFruit(){
return new Apple(Color.RED,Size.BIG);
}
}(1)中添加註解@Module註明本類屬於Module
(2)中添加註解@Provides註明該方法是用來提供依賴物件的特殊方法
一個完整的Module必須擁有@Module與@Provides註解
實現Component
Component就是一個將Module生成的例項注入Container中的注入器。我們來寫一個水果注入器：
@Component(modules={FruitModule.class}) //3 指明Component在哪些Module中查詢依賴
public interface FruitComponent{ //4 介面，自動生成實現
void inject(Container container); //5 注入方法，在Container中呼叫
}(3)中@Component使用modules指向使用的Module的集合。
(4)所有的Component都必須以介面形式定義。Dagger2框架將自動生成Component的實現類，對應的類名是Dagger×××××，這個例子中對應的實現類是DaggerFruitComponent
(5)中添加註入方法,一般使用inject做為方法名，方法引數為對應的Container
實現Container
Container就是可以被注入依賴關係的容器。具體實現如下
public Container{
@Inject //6 新增@Inject，標記f可以被注入
Fruit f;
public void init(){
DaggerFruitComponent.create().inject(this); //7 使用FruitComponent的實現類注入
}
}Container除了程式碼中（6）標記f需要被注入外，還需要程式碼中（7）呼叫Component的實現類將Module的生成的物件注入到f中。
到此，當呼叫Container的init()方法時，Contianer中的f將會自動初始化成實現類Apple的物件。
以後如果想更改Fruit的實現類，只需要在@Component中的modules指向不同的Module即可。而Container的程式碼完全不需要改動。因為Container已經不再依賴Apple實現了。
拓展
儘管Dagger2看起來很容易，但其實裡面各種細節很值得注意。
為@Provides方法新增輸入引數
Module中@Provides方法可以帶輸入引數，其引數由Module集合中的其他@Provides方法提供，或者自動呼叫構造方法
下面是其他@Provides方法提供的例子
@Module
public class FruitModule{
//8輸入引數自動使用到provideFruit()的返回值Color.RED
@Provides
public Fruit provideFruit(Color color){
return new Apple(color,Size.BIG);
}
@Provides
pulic Color provideFruit(){
return Color.RED;
}
}如果找不到@Provides方法提供對應引數的物件，自動呼叫帶@Inject引數的構造方法生成相應物件
@Module
public class FruitModule{
@Provides
public Fruit provideFruit(FruitInfo info){//自動查詢到FruitInfo中帶@Inject的無參構造器並生成例項傳入引數info
return new Apple(info);
}
}
public class FruitInfo{
Color mColor;
Size mSize;
@Inject
FruitInfo(){
mColor=Color.RED;
mSize=Size.BIG;
}
}新增多個Module
一個Component可以包含多個Module，這樣Component獲取依賴時候會自動從多個Module中查詢獲取，Module間不能有重複方法。新增多個Module有兩種方法，一種是在Component的註解@Component(modules={××××，×××}) 新增多個modules，如下
@Component(modules={ModuleA.class,ModuleB.class,ModuleC.class}) //新增多個Module
public interface FruitComponent{
...
}另外一種新增多個Module的方法可以被使用Module中的@Module（includes={××××，×××}）,如下
@Module(includes={ModuleA.class,ModuleB.class,ModuleC.class})
public class FruitModule{
...
}
@Component(modules={FruitModule.class}) //新增多個Module
public interface FruitComponent{
...
}這種使用Module的includes的方法一般用於構建更高層的Module時候使用。
Module例項的建立
上面簡單例子中，當呼叫DaggerFruitComponent.create(）實際上等價於DaggerFruitComponent.builder().build()。可以看出，DaggerFruitComponent使用了構造者模式。在構建的過程中，預設使用Module無參構造器產生例項。如果需要傳入特定的Module例項，可以使用
DaggerFruitComponent.builder()
.moduleA(new ModuleA()) //指定Module例項
.moduleB(new ModuleB())
.build()。如果Module只有有參構造器，則必須顯式傳入Module例項。
區分返回型別相同的@Provides 方法
當有Fruit需要注入時，Dagger2就會在Module中查詢返回型別為Fruit的方法，也就是說，Dagger2是按照Provide方法返回型別查詢對應的依賴。但是，當Container需要依賴兩種不同的Fruit時，你就需要寫兩個@Provides方法，而且這兩個@Provides方法都是返回Fruit型別，靠判別返回值的做法就行不通了。這就需要使用@Named來區分，如下：
//定義Module
@Module
public class FruitModule{
@Named("typeA")
@Provides
public Fruit provideApple(){ //提供Apple給對應的mFruitA
return new Apple();
}
@Named("typeB")
@Provides
public Fruit provdeBanana(){ //提供Banana給對應的mFruitB
return new Banana()
}
}
//定義Component
@Component(modules={FruitModule.class})
interface FruitComponent{ //Dagger根據介面自動生成FruitComponent
void inject(Container container);
}
//定義Container
class Container{
@Named("typeA") //新增標記@Name("typeA")，只獲取對應的@Name("typeA")的元依賴 @Inject
Fruit mFruitA;
@Named("typeB") //新增標記@Name("typeA")，只獲取對應的@Name("typeA")的依賴 @Inject
Fruit mFruitB;
...
public void init(){
DaggerFruitComponent.creaete().inject(this); //使用FruitComponent的實現類注入
}
}這樣，只有相同的@Named的@Inject成員變數與@Provides方法才可以被對應起來。
如果覺得@Named只能用字串區分不滿足需求，你也可以自定義類似@Named的註解，使用元註解@Qualifier可以實現這種註解，比如實現一個用int型別區分的@IntNamed
@Qualifier //必須，表示IntNamed是用來做區分用途
@Documented //規範要求是Documented，當然不寫也問題不大，但是建議寫，做提示作用
@Retention(RetentionPolicy.RUNTIME) //規範要求是Runtime級別
public @interface IntNamed{
int value();
}接下來使用我們定義的@IntNamed來修改上面FruitA，FruitB的例子如下
//定義Module
@Module
class FruitModule{
@IntName(1)
@Provides
public Fruit provideApple(){ //提供Apple給對應的mFruitA
return new Apple();
}
@IntName(2)
@Provides
public Fruit provdeBanana(){ //提供Banana給對應的mFruitB
return new Banana()
}
}
//定義Component
@Component(modules={FruitModule.class})
interface FruitComponent{ //Dagger根據介面自動生成FruitComponent
void inject(Container container);
}
//定義Container
class Container{
@IntName(1) //新增標記@IntName(1)，只獲取對應的@IntName(1)的元依賴
@Inject
Fruit mFruitA;
@IntName(2) //新增標記@IntName(2)，只獲取對應的@IntName(2)的依賴
@Inject
Fruit mFruitB;
...
public void init(){
DaggerFruitComponent.creaete().inject(this); //使用FruitComponent的實現類注入
}
}Component定義方法的規則
1）對應上面蘋果容器的例子，Component的方法輸入引數一般只有一個，對應了需要注入的Container。有輸入引數返回值型別就是void
2）Component的方法可以沒有輸入引數，但是就必須有返回值：
Step1：返回的例項會先從事先定義的Module中查詢，如果找不到跳到Step2
Step2 : 使用該類帶@Inject的構造器來生成返回的例項，並同時也會遞迴注入構造器引數以及帶@Inject的成員變數。比如
//定義ComponentB
@Component(modules={××××××××})//1.假設Module中沒有provideApp()方法,但有provideInfo()
interface ComponentB{
Apple apple(); //2.實現類自動返回由Apple(info)構建的實現類
}
public class Apple{
@Inject
Apple(Info info){//被@Inject標記，使用這個構造器生成例項
...
}
Apple(){ //不會使用這個構造器，沒有被@Inject標記
}
}上述程式碼會生成ComponentB的實現類DaggerComponetB,呼叫其apple()方法會自動使用Apple(info)構造器生成例項返回。
3 ) 假設ComponentA依賴ComponentB，B必須定義帶返回值的方法來提供A缺少的依賴
ComponentA依賴ComponentB的程式碼如下
//定義ComponentB
@Component(modules={××××××××})
interface ComponentB{
...
}
//定義ComponentA
@Component(dependencies={ComponentB.class},modules={××××××××})//使用dependencies
interface ComponentA{
...
}這樣，當使用ComponentA注入Container時，如果找不到對應的依賴，就會到ComponentB中查詢。但是，ComponentB必須顯式把這些A找不到的依賴提供給A。怎麼提供呢，只需要在ComponentB中新增方法即可，如下
@Component(modules={××××××××})
interface ComponentB{
// 假設A中module中找不到apple，banana，oranges，但是B的module有，B必須提供帶返回值的方法如下
Apple apple();
Banana banana();
Oranges oranges();
}Container中的@Inject的規則
1）@Inject可以標記Container中的成員變數，但是這些成員變數要求是包級可見，也就是說@Inject不可以標記private型別的成員變數。
2）當@Inject標記成員變數時，查詢對應依賴按照以下規則
1.該成員變數的依賴會從Module的@Provides方法集合中查詢；
2.如果查詢不到，則查詢成員變數型別是否有@Inject構造方法，並注入構造方法且遞迴注入該型別的成員變數
強大的功能
如果說因為Dagger2能生成工廠程式碼就使用Dagger2，那麼有些牽強。Dagger2除了能產生工廠程式碼，還有其他強大的功能，這些也是使用Dagger2的理由。
Scope，Multibinding，Subcomponent，Provider與Lazy，這些將在下一篇文章介紹。