【译】使用Kotlin从零开始写一个现代Android 项目-Part4，系列终结篇！

时间  2020-08-29
标签 使用 kotlin 开始 一个 现代 android 项目 part4 系列 终结 栏目 Android 繁體版
原文   原文链接

这是本系列的第四篇文章，尚未看过前面三篇的读者能够先看看：java

【译】使用Kotlin从零开始写一个现代Android 项目-Part1android

【译】使用Kotlin从零开始写一个现代Android 项目-Part2git

【译】使用Kotlin从零开始写一个现代Android 项目-Part3设计模式

正文开始！app

什么是依赖注入

让咱们先看看GitRepoRepository类：ide

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。函数

依赖注入是一个很是简单的概念：你须要什么，其余人就给你提供什么。post

让咱们看看，咱们在哪里构造GitRepoRepository类（Mac上用cmd + B，Windows上用alt + B）：测试

如你所见，GitRepoRepository类在MainViewModel中被构造，NetManager也是在这儿被构造，是否也应该将它们注入ViewModel？是的。应该将GitRepoRepository实例提供给ViewModel，由于GitRepoRepository能够在其余ViewModel中使用。ui

另外一方面，咱们肯定整个应用程序仅应建立一个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将仅具备提供应用程序上下文的函数：

@Module
class 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.Builder
abstract 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。

@Module
internal abstract class MainActivityModule {

    @ContributesAndroidInjector()
    internal abstract fun mainActivity(): MainActivity

}

@ContributesAndroidInjector注解可帮助Dagger链接所需的内容，以便咱们能够将实例注入指定的Activity中。

若是返回到咱们的Activity，能够看到咱们使用Injection类注入了MainViewModelProvider。所以，咱们须要在MainActivityModule中提供provider方法，该方法将提供MainViewModelProvider：

@Module
internal 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的构造函数

@Singleton
class 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)
@MapKey
annotation 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:

@Module
internal 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模块便可：

@Module
internal 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篇，建议你们看完，你会有收获的！

以上就是本文的所有内容，感谢你的阅读！

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程