[[174027]]

依賴注入這個模式(模式已經(jīng)用爛了，這里再爛一次)是用來給應(yīng)用的各部分解耦的。使應(yīng)用開發(fā)更加可擴展，更容易維護。通過本文你會學到如何使用Dagger2來處理依賴。

簡介

如果以對象需要另外的一個對象才能完成一個完整功能的話，那么這里就存在一個依賴。比如，悟空要用金箍棒才能三打白骨精，要筋斗云才能十萬八千里。悟空有對金箍棒和筋斗云的依賴。你可以在悟空對象里初始化金箍棒，也可以用一個工廠方法批量生產(chǎn)金箍棒。使用依賴注入可以無需一個專門的類來初始化這些依賴對象。這樣就實現(xiàn)了解耦。

本教程會使用***的Dagger2(當前的版本是2.2)。這里是官網(wǎng)。你可以在這里找到***的發(fā)布。

準備

Android Studio是必須的。其他：

1. Dagger2 基礎(chǔ)

注解講解：

• @Module這個annotation修飾的類專門用來提供依賴
• @Provides這個annotation修飾的方法用在Module類里
• @Inject用來annotation一個依賴(可以是構(gòu)造方法、field或者一般的方法)
• @Component連接@Module和注入的橋梁

這些名詞看起來非常抽象。下面稍微解釋一下。依賴反射并沒有什么神奇的地方。只不過是我們需要單獨寫初始化依賴的地方由其他的框架代替了。這個依賴關(guān)系也有我們常寫的代碼轉(zhuǎn)移到了“配置文件”中。

在很久以前，依賴注入的框架就是這樣處理依賴注入的：讀取配置文件的依賴關(guān)系，然后用反射的方法初始化被依賴對象并賦值給調(diào)用依賴的對象。比如，我們之前在悟空類中初始化金箍棒：

public class Wukong { 
    private Jingubang jingubang; 
 
    public Wukong(){ 
        // 依賴 
        this.jingubang = Jingubang(); 
    } 
}  

后來有了使用配置文件的依賴注入(這里都是虛構(gòu)的文件格式)：

<xml> 
    <com.xiyou.Wukong> 
        <dependency field="jingubang"> 
            <com.xiyou.Jingubang /> 
        </dependency> 
    </com.xiyou.Wukong> 
</xml>  

在悟空使用金箍棒的時候，依賴注入框架自動初始化好了金箍棒，并賦值給了悟空。

現(xiàn)在使用Dagger2。這里就有不得不說的牛X的地方了。因為是在Android里能用的資源沒有后端那么多。尤其反射消耗比較大!所以Dagger為了滿足移動開發(fā)節(jié)約資源的需要，沒有使用反射實現(xiàn)依賴注入。而是在編譯的時候同時生成依賴注入的相關(guān)代碼。生成代碼的根據(jù)就是前文中說明的那些注解(annotation)以及使用這些annotation的類、接口。

總結(jié)起來就一句話，Dagger把你需要在悟空類里寫的金箍棒類的初始化代碼都根據(jù)注解替你自動生成了!只不過這種生成的代碼比明晃晃的使用new初始化的方法更加復雜一些。

Dagger2 開發(fā)步驟

把大象裝冰箱一共分幾步：

1. 定義依賴和被依賴的對象的類，悟空類和金箍棒類。“悟空類”和“金箍棒類”的構(gòu)造函數(shù)用@Inject注解修飾。
2. 定義一個@Module注解的類，一般叫做XXXModule。里面寫的@Provides注解修飾的方法。這些@Provides方法返回“悟空類”和“金箍棒類”對象。比如@Provides Wukong provideWukong(){ return new Wukong(); }
3. 創(chuàng)建一個interface，并用@Component注解修飾。一般叫做XXXComponent。里面寫一個注入方法：void inject(Wukong wk);。這里Wukong只是一個例子。任何你準備要注入的類都可以代替上面參數(shù)的Wukong類。
4. 在需要注入的地方寫@Inject的field。

***，Dagger會根據(jù)上面的內(nèi)容和***的@Component接口生成一個DaggerXXXComponent的類型，使用這個類型來實現(xiàn)注入。上面的1到3步可以理解為依賴的配置。***的XXXComponent代替古老的Reflect方式實現(xiàn)注入。

***步的@Inject修飾的構(gòu)造函數(shù)和`@Module`的`provideXXX`方法二者可以省略一個。

Dagger可以根據(jù)其中的任意一種配置創(chuàng)建依賴的對象。都寫上等于有了雙保險。

上文提到過多次。Dagger 2厲害的地方就在于這個庫完全不用反射，而是用在編譯期生成代碼的方式實現(xiàn)的依賴注入。這個特點導致在Android Studio配置的時候需要做一些額外的工作。

這里假設(shè)你已經(jīng)創(chuàng)建了一個新的Android應(yīng)用項目。下面打開build.gradle文件，我們一步一步的來完成Dagger2的配置。

3. Android Studio的配置

***步

apply plugin: 'kotlin-android' // 非必須 
 
apply plugin: 'kotlin-android-extensions' // 必須!!!  

為什么要加一個新的plugin呢?這個是為后面使用的kapt和provided提供支持的。gradle本身不支持這兩個操作。

第二步

buildscript { 
    ext.kotlin_version = '1.0.1-2' 
    repositories { 
        mavenCentral() 
    } 
    dependencies { 
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" 
        classpath "org.jetbrains.kotlin:kotlin-android-extensions:$kotlin_version" 
    } 
}  

第三步

dependencies { 
    // ...其他略... 
    compile 'com.google.dagger:dagger:2.2' 
    kapt 'com.google.dagger:dagger-compiler:2.2' 
    provided 'javax.annotation:jsr250-api:1.0' 
}  

