关于android:译使用Kotlin从零开始写一个现代Android-项目Part4系列终结篇

44次阅读

共计 11926 个字符，预计需要花费 30 分钟才能阅读完成。

这是本系列的第四篇文章，还没有看过后面三篇的读者能够先看看：

【译】应用 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 将仅具备提供应用程序上下文的函数：

@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 篇，倡议大家看完，你会有播种的！

以上就是本文的全部内容，感激你的浏览！

正文完
android
发表至： android
2020-08-28
 0
关于android:Android-应用外悬浮窗
关于android:HMS-Core-Discovery第16期回顾与虎墩一起玩转AI新声态
关于android:XPage系列｜这次升级后终于是全自动化注册了
关于android:洞穿性能测试痛点PerfDog以提升应用和游戏的品质为使命