Dagger2之Kotlin写法

依赖

项目的gradle

buildscript {
ext.dagger_version = '2.11'
}
复制代码

module的gradle

//多模块项目，这个必须在使用到dagger2的全部moudle里都配置
apply plugin: 'kotlin-kapt'

dependencies {
    //dagger2，这个能够写在BaseMoudle里
    api "com.google.dagger:dagger:$dagger_version"
    //多模块项目，这个必须在使用到dagger2的全部moudle里都配置
    kapt "com.google.dagger:dagger-compiler:$dagger_version"
}
复制代码

概念

@Inject

1. 修饰构造方法
2. 修饰变量，在宿主类里，引入要注入的实例

@Module

生产实例的工厂，每个实例都是经过@Provides修饰的方法提供的

专门解决，不是本身写的类没法在其构造函数上加@Inject的状况

固然本身写的类也能够经过@Provides修饰的方法提供，这样就不会找@Inject的构造函数了

Component

Component是桥梁纽带，是一个接口

功能1：组织依赖关系（链条）

一个Component能够组织多个Module 一个Component还能够组织引入其余的Component

依赖的查找顺序为：先找@Module，若是找到了就中止，若是找不到就去找@Inject

功能2：为宿主类提供Inject方法

@Inject+@Component

全部实例类型所有在我掌控之中 最简单的状况 （不须要Module）

（要注入的实例的类都是本身写的，不须要Module，本身写的类本身用@inject修饰构造方法）

构造方法不带参数

1. 注入类的构造方法使用 @Inject

class Apple @Inject constructor(){
    var color:String ="red"
}
复制代码

2. 必须有一个FruitComponent接口，提供一个注入方法

   注意：参数必须为要使用对象注入的类

@Component
interface FruitComponent {
    fun inject(activity: MainActivity)
}
复制代码

3. 经过inject注入全部对象，@Inject使用注入对象

class MainActivity : AppCompatActivity() {
    @Inject
    lateinit var apple: Apple//注入实例

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        DaggerFruitComponent.builder().build().inject(this)//必须注入一下
        tv1.setOnClickListener {
            rx1()
        }
    }

    private fun rx1() {
        toast(apple.color)

    }
}
复制代码

构造方法带参数

（可是所带参数的构造函数，也能够被@Inject修饰，即所带参数的类型的类也是本身写的）

class Apple @Inject constructor(val knife: Knife) {
    var color: String = "red"
}
复制代码

class Knife @Inject constructor() {
    var name: String = "小刀"
}
复制代码

@Component
interface FruitComponent {
    fun inject(activity: MainActivity)
}
复制代码

class MainActivity : AppCompatActivity() {
    @Inject
    lateinit var apple: Apple
    @Inject
    lateinit var knife: Knife
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        DaggerFruitComponent.builder().build().inject(this)
        tv1.setOnClickListener {
            rx1()
        }
    }

    private fun rx1() {
        Log.e("CCC",knife.name)
        Log.e("CCC",apple.color)

    }
}
复制代码

@Inject+@Component+@Module(含@Provides)

有些实例类型，我没法掌控

别慌！@Module来帮忙

两种状况

1. 你要注入的实例的类型就不是你本身写的类，没法使用@inject
2. 你要注入的实例的类型就是你本身写的类，可是带了一个参数，这个参数类型的类不是你本身写的，没法使用@inject

状况一

@Module
class SecondModule {
    @Provides
    fun provideString():String{
        return  "我是String，你能在个人构造方法上加@inject吗？是的，你不能！"
    }
}
复制代码

@Component(modules = [SecondModule::class])
interface SecondComponent {
    fun  inject(activity:MainActivity)
}
复制代码

class MainActivity : AppCompatActivity() {

    @Inject
    lateinit var s: String


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        DaggerSecondComponent.builder().build().inject(this)//注入
        tv1.setOnClickListener {
            rx1()
        }
    }

    private fun rx1() {
        Log.e("CCC", s)
    }
}

复制代码

状况二

Person 是我本身写的类，我能够在它构造方法上面加@inject，可是他有一个参数是String，你要提供Person对象就必须提供Person所须要的全部参数，咱们没法在String上加@inject

class Person @Inject constructor(var name: String){
    
}
复制代码

@Module
class SecondModule {
    @Provides
    fun provideString():String{
        return  "我是为Person提供name的，可是我是String，你能在个人构造方法上加@inject吗？是的，你不能！"
    }
}
复制代码

@Component(modules = [SecondModule::class])
interface SecondComponent {
    fun  inject(activity:MainActivity)
}
复制代码

class MainActivity : AppCompatActivity() {

    @Inject
    lateinit var person: Person

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        DaggerSecondComponent.builder().build().inject(this)
        tv1.setOnClickListener {
            rx1()
        }
    }

    private fun rx1() {
        Log.e("CCC", person.name)
    }
}
复制代码

SecondComponet依赖其余的ThirdComponet

1.先准备第一个ThirdComponet，他一会要被SecondComponet依赖

class Cat @Inject constructor(var age: Int)
复制代码

@Module
class ThirdMoudle {
//    这里直接提供了Cat的实例，而不是只是提供一个age（相似上面Person的name）
//    直接提供实例，就不用写提供age实例的provides方法了
    @Provides
    fun provideCat():Cat{
        return Cat(1)
    }
}
复制代码

<!--好多坑，看注释-->
@Component(modules = [ThirdMoudle::class])
interface ThirdComponet {
//    ★由于这个ThirdComponet要被SceondComponent依赖，这里必须提供一个方法，否则报错
//    ★若是没有Componet依赖ThirdComponet，这里能够不写
    fun provideCat():Cat
    //fun inject(activity:Activity)
    //★若是ThirdComponet没有要注入的类，这里不要写inject也行，可是写的话千万不能同SecondComponet所注入的类同样，会报错
}
复制代码

2. 看第二个SecondComponent的写法

class Person @Inject constructor(var name: String)
复制代码

@Module
class SecondModule {
    @Provides
    fun provideString():String{
        return  "我是为Person提供name的， 可是我是String，你能在个人构造方法上加@inject吗？是的，你不能！"
    }
}
复制代码

@Component(modules = [SecondModule::class]
    ,dependencies = [ThirdComponet::class])
    //★dependencies依赖ThirdComponet
interface SecondComponent {
    fun  inject(activity:MainActivity)
}
复制代码

3. 注入到MainActivity使用

class MainActivity : AppCompatActivity() {

    @Inject
    lateinit var person: Person
    @Inject
    lateinit var cat: Cat

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val thirdComponet = DaggerThirdComponet.builder().build()

        DaggerSecondComponent.builder()
            .thirdComponet(thirdComponet)//★注意这里传入thirdComponet
            .build().inject(this)
        tv1.setOnClickListener {
            rx1()
        }
    }

    private fun rx1() {
        Log.e("CCC", person.name)
        Log.e("CCC", "${cat.age}")
    }
}
复制代码

Scope

摘抄自：Dagger2：Scope, Component间依赖和subComponent

参考

Android：dagger2让你爱不释手-基础依赖注入框架篇

Dagger2：Scope, Component间依赖和subComponent