@(Alu)

1.導入Dagger2依賴

APP的build.gradle文件中:

apply plugin: 'kotlin-kapt"
kapt {
generateStubs = true
}
dependencies {
...
...
compile "com.google.dagger:dagger:2.11"
kapt 'com.google.dagger:dagger-compiler:2.11'
}

注：必須使用 kapt方式添加注解，否則會出現無法編譯自動生成類文件的bug。

2.需要用的的Daager2基礎

我所理解的dagger2 就是可以讓你不需要手動實例化就可以拿到參與注解的類的實例化對象
表現在MVP里：

View層不需要實例化就可以隨時拿到Presenter的實例化對象，presenter同樣可以拿到View 與 Model。
因而讓MVP開發模式解耦的同時又進一步解耦，且減少代碼量。
這也是我看來需要學習掌握dagger2的必要性。

在實際開發中dagger2有兩種注解模式，也就是依賴注入模式。

1.在目標依賴類構造函數上使用 @Inject

**
 * 方式1
 * 在目標依賴類構造函數@Inject 
 *
 */

class A @Inject constructor(private val aa: Aa, private val aaa: Aaa) {
    fun getData() = aa.getData() + aaa.getData()
}

class Aa @Inject constructor() {
    init {
        println("Aa類初始化后，")
    }
    fun getData() = "在kotlin中使用注解構造方法的方式拿到值"
}

class Aaa @Inject constructor(private val aa: Aa) {
    init {
        println("Aaa類初始化后，")
    }

    fun getData() = "在Aaa中獲取到Aa的數據:" + aa.getData()
}

class B {
    @Inject lateinit var a: A

    init {
        DaggerABComponent.create().Inject(this)
    }

fun getData() = a.getData()
}

@Component
 interface ABComponent {
    fun Inject(b: B)
}

在代碼中我使用@Inject 注解了A，Aa，Aaa三個類的構造函數 .
在 B 類中，我們拿到 A類的對象，在 A類中 拿到了 Aa,Aaa類的對象 .

寫出 main函數運行測試：

fun main(args: Array<String>) {
    println(B().getData())
}

運行main函數得到結果：

在目標依賴類構造函數@Inject.png

2.使用 @Module

/**
 * 方式2 使用@Module
 */
class C {
    fun getData() = "kotlin中使用@Moudle的方式，獲取到了C 的實例化對象"
}

@Module
class D {
    @Provides
    fun provideC() = C()
}

@Singleton
@Component(modules = arrayOf(D::class))
interface CDComponent {
    fun inject(e: App)
}

class App {
    @Inject lateinit var c: C
    init {
        DaggerCDComponent.create().inject(this)
    }
    fun getData() = c.getData()
}

寫出 main函數運行測試：

fun main(args: Array<String>) {
println(B().getData())
println(C().getData())
}

運行main函數得到結果：

使用@Module.png

準備工作已經做好 ，進入正題：

3.模擬實際MVP模式下的開發

為什么說模擬,因為是使用普通的java類來代替實際開發的類，原因是這樣做有幾個好處:
一是代碼量會很小，便于邏輯的體現
二是所有類都寫在一個.kt 文件里，對比參照起來會很舒服.便于理解

雖說是模擬，但五臟俱全,貼上代碼:

/**
 * 模擬MVP
*/

/**
 * Application
 */
class App {
    @Inject lateinit var cdComponent: CDComponent

    companion object {
        lateinit var instance: App
    }

    init {
        instance = this
        DaggerCDComponent.builder().d(D()).build().inject(this)
    }
}

@Module
class D {
    @Provides
    fun provideC() = "做一些初始化操作,例如 Retrofit 初始化"
}

@Singleton
@Component(modules = arrayOf(D::class))
interface CDComponent {
    fun inject(e: App)
    fun plus(cdfModule: CDFModule): CDFComponent
}

@Subcomponent(modules = arrayOf(CDFModule::class))
interface CDFComponent {
    fun inject(f: F)
}

@Module
class CDFModule(private val mView: I) {
    @Provides fun providesView() = mView
}


/**
 * View
 */
class F : I {
    override fun setData(str: String) {
        println(str)
    }

    @Inject lateinit var m: Presenter

    init {
        App.Companion.instance.cdComponent.plus(CDFModule(this)).inject(this)
    }

    /**
     *  拉取數據
     */
    fun getData() = m.getData()
}

interface I {
    fun setData(str: String)
}

/**
 * presenter
 */
class Presenter
@Inject constructor(private val mView: I, private val mModel: Model) {

    fun getData() {
        /**
         * 網絡延遲
         */
        Thread.sleep(2000)
        mView.setData(mModel.getData())
    }
}

/**
 * Model
 */
class Model @Inject constructor() {
    fun getData() = "這是數據源"
}

在Application做總初始化，在具體的Activity 或fragment里 注解拿到 presenter 調取服務請求
使用I接口回傳 數據.

寫出 main函數運行測試：

fun main(args: Array<String>) {
    App()
    F().getData()
}

運行main函數得到結果：

MVP.png

數據源在兩秒延遲后被回傳到View層,View層得到結果并打印.

寫的比較倉促，如有問題，望指正。