这是本系列的第四篇文章，还没有看过后面三篇的读者能够先看看：
【译】应用Kotlin从零开始写一个古代Android 我的项目-Part1
【译】应用Kotlin从零开始写一个古代Android 我的项目-Part2
【译】应用Kotlin从零开始写一个古代Android 我的项目-Part3
注释开始！
什么是依赖注入
让咱们先看看GitRepoRepository类：
class GitRepoRepository(private val netManager: NetManager) { private val localDataSource = GitRepoLocalDataSource() private val remoteDataSource = GitRepoRemoteDataSource() fun getRepositories(): Observable<ArrayList<Repository>> { ... }}咱们能够说GitRepoRepository依赖三个对象，别离是netManager、localDataSource 和remoteDataSource。通过构造函数提供netManager时，数据源在GitRepoRepository中被初始化。换句话说，咱们将netManager注入到GitRepoRepository。
依赖注入是一个非常简单的概念：你须要什么，其他人就给你提供什么。
让咱们看看，咱们在哪里结构GitRepoRepository类（Mac上用cmd + B，Windows上用alt + B）：
如你所见，GitRepoRepository类在MainViewModel中被结构，NetManager也是在这儿被结构，是否也应该将它们注入ViewModel？是的。应该将GitRepoRepository实例提供给ViewModel，因为GitRepoRepository能够在其余ViewModel中应用。
另一方面，咱们确定整个应用程序仅应创立一个NetManager实例。让咱们通过构造函数提供它。咱们冀望有这样的货色：
class MainViewModel(private var gitRepoRepository: GitRepoRepository) : ViewModel() { ...}请记住，咱们没有在MainActivity中创立MainViewModel。咱们从ViewModelProviders来取得它：
class MainActivity : AppCompatActivity(), RepositoryRecyclerViewAdapter.OnItemClickListener { ... override fun onCreate(savedInstanceState: Bundle?) { ... val viewModel = ViewModelProviders.of(this).get(MainViewModel::class.java) ... } ...}如前所述，ViewModelProvider将创立新的ViewModel或返回现有的ViewModel。当初，咱们必须将GitRepoRepository作为参数。该怎么做？
咱们须要为MainViewModel设置非凡的工厂(Factory)类，因为咱们不能应用规范的类：
class MainViewModelFactory(private val repository: GitRepoRepository) : ViewModelProvider.Factory { override fun <T : ViewModel?> create(modelClass: Class<T>): T { if (modelClass.isAssignableFrom(MainViewModel::class.java)) { return MainViewModel(repository) as T } throw IllegalArgumentException("Unknown ViewModel Class") }}因而，当初咱们能够在结构它时，设置参数，
class MainActivity : AppCompatActivity(), RepositoryRecyclerViewAdapter.OnItemClickListener { .... override fun onCreate(savedInstanceState: Bundle?) { ... val repository = GitRepoRepository(NetManager(applicationContext)) val mainViewModelFactory = MainViewModelFactory(repository) val viewModel = ViewModelProviders.of(this, mainViewModelFactory) .get(MainViewModel::class.java) ... } ...}等等！咱们还是没有解决问题，咱们真的应该在MainActivity中创立一个MainViewModelFactory实例吗？不因该的，这里应该应用依赖注入来解决。
让咱们创立一个Injection类，它具备将提供所需实例的办法：
object Injection { fun provideMainViewModelFactory(context: Context) : MainViewModelFactory{ val netManager = NetManager(context) val repository = GitRepoRepository(netManager) return MainViewModelFactory(repository) }}当初，咱们能够将其从此类注入MainActivity.kt：
class MainActivity : AppCompatActivity(), RepositoryRecyclerViewAdapter.OnItemClickListener { private lateinit var mainViewModelFactory: MainViewModelFactory override fun onCreate(savedInstanceState: Bundle?) { ... mainViewModelFactory = Injection.provideMainViewModelFactory(applicationContext) val viewModel = ViewModelProviders.of(this, mainViewModelFactory) .get(MainViewModel::class.java) ... } ...}因而，当初咱们的Activity不晓得来自应用程序数据层的repositories。这样的代码组织对咱们有很大帮忙，尤其是在测试应用程序方面。这样，咱们将UI逻辑与业务逻辑离开。
咱们能够在Injection.kt中利用更多的依赖注入概念：
object Injection { private fun provideNetManager(context: Context) : NetManager { return NetManager(context) } private fun gitRepoRepository(netManager: NetManager) :GitRepoRepository { return GitRepoRepository(netManager) } fun provideMainViewModelFactory(context: Context): MainViewModelFactory { val netManager = provideNetManager(context) val repository = gitRepoRepository(netManager) return MainViewModelFactory(repository) } }当初，每个类都有获取它们实例的办法了，如果你认真看，你会发现，所有的这些办法在咱们调用它们时，都会返回一个新的实例，真的应该这样？每当咱们某个Repository类中须要时，都要创立NetManager的新实例？当然不是，每个应用程序只须要一个NetManager实例。能够说NetManager应该是单例。
在软件工程中，单例模式是一种将类的实例化限度为一个对象的软件设计模式。
让咱们实现它：
object Injection { private var NET_MANAGER: NetManager? = null private fun provideNetManager(context: Context): NetManager { if (NET_MANAGER == null) { NET_MANAGER = NetManager(context) } return NET_MANAGER!! } private fun gitRepoRepository(netManager: NetManager): GitRepoRepository { return GitRepoRepository(netManager) } fun provideMainViewModelFactory(context: Context): MainViewModelFactory { val netManager = provideNetManager(context) val repository = gitRepoRepository(netManager) return MainViewModelFactory(repository) }}这样，咱们确保每个应用程序只有一个实例。换句话说，咱们能够说NetManager实例具备Application同样的生命周期范畴。
让咱们看看依赖图：
为什么咱们须要Dagger？
如果看一下下面的注入，您会发现，如果图中有很多依赖项，那么咱们将须要做大量工作。 Dagger帮忙咱们以简略的形式治理依赖项及其范畴。
让咱们先引入dagger:
...dependencies { ... implementation "com.google.dagger:dagger:2.14.1" implementation "com.google.dagger:dagger-android:2.14.1" implementation "com.google.dagger:dagger-android-support:2.14.1" kapt "com.google.dagger:dagger-compiler:2.14.1" kapt "com.google.dagger:dagger-android-processor:2.14.1" ...}要应用dragger,咱们须要新建一个Application继承自DaggerApplication类，咱们创立一个DaggerApplication:
class ModernApplication : DaggerApplication(){ override fun applicationInjector(): AndroidInjector<out DaggerApplication> { TODO("not implemented") }}在继承DaggerApplication（）时，它须要实现applicationInjector（）办法，该办法应返回AndroidInjector的实现。稍后我将介绍AndroidInjector。
不要忘了在AndroidManifest.xml注册application:
<?xml version="1.0" encoding="utf-8"?><manifest xmlns:android="http://schemas.android.com/apk/res/android" package="me.mladenrakonjac.modernandroidapp"> ... <application android:name=".ModernApplication" ...> ... </application></manifest>首先，创立AppModule,Modules是具备@Provides注解性能的类。咱们说这些办法是提供者，因为它们提供了实例。要将某个类作为模块，咱们须要应用@Module注解对该类进行注解。这些注解可帮忙Dagger制作和验证图形。咱们的AppModule将仅具备提供应用程序上下文的函数：
@Moduleclass AppModule{ @Provides fun providesContext(application: ModernApplication): Context { return application.applicationContext }}当初，咱们创立一个component:
@Singleton@Component( modules = [AndroidSupportInjectionModule::class, AppModule::class])interface AppComponent : AndroidInjector<ModernApplication> { @Component.Builder abstract class Builder : AndroidInjector.Builder<ModernApplication>()}Component是一个接口，咱们在其中指定应从哪些模块中将实例注入哪些类中。这个例子中，咱们指定AppModule和AndroidSupportInjectionModule。
AndroidSupportInjectionModule是可帮忙咱们将实例注入Android生态系统类的模块，这些类包含 Activity，Fragment，Service，BroadcastReceivers或ContentProviders。
因为咱们要应用咱们的组件来注入这些类，因而AppComponent必须继承AndroidInjector <T>。对于T，咱们应用ModernApplication类。如果关上AndroidInjector接口，则能够看到：
abstract class Builder<T> implements AndroidInjector.Factory<T> { @Override public final AndroidInjector<T> create(T instance) { ... } public abstract void seedInstance(T instance); ... }}Builder有两个办法：create(T instance) 用于创立AndroidInjector，而seedInsance(T instance) 办法则用于提供实例。
在咱们的例子中，咱们将创立具备ModernApplication实例的AndroidInjector，并将在须要的中央提供该实例。
@Component.Builderabstract class Builder : AndroidInjector.Builder<ModernApplication>()对于咱们的AppComponent，总结一下：
- 咱们领有AppComponent，它是继承与AndroidInjector的应用程序的次要组件
- 当咱们要构建Component时，咱们将须要应用ModernApplication类的实例作为参数。
- 将以AppComponent中应用的模块模式，向所有其余
@Provides办法提供ModernApplication的实例。例如，将向AppModule中的providerContext（application：ModernApplication）办法提供ModernApplication的实例。
当初，咱们编译一下我的项目
当构建完结，Dragger将主动生成一些新的类，对于AppComponent,Dragger将会生成一个DaggerAppComponent类。
让咱们回到ModernApplication并创立应用程序的次要组件。创立的组件应在applicationInjector（）办法中返回。
class ModernApplication : DaggerApplication(){ override fun applicationInjector(): AndroidInjector<out DaggerApplication> { return DaggerAppComponent.builder().create(this) }当初，咱们实现了Dagger所需的标准配置。
当咱们想将实例注入MainActivity类时，咱们须要创立MainActivityModule。
@Moduleinternal abstract class MainActivityModule { @ContributesAndroidInjector() internal abstract fun mainActivity(): MainActivity}@ContributesAndroidInjector注解可帮忙Dagger连贯所需的内容，以便咱们能够将实例注入指定的Activity中。
如果返回到咱们的Activity，能够看到咱们应用Injection类注入了MainViewModelProvider。因而，咱们须要在MainActivityModule中提供provider办法，该办法将提供MainViewModelProvider：
@Moduleinternal abstract class MainActivityModule { @Module companion object { @JvmStatic @Provides internal fun providesMainViewModelFactory(gitRepoRepository: GitRepoRepository) : MainViewModelFactory { return MainViewModelFactory(gitRepoRepository) } } @ContributesAndroidInjector() internal abstract fun mainActivity(): MainActivity}然而，谁将提供GitRepoRepository给providesMainViewModelFactoty办法呢？
有两个抉择：咱们能够为其创立provider办法并返回新实例，或者能够应用@Inject注解它的构造函数。
让咱们回到咱们的GitRepoRepository并应用@Inject注解来标注其构造函数：
class GitRepoRepository @Inject constructor(var netManager: NetManager) { ...}因为GitRepoRepository须要NetManager,因而，同样标注NetManager的构造函数
@Singletonclass NetManager @Inject constructor(var applicationContext: Context) { ...}咱们应用@Singleton注解设置NetManager为单例。另外，NetManager须要applicationContext。 AppModule中有一个办法来提供它。
不要遗记将MainActivityModule增加到AppComponent.kt中的模块列表中：
@Component( modules = [AndroidSupportInjectionModule::class, AppModule::class, MainActivityModule::class])interface AppComponent : AndroidInjector<ModernApplication> { @Component.Builder abstract class Builder : AndroidInjector.Builder<ModernApplication>()}最初，咱们须要将其注入到咱们的MainActivity中。为了使Dagger在那里工作，咱们的MainActivity须要继承DaggerAppCompatActivity。
class MainActivity : DaggerAppCompatActivity(), RepositoryRecyclerViewAdapter.OnItemClickListener { ... @Inject lateinit var mainViewModelFactory: MainViewModelFactory override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) val viewModel = ViewModelProviders.of(this, mainViewModelFactory) .get(MainViewModel::class.java) ... } ...}要注入MainViewModelFactory实例，咱们须要应用@Inject注解。
重要阐明： mainViewModelFactory变量必须是公共的。
到这儿就实现了！
不再须要从“注入”类进行注入：
mainViewModelFactory = Injection.provideMainViewModelFactory(applicationContext)实际上，咱们能够删除Injection类了，因为咱们当初正在应用Dagger了。
一步步回头看看
- 咱们想把
MainViewModelFactory注入MainActiivty - 为了使Dragger能在MainActivity中失常工作，MainActivity须要继承自DaggerAppCompatActivity
- 咱们须要应用
@Inject注解对mainViewModelFactory进行标注 - Dagger搜寻带有
@ContributesAndroidInjector注解的办法的模块，该办法返回MainActivity。 - Dagger搜寻返回MainViewModelFactory实例的provider，或带
@Inject注解的构造函数。 provideMainViewModelFactory()返回实例，然而为了创立它，须要GitRepoRepository实例- Dagger搜寻provider或
@Inject带注解的构造函数，该构造函数返回GitRepoRepository实例。 - GitRepoRepository类具备带
@Inject注解的构造函数。然而该构造函数须要NetManager实例 - Dagger搜寻返回NetManager实例的provider或带
@Inject正文的构造函数。 - Dagger搜寻返回Application Context实例的provider。
- AppModule具备返回application context 的provider办法。然而该构造函数须要ModernApplication实例。
- AndroidInjector具备provider。
就是这样！
有一种更好的自动化办法来提供ViewModelFactory
问题：对于每个具备参数的ViewModel，咱们都须要创立ViewModelFactory类。在Chris Banes的Tivi应用程序源代码中，我发现了一种十分好的主动办法。
创立ViewModelKey.kt :
@Target(AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER)@Retention(AnnotationRetention.RUNTIME)@MapKeyannotation class ViewModelKey(val value: KClass<out ViewModel>)而后增加一个DaggerAwareViewModelFactory类：
class DaggerAwareViewModelFactory @Inject constructor( private val creators: @JvmSuppressWildcards Map<Class<out ViewModel>, Provider<ViewModel>>) : ViewModelProvider.Factory { override fun <T : ViewModel> create(modelClass: Class<T>): T { var creator: Provider<out ViewModel>? = creators[modelClass] if (creator == null) { for ((key, value) in creators) { if (modelClass.isAssignableFrom(key)) { creator = value break } } } if (creator == null) { throw IllegalArgumentException("unknown model class " + modelClass) } try { @Suppress("UNCHECKED_CAST") return creator.get() as T } catch (e: Exception) { throw RuntimeException(e) } }}创立ViewModelBuilder module:
@Moduleinternal abstract class ViewModelBuilder { @Binds internal abstract fun bindViewModelFactory(factory: DaggerAwareViewModelFactory): ViewModelProvider.Factory}增加ViewModelBuilder到AppComponent:
@Singleton@Component( modules = [AndroidSupportInjectionModule::class, AppModule::class, ViewModelBuilder::class, MainActivityModule::class])interface AppComponent : AndroidInjector<ModernApplication> { @Component.Builder abstract class Builder : AndroidInjector.Builder<ModernApplication>()}MainViewModel类增加@Injec:
class MainViewModel @Inject constructor(var gitRepoRepository: GitRepoRepository) : ViewModel() { ...}从当初开始，咱们只须要将其绑定到Activity模块即可：
@Moduleinternal abstract class MainActivityModule { @ContributesAndroidInjector internal abstract fun mainActivity(): MainActivity @Binds @IntoMap @ViewModelKey(MainViewModel::class) abstract fun bindMainViewModel(viewModel: MainViewModel): ViewModel}不须要MainViewModelFactory provider 。实际上，基本不须要MainViewModelFactory.kt，因而能够将其删除。
最初，在MainActivity.kt中对其进行更改，以便咱们应用ViewModel.Factory类型而不是MainViewModelFactory：
class MainActivity : DaggerAppCompatActivity(), RepositoryRecyclerViewAdapter.OnItemClickListener { @Inject lateinit var viewModelFactory: ViewModelProvider.Factory override fun onCreate(savedInstanceState: Bundle?) { ... val viewModel = ViewModelProviders.of(this, viewModelFactory) .get(MainViewModel::class.java) ... } ...}感激Chris Banes 这个神奇的解决方案！
译者注：原本，这个系列还有一篇文章，讲Retrofit + Room的使用，不过如同原作者断更了????????????，因而本篇就将是最初一篇了，本系列总共4篇，倡议大家看完，你会有播种的！以上就是本文的全部内容，感激你的浏览！