• dagger, 我們要用的正主。
• dagger-compiler, 用來生成代碼。
• java.annotation, 提供Dagger意外的注解

***，同步Gradle。

使用Dagger 2

下面就是Dagger一展身手的時候了。

首先，我們已經(jīng)有悟空和金箍棒了。代碼如下：

悟空：

import javax.inject.Inject; 
 
/** 
 * Created by uncle_charlie on 6/4/2016. 
 */ 
public class Wukong { 
 
    @Inject 
    JinGuBang jinGuBang; 
 
    @Inject 
    public Wukong() { 
 
    } 
 
    public String useJinGuBang() { 
        return this.jinGuBang.use(); 
    } 
}  

金箍棒：

import javax.inject.Inject; 
 
/** 
 * Created by uncle_charlie on 6/4/2016. 
 */ 
public class JinGuBang { 
 
    @Inject 
    public JinGuBang() { 
 
    } 
 
    public String use() { 
        return "user Jing gu bang"; 
    } 
}  

悟空對金箍棒有依賴，所以金箍棒屬性有@Inject注解修飾。

因為兩個類都需要Dagger創(chuàng)建，所以在構(gòu)造函數(shù)上都有@Inject注解。

第二步 創(chuàng)建@Module類

創(chuàng)建@Module注解的類，并在其中添加@Provides注解修飾的方法。這些方法創(chuàng)建被依賴的對象。

import dagger.Module; 
import dagger.Provides; 
 
/** 
 * Created by uncle_charlie on 6/4/2016. 
 */ 
@Module 
public class XiYouModule { 
    @Provides 
//    @Singleton 
    Wukong provideWukong() { 
        return new Wukong(); 
    } 
 
    @Provides 
//    @Singleton 
    JinGuBang provideJinGuBang() { 
        return new JinGuBang(); 
    } 
}  

• @Singleton注解表明，這個被依賴的對象在應(yīng)用的生命周期里只有一個實例。
• 這個里的@Provides方法和前一步說到的@Inject注解的構(gòu)造函數(shù)兩個可以只寫一個。

第三步 @Component接口，連接@Module和@Inject

@Module和@Provides方法提供了被依賴的對象。@Inject在@Component接口出現(xiàn)的地方則是指明了需要注入的地方(一般是一個field)。@Component接口就是用來把他們連接起來的。

import android.app.Activity; 
import javax.inject.Singleton; 
import dagger.Component; 
 
/** 
 * Created by uncle_charlie on 6/4/2016. 
 */ 
@Component(modules = {XiYouModule.class}) 
@Singleton 
public interface XiYouComponent { 
    void inject(Wukong wk); 
    void inject(Activity a); 
}  

其中inject()方法里使用的對象，就是包含@Inject的field的需要注入的對象。

在這個接口中也可以不用inject()方法，而使用provideXXX()方法后面會有更多介紹。

注意：@Component接口一定要在直接中指明@Module類型

第四步 使用@Component接口獲取對象

經(jīng)過前面的步驟，依賴和被依賴對象關(guān)系都已經(jīng)配置好了。下面就來獲取被依賴對象來注入依賴對象。

public class MainActivity extends AppCompatActivity { 
    private static final String TAG = "##MainActivity"; 
 
    @Inject 
    Wukong wukong; 
 
    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
        super.onCreate(savedInstanceState); 
        setContentView(R.layout.activity_main); 
 
        TextView welcomeTextView = (TextView) findViewById(R.id.welcome_textview); 
        // 1 
        XiYouComponent xiYouComponent = DaggerXiYouComponent 
                .builder() 
                // 2 
                .xiYouModule(new XiYouModule()) 
                .build(); 
        xiYouComponent.inject(this); 
        // 3 
        welcomeTextView.setText(wukong.useJinGuBang()); 
    } 
}  

首先主要到屬性@Inject Wukong wukong;已經(jīng)在MainActivity 聲明了。這里表明一個依賴關(guān)系：這個activity依賴于悟空，并準備注入悟空對象。

1. Dagger2會在編譯器自動生成依賴注入的代碼，所以在添加上面的代碼之前需要編譯一下。DaggerXiYouComponent就是Dagger根據(jù)我們的XiYouModule類生成的代碼。
2. 在這一步給DaggerXiYouComponent的builder添加XiYouModule的實例。如果這個Module只需要用到無參構(gòu)造函數(shù)的話可以用一種省略用法：create()方法?？梢院唽憺椋?/li>

DaggerXiYouComponent 
                .builder() 
                // 2 
                //.xiYouModule(new XiYouModule()) 
                //.build() 
                .create(); 

Component接口的對象調(diào)用inject(this)方法之后注入即完成。所以可以直接使用@Inject Wukong wukong;屬性來調(diào)用方法：welcomeTextView.setText(wukong.useJinGuBang());***在activity中顯示方法返回的文字。

運行代碼，看看結(jié)果吧。

結(jié)論

以上內(nèi)容可以概括為：什么被依賴，就把什么放在@Module類里(或者什么被依賴，就給什么添加@Inject的無參構(gòu)造函數(shù))。什么有依賴(@Inject屬性)，就把什么放在@Component接口的inject()方法參數(shù)里。(或者有什么@Inject屬性，就在@Component接口里provide什么對象)。這個概括不一定嚴密，但是基本用法全部包括了。

依賴注入是很有用的。以上的內(nèi)容只是Dagger2依賴注入的一部分。各位讀者還需要根據(jù)官方文檔多加練習才能更好的理解依賴注入和Dagger的各種用法。