前言
最近在用 MVP + RxJava + Retrofit 寫項目，覺得相對于其他的開發框架，這的確是給我們帶來了很多方便，但是在網上搜尋相關資料的時候，總是能看到 MVP + RxJava + Retrofit + Dagger 這樣的搭配組合，那 Dagger 又是一個怎樣的框架呢，我也去具體搜了搜，但看到一些文章帶著“Dagger2從入門到放棄”這樣意思的句子，就感覺Dagger2會很難嗎，emmmm...行吧，好像是有點難理解，但是想著既然有那么多人用這個框架，必然有它的好處，于是花了些時間學習了一波。
Dagger2
Dagger2 ： A fast dependency injector for Android and Java. （官方給出的定義）
Dagger2是一個依賴注解框架，它的作用就是通過注解來實現組件之間的依賴，由此來達到更好的解耦，比如說，如果將 Dagger2 使用到我們的 MVP 框架中，那么我們就可以達到 V層 和 P層 的進一步解耦，從而使我們的項目有更好的維護性。
Dagger2 和 Butterknife 一樣，都是在編譯階段利用Java注解通過APT（Annotation Processing Tool）自動生成Java代碼，然后由我們自己寫的代碼進行調用，完成依賴注入，因此不用擔心性能上的問題。那么如何來使用 Dagger2 呢？我們先來看一下使用 Dagger2 和不使用的區別。
對比
用簡單的例子來說明。比如說我們有這樣一個AAA類，沒什么內容，只有一個get()方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
/** * @author chaochaowu * @Description : AAA * @class : AAA * @time Create at 6/12/2018 10:58 AM */public class AAA { public AAA() { } public void get(){ Log.e("AAA","has gotten."); }} |
我們需要在MainActivity用到這個類，因此MainActivity中變含有這個成員變量，有了這個成員變量aaa，我們就要對它進行實例化，因此會有以下的代碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
/** * @author chaochaowu * @Description : MainActivity * @class : MainActivity * @time Create at 6/12/2018 10:58 AM */public class MainActivity extends AppCompatActivity { AAA aaa; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); aaa = new AAA(); aaa.get(); }} |
我們需要在 MainActivity 中聲明aaa這個變量，然后會對其進行new一個實例，然后才能對其進行調用，調用它定義的方法。這樣，AAA類對象的創建就和 MainActivity 耦合在了一起。如果使用 Dagger2 進行依賴注入呢
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
/** * @author chaochaowu * @Description : MainActivity * @class : MainActivity * @time Create at 6/12/2018 10:58 AM */public class MainActivity extends AppCompatActivity { @Inject AAA aaa; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main2); DaggerMainActivityComponent.create().inject(this); aaa.get(); }} |
代碼就會變成這樣。我們可以發現MainActivity里沒有任何有關aaa的初始化賦值，但是它還是可以調用其get()方法。這樣我們就達到了解耦合的目的。
這樣一個簡單的例子可能看不出 Dagger2 的好處，但是你可以想象一下，如果這個 Activity 里有很多個類似 AAA 這樣的類的成員變量，它們都需要初始化，有的初始化還要傳參數，那么，這個 Activity 就會變得臃腫，如果 AAA類 的初始化參數變了，不僅 AAA類 需要改，MainActivity 因為它與AAA類的耦合也要跟著改變，如果 AAA類 不止用在 MainActivity 中還用在了其他的 Activity 中，那么要改的東西變的可有點多咯，但是如果用上Dagger2，我們就可以很好的解決這個問題。
注解介紹
Dagger2中注解有：@Inject， @Component， @Module， @Provides， @Qulifier， @Scope， @Singleten 。而我們主要用到的是@Inject， @Component，@Module， @Provides 這四個，下面來介紹一下。
@Inject
Inject 主要用來標記需要依賴的變量，告訴Dagger需要為它提供依賴；inject 還被用來標記類的構造函數。當Dagger2碰到使用@Inject注解的變量時，會去尋找這個變量對應的被@Inject注解的構造函數，把實例構造出來，為變量提供依賴。
@Component
@Component用于標注接口，是依賴需求方（MainActivity）和依賴提供方（AAA）之間的橋梁。被Component標注的接口在編譯時會生成該接口的實現類，類的名稱為被@Component注解的類的名稱前加上Dagger，我們通過調用這個實現類的方法來完成注入。
@Module
Module用于標注提供依賴的類。雖然我們有@Inject注解實現注入，但是@Inject只能注入構造函數為無參的類，要是構造函數是帶參數的呢？那就要使用module注解來解決這個問題，又比如說，有很多的第三方庫，我們對它的代碼無法進行修改，也就不能對其構造函數加上@Inject注解，那么可咋辦啊，@module注釋可以很好的解決我們的問題。
@Provides
Provides是與Module一起使用的，@Provides用于標注Module所標注的類中的方法，該方法會在需要提供依賴時被調用，在方法內進行對象的初始化，返回對象依賴給標注了@Inject的變量。相當于一個有參數的@Inject。
我們來具體的使用一下。
構造函數無參的對象注入
用上面提到的 AAA類 進行依賴注入演示。
首先我們在 AAA類 的構造函數上加上 @Inject 注解（構造函數必須得是無參）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
/** * @author chaochaowu * @Description : AAA * @class : AAA * @time Create at 6/12/2018 10:58 AM */public class AAA { @Inject public AAA() { } public void get(){ Log.e("AAA","has gotten."); }} |
然后創建一個 MainActivityComponent 接口并用 @Component 進行注解，然后Build一下項目，
|
1
2
3
4
5
6
7
8
9
10
11
|
/** * @author chaochaowu * @Description : MainActivityComponent * @class : MainActivityComponent * @time Create at 6/12/2018 11:03 AM */@Componentpublic interface MainActivityComponent { void inject(MainActivity mainActivity);} |
Build之后apt會自動生成如下的代碼
build后生成.png
我們利用其中的 DaggerMainActivityComponent 進行 MainActivity 與 AAA類 之間的橋梁搭建。如下代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
/** * @author chaochaowu * @Description : MainActivity * @class : MainActivity * @time Create at 6/12/2018 10:58 AM */public class MainActivity extends AppCompatActivity { @Inject AAA aaa; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main2); DaggerMainActivityComponent.create().inject(this); aaa.get(); }} |
至此，我們便完成了構造函數無參的對象的依賴注入。
構造函數含參的對象注入
相信很多的時候，我們要用的對象在構造的時候是需要參數的，那我們如何進行它們的依賴注入呢，這里我用 MVP 中的 Presenter 來進行演示。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
/** * @author chaochaowu * @Description : MainActivity * @class : MainActivity * @time Create at 6/12/2018 10:58 AM */public class MainActivity extends AppCompatActivity implements MainContract.View{ MainContract.Presenter mPresenter; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); mPresenter = new MainPresenter(this); mPresenter.getData(); }} |
上面的代碼是沒用 Dagger2 時的 Activity，在 MVP 框架中，由于 Presenter 需要與 View 進行交互，需要持有View的對象，因此在初始化的時候，需要在構造函數里傳入View對象作為參數，可以看到代碼中 mPresenter = new MainPresenter(this);
接下來我們對它進行依賴注入。首先看一下 Presenter,，Presenter不需要作出任何改變，我們可以看到它的構造函數帶有一個參數View
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/** * @author chaochaowu * @Description : MainPresenter * @class : MainPresenter * @time Create at 6/11/2018 2:22 PM */public class MainPresenter implements MainContract.Presenter{ MainContract.View mView; public MainPresenter(MainContract.View mView) { this.mView = mView; } @Override public void getData() { }} |
然后我們需要創建一個 MainActivityModule 類，并在該類名加上@Module注解，它含有一個成員變量 mView 需要在構造函數時賦值，我們之后會將這個變量給 Presenter 進行 Presenter 的構造，我們還需要寫一個方法，并在其上添加@Provides注解，方法的名字其實沒所謂可以隨便取，但是為了代碼的可讀性，一般都以provide開頭加上provide的東西的名字，我們在這個方法里返回我們所要提供依賴的對象，這里返回了一個 Presenter 對象，可以看到它在這里的構造，我們傳入了參數 View。到這便完成了MainActivityModule 的定義，其實這個 MainActivityModule 作用就和之前的 構造函數無參中的 對無參構造函數 Inject 步驟的性質相同。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
/** * @author chaochaowu * @Description : MainActivityModule * @class : MainActivityModule * @time Create at 6/11/2018 2:41 PM */@Modulepublic class MainActivityModule { MainContract.View mView; public MainActivityModule(MainContract.View mView) { this.mView = mView; } @Provides public MainContract.Presenter providePresenter(){ return new MainPresenter(mView); }} |
接下來和 構造函數無參的對象注入 中一樣，我們需要定義一個 MainActivityComponent ，并用 @Component 進行注解，不一樣的是需要在括號里加上參數 modules = {MainActivityModule.class} 如下代碼。
|
1
2
3
4
5
6
7
8
9
10
|
/** * @author chaochaowu * @Description : MainActivityComponent * @class : MainActivityComponent * @time Create at 6/11/2018 2:45 PM */@Component(modules = {MainActivityModule.class})public interface MainActivityComponent { void inject(MainActivity mainActivity);} |
Build一下項目
build之后生成.png
這樣我們就可以像上面一樣，在Activity中調用DaggerMainActivityComponent 進行依賴注入。看一下Activity中的代碼。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
/** * @author chaochaowu * @Description : MainActivity * @class : MainActivity * @time Create at 6/12/2018 10:58 AM */public class MainActivity extends AppCompatActivity implements MainContract.View{ @Inject MainContract.Presenter mPresenter; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); DaggerMainActivityComponent.builder() .mainActivityModule(new MainActivityModule(this)) .build() .inject(this); mPresenter.getData(); }} |
可以看到這里 DaggerMainActivityComponent 調用的方法有所不同，其中調用了一個mainActivityModule() 方法，傳入了一個 MainActivityModule 對象，該對象的初始化，我們又傳入了一個this，也就是View，這個 View就是我們在之后創建 Presenter 時傳入的參數 。
至此，我們就完成了構造函數有參的對象的依賴注入。其他有參的、第三方庫的依賴注入也是通過這樣的方式進行。
總結
Dagger2的使用，讓我們代碼的耦合度進一步降低了，這是一個優點，但是另一方面，使用了Dagger2你需要額外的去定義一些類，導致代碼的數量也增加。個人覺得，在比較小的項目中，如果去使用，有點emmmm....多此一舉？（劃掉），但是如果一個項目比較大，代碼本身也比較多，那么使用Dagger2所帶來的優點，便可以顯現了。所以說，是否在項目中使用 Dagger2 仁者見仁智者見智，不過作為一個學習的點，還是挺不錯的，嗯。
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持服務器之家。
原文鏈接：https://www.jianshu.com/p/3e9862b61625
