Android常用開源工具(1)-Dagger2入門
介紹
Dagger 2是一種依賴注入的框架,能夠在編譯時自動生成出一些程式碼,這些程式碼可以幫助對應的例項初始化。
舉個具體的例子,一個容器裡面裝的是蘋果,不用Dagger2的情況下我們應該這麼寫:
public class Container{
Fruit f=new Apple(color,size);
...
}
上面例子面臨著一個問題,Container依賴了Apple實現,如果某一天需要修改Apple為Banana,那麼你一定得改Container的程式碼。有沒有一種方法可以不改Container呢?
可以使用Dagger2,我們可以把程式碼改成
public class Container{
@Inject
Fruit f;
...
}
這樣,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' //新增apt命令
}
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,這些將在下一篇文章介紹。