使用Dagger2 对第三方依赖库进行初始化，减少Application 代码的冗余

作用：对于在 Application 中进行初始化(如第三方依赖库) 使用 Dagger 进行包装处理，减少Application 代码的冗余。

原理 ：将每个依赖的初始化算法包装到它自己的类中，向Dagger发信号通知我们要将它们绑定到一个集合中，然后迭代它并告诉每个依赖执行它的初始化。

实现步骤：

1. 定义一个Initializer 接口，每个依赖初始化包装器(TimberInitializer,FooInitializer ...) 将实现该接口

2. 在每个依赖初始化包装器类 中不要忘记包含 @Inject构造函数

3. 创建一个Dagger模块 InitializerModule类, 并绑定相关的依赖初始化包装器类

4. 创建 AppInitializer类，然后可以将此类注入或暴露给您的自定义Application子类并调用initialize()方法

5. 创建AppComponent接口，将Dagger模块 InitializerModule类进行关联，并提供一个appInitializer 初始化方法

6. 在自定义Application 进行初始化操作

// 1. 初始化通用接口
interface Initializer {

    fun initialize()

}

// 2. Timber 初始化
class TimberInitializer @Inject constructor() : Initializer {

    override fun initialize() {
        if (BuildConfig.DEBUG) {
            Timber.plant(Timber.DebugTree())
        }
    }
}

// 2. Fresco 初始化
class FrescoInitializer @Inject constructor(private val context: Context) : Initializer {

    override fun initialize() {
        Fresco.initialize(context)
    }
}

/**
 * 2. 需要使用Context 进行初始化依赖库
 */
class FooInitializer @Inject constructor(private val context: Context) : Initializer {

    override fun initialize() {
        Foo.initialize(context)
    }
}

@Module
abstract class InitializerModule {


    // 使用@IntoSet注释，我们告诉Dagger我们希望所有这些新实例Initializer可以通过注射器使用Set<Initializer>。
    // 让我们将这样的一个Set注入另一个自定义类--> AppInitializer
    // AppInitializer然后可以将此类注入或暴露给您的自定义Application子类并调用initialize()方法！
    // 请注意，在Kotlin中@JvmSuppressWildcards，此注释是编译成功所必需的。
    @Binds
    @IntoSet
    abstract fun timberInitializer(timberInitializer: TimberInitializer): Initializer


    @Binds
    @IntoSet
    abstract fun fooInitializer(fooInitializer: FooInitializer): Initializer


    @Binds
    @IntoSet
    abstract fun frescoInitializer(frescoInitializer: FrescoInitializer): Initializer

}

class AppInitializer @Inject constructor(
    private val initializers: Set<@JvmSuppressWildcards Initializer>
) : Initializer {

    override fun initialize() {
        initializers.forEach(Initializer::initialize)
    }

}

@Component(modules = [InitializerModule::class])
interface AppComponent {

    fun appInitializer(): AppInitializer

    @Component.Builder
    interface Builder {

        @BindsInstance
        fun context(context: Context): Builder

        fun build(): AppComponent
    }


}

class App : Application() {

    private val appComponent: AppComponent by lazy {
        DaggerAppComponent.builder()
            .context(this)
            .build()

    }

    override fun onCreate() {
        super.onCreate()

        appComponent.appInitializer().initialize()

    }
}

现在，每当添加需要初始化新依赖项时，只需实现Initializer接口的实现类，并将其添加到InitializerModule绑定列表中。

注意：

1. 添加Dagger依赖

    def dagger_version = "2.22.1"
    implementation "com.google.dagger:dagger:$dagger_version"
    kapt "com.google.dagger:dagger-compiler:$dagger_version"

2. Manifest 中 application 注册

    <application
            android:name=".App"
            android:allowBackup="true"
            android:icon="@mipmap/ic_launcher"
            android:label="@string/app_name"
            android:roundIcon="@mipmap/ic_launcher_round"
            android:supportsRtl="true"
            android:theme="@style/AppTheme">