(Dagger--A fast dependency injector for Android and Java 實例講解)
IDE: AndroidStudio 4.2
Dagger 是一種android平臺的依賴注入框架,是有一家專注於移動支付的公司,Square公司推出的庫,這家公司也推出了
其他在Android開發中常用庫:otto,okhttp,retrofit等等,這些在接下的博文中會一一介紹。
對Dagge的介紹,除了官方文檔的介紹外,接下來的這些分析,本人覺得是比較不錯的,也許在不熟悉Dagger的情況下看這
寫內容,你會覺得無厘頭,不知道講什麼。根據本人經驗,建議先了解Dagger的使用再來看這個會對了解Dagger有比較好的效果。
如果你不喜歡看英文官方文檔介紹,請參考:http://fanxu.me/post/2013-07-18
Dagger的簡介,請閱讀:http://www.infoq.com/cn/news/2012/10/dagger
接下來就進入正題,進行實例講解,與官方例子一樣,我這裏也用煮咖啡的例子來說明,只不過官方的例子是用在Java上,這裏
的例子使用Android開發來進行,並且對其也進行了改進。
首先我先說明一下這個過程,既然是煮咖啡,就要由一個加熱器(Heater),加熱之後要有一個倒(Pump)的過程,倒好之後才能供給人
們喝(Drink)。就這麼一個簡單的邏輯,你也許會和我開始一樣,覺得這有什麼難的,很少的代碼就能搞定。是的,我們就要用這麼一
個簡單的事件,來看看用Dagger是怎麼實現的。
首先,我們來設計Heater、Pump、Drink這三個接口,如下:
package com.example.app.dagger;
/**
* Created by zjb on 14-1-22.
*/
interface Heater {
void on(); //加熱器打開
void off();//加熱器關閉
boolean isHot();//加熱是否完畢
}
package com.example.app.dagger;
/**
* Created by zjb on 14-1-22.
*/
interface Pump {
void pump(); //倒咖啡
boolean isPumped();//是否倒好
}
package com.example.app.dagger;
/**
* Created by zjb on 14-1-22.
*/
interface Drink {
void drink(); //喝咖啡
}
Ok,接口已經設計完畢,是否合理暫且不細究,接下來我們分別實現這三個接口(有用到AndroidAnnotations框架(請看上篇博文)):
package com.example.app.dagger;
import android.content.Context;
import android.widget.Toast;
import org.androidannotations.annotations.EBean;
import org.androidannotations.annotations.RootContext;
import org.androidannotations.annotations.UiThread;
/**
* Created by zjb on 14-1-22.
*/
@EBean
class ElectricHeater implements Heater {
boolean heating = false;
@RootContext
Context context;
@Override
public void on() {
heating = true;
System.out.println("-----Heating-----");
reportHeating();
}
@UiThread
void reportHeating(){
Toast.makeText(context,"Electric heater heating.....",Toast.LENGTH_LONG).show();
}
@Override
public void off() {
heating = false;
}
@Override
public boolean isHot() {
return heating;
}
}
ElectricHeater是對Heater接口的實現類,@EBean,@RootContext,@UiThread是AndroidAnnotations框架中的註解。
使用@EBean註解會在編譯過程中產生一個ElectricHeater子類ElectricHeater_.class, 接下來會用到。
Pump接口實現:
package com.example.app.dagger;
import javax.inject.Inject;
/**
* Created by zjb on 14-1-22.
*/
class Thermosiphon implements Pump {
private final Heater heater;
boolean pumped = false;
@Inject
Thermosiphon(Heater heater) {
this.heater = heater;
}
@Override
public void pump() {
if (heater.isHot()) {
System.out.println("-----Pumping-----");
pumped = true;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Override
public boolean isPumped() {
return pumped;
}
}
package com.example.app.dagger;
import javax.inject.Inject;
/**
* Created by zjb on 14-1-22.
*/
class PeopleDrink implements Drink {
private Pump pump;
@Inject
PeopleDrink(Pump pump) {
this.pump = pump;
}
@Override
public void drink(){
if(pump.isPumped()){
System.out.println("-----Drinking-----");
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
三個接口已經實現完畢,對比三個實現類,有沒有發現什麼共同點. 是的,你會發現,三個類中都有使用@Inject來註解他們的構造函數,這是因爲Dagger要用@Inject來註解一個類的實例構造函數,當請求一個新實例的時侯,Dagger就會獲取這個
參數值並調用這個構造函數。也許你不明白,沒關係,繼續往下看,會給出詳細解釋。
Dagger不僅能向上述代碼那樣註解構造函數,也能直接註解fields(Dagger can inject fields directly),看這個類:
package com.example.app.dagger;
import javax.inject.Inject;
import dagger.Lazy;
/**
* Created by zjb on 14-1-22.
*/
class CoffeeMaker {
@Inject
Lazy<Heater> heater;
@Inject
Pump pump;
@Inject
Drink drink;
public void brew() {
heater.get().on();
pump.pump();
System.out.println("-----Pumped-----");
heater.get().off();
drink.drink();
}
}
將Heater、Pump及Drink注入到類CoffeeMaker中,就可以直接使用並調用其方法。值得注意的是,在註解的時候Dagger
就會通過@Module中的@Provides方法調用構造函數來獲得實例對象(下面馬上介紹)。如果你@Inject fields卻沒有@Inject
構造函數,Dagger就會使用一個存在的無參構造函數,若沒有@Inject構造函數,就會出錯。繼續看@Module
package com.example.app.dagger;
import android.content.Context;
import javax.inject.Singleton;
import dagger.Module;
import dagger.Provides;
/**
* Created by zjb on 14-1-22.
*/
@Module(injects={CoffeeActivity_.class},library = true,complete = false)
/*@Module(injects = {CoffeeActivity_.class},includes = {PumpModule.class,DrinkModule.class},library = true,complete = false)*/
class DripCoffeeModule {
private final Context context;
public DripCoffeeModule(Context context) {
this.context = context.getApplicationContext();
}
@Provides
@Singleton
Context appliactionContext() {
return context;
}
@Provides
@Singleton
Heater provideHeater(){
return ElectricHeater_.getInstance_(appliactionContext());
}
@Provides
@Singleton
Drink provideDrink(PeopleDrink drink){
return drink;
}
@Provides
@Singleton
Pump providePump(Thermosiphon pump){
return pump;
}
}
上面就是使用@Module註解的類,Dagger要求所有的@Provides必須屬於一個Module.他們僅僅是一個使用@Module註解的類。
解釋一下前面一句話:如果說@Inject實現了注入,那麼@Provides就是實現依賴關係。@Provides方法方法的返回類型就定義了它
所滿足的依賴。你也許注意到了我註釋掉的@Module,這是什麼意思呢?是這樣的,假如我這裏將providesDrink方法刪除,我可以
另建一個DrinkModule.java文件,由於所有的@Provides必須屬於一個Module,所以必須將DrinkModule類includes進來:
package com.example.app.dagger;
import dagger.Module;
/**
* Created by zjb on 14-1-22.
*/
@Module(library = true,complete = false)
public class DrinkModule {
@Provides
@Singleton
Drink provideDrink(PeopleDrink drink){
return drink;
}
}
(@Module後的library和complete是什麼意思這裏先不說)至此,Dagger中的三個重要annotation已經全部涉及到了,那麼它是如何管理這些依賴關係的呢?繼續往下看:
package com.example.app.dagger;
import android.app.Application;
import org.androidannotations.annotations.EApplication;
import dagger.ObjectGraph;
/**
* Created by zjb on 14-1-22.
*/
@EApplication
public class CoffeeApplication extends Application {
private ObjectGraph objectGraph;
@Override
public void onCreate() {
super.onCreate();
objectGraph = ObjectGraph.create(new DripCoffeeModule(this));
}
public ObjectGraph getObjectGraph() {
return objectGraph;
}
}
上邊提到,Dagger是通過什麼管理或者組織依賴關係的呢,就是通過ObjectGraph(對象圖表)。
最後的主程序:在節面中就一個按鈕來觸發整個過程
package com.example.app.dagger;
import android.app.Activity;
import android.widget.Toast;
import com.example.app.R;
import org.androidannotations.annotations.AfterInject;
import org.androidannotations.annotations.App;
import org.androidannotations.annotations.Background;
import org.androidannotations.annotations.Click;
import org.androidannotations.annotations.EActivity;
import org.androidannotations.annotations.UiThread;
import javax.inject.Inject;
import dagger.ObjectGraph;
/**
* Created by zjb on 14-1-22.
*/
@EActivity(R.layout.coffee)
public class CoffeeActivity extends Activity {
@App
CoffeeApplication coffeeApplication;
@Inject
CoffeeMaker maker;
@AfterInject
void daggerInject(){
ObjectGraph objectGraph = coffeeApplication.getObjectGraph();
objectGraph.inject(this);
}
@Click(R.id.coffeeClick)
@Background
void coffeeClicked(){
maker.brew();
coffeeBrew();
}
@UiThread
void coffeeBrew(){
Toast.makeText(this,"Coffee has been pumped...",Toast.LENGTH_LONG).show();
}
}
程序運行的結果:
com.example.app I/System.out﹕ -----Heating-----
com.example.app I/System.out﹕ -----Pumping-----
com.example.app I/System.out﹕ -----Pumped-----
com.example.app I/System.out﹕ -----Drinking-----
使用Dagger,我們能夠很好的實現依賴關係,也能更清楚的看到我們的代碼在做些事情,能夠清晰地顯示出各部分的
邏輯關係,通過下面這張圖,我們能夠很清楚的看到它的每一步操作:
好了,Dagger呢就介紹到這裏,源碼這次就先不上傳了,等到介紹完Otto之後,我會抽空上傳到資源,供大家下載學習。
內容細節說的不全請見諒、指教。如果你對使用dagger有興趣也歡迎一起討論、學習。這是春節前最後一篇文章了,祝大家
搶到一張好票,馬上有錢、有對象!
注:文章原創 轉載請註明出處:CSDN 菜鳥的成長史
附:
Demo 下載
Jake Warhton的Dagger ppt 下載資源