我的编程空间,编程开发者的网络收藏夹
学习永远不晚

移动端开发之Jetpack Hilt技术实现解耦

短信预约 -IT技能 免费直播动态提醒
省份

北京

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团
手机号立即预约

请填写图片验证码后获取短信验证码

看不清楚,换张图片

免费获取短信验证码

移动端开发之Jetpack Hilt技术实现解耦

Hilt是什么

Hilt 是基于 Dagger2 的针对 Android场景定制化 的框架。

这有点像什么? RxAndroid 是 RxJava 的Android平台定制化扩展。Andorid虽然由Java、Kotlin构成,但是它有很多平台的特性,比如它有 Java开发 所不知道的 Context 等。

Dagger框架虽然很出名,在国外也很流行,但是在国内使用其的App少之又少,列举一些缺点:

  • 上手难,众多Android应用框架中,Dagger必定是最难学的那一档;
  • 它就是一个复杂框架,没有针对任何平台,所以对于所有平台来说会难用;
  • 在Android Studio4.0版本以前,无法追踪Dagger的依赖关系(就类比IDE无法通过快捷键知道一个接口有哪些实现类) 开发者不知道为啥要做依赖注入
  • 对于第三点,Android Studio4.1已经支持了该功能,但是4.1有许多Bug,很多开发者都没有升级 。

Hilt的出现解决前两点问题,因为 Hilt 是 Dagger 针对Android平台的场景化框架,比如Dagger需要我们手动声明注入的地方,而Android声明的地方不都在 onCreate()吗,所以Hilt就帮我们做了,除此之外还做了很多事情,这样一来,相较于Dagger,我们能用更少代码、更容易、更轻松的配置依赖注入。

Hilt使用地方

Google认为移动端应用的架构设计,最重要的 Separation of concerns(分离关注点)。上网找解释,其实它就是 模块解耦。下面是Google官方推荐的Android应用架构图:

依赖注入(DI)概念

而 Hilt 是被定义为 依赖注入框架而被发布。什么?又是依赖注入框架?不是之前已经有了一个 Dagger2 了吗?除了 Dagger2, 还有 ButterKnife ,Kotlin甚至还有轻量级的 Koin。

什么是依赖注入?先来看下面代码:

class MyClass {
    val user = User()
}

我们在一个类 MyClass 中 声明了一个变量 user,并初始化-------调用 User 构造函数,创建一个对象。

上面这段代码就产生了一个依赖关系。

我们要先看懂谁依赖了谁?首先 MyClass 是我们的类,User 可以是我们自己写的类,也可以是通过第三方Jar包或SDK里面的类。 在我们写的 MyClass 的代码里面,我们需要一个 User 对象来完成一些任务,所以我们创建了 User 对象,这就说明 MyClass 依赖了 User。对于 MyClass来说,User是外面之物,但是又需要依赖它。

如果上面这个 User,不是由自己创建,而是由外部创建,然后在本类只做赋值工作 ,这个过程就是 依赖注入。

有一个我们非常熟悉的设计模式,就使用了依赖注入的方法—工厂模式:

class UserFactory {
    fun newUser(): User{
        return User()
    }
}
class MyClass {
    val user = UserFactory.newUser()
}

我们的 MyClass 类需要使用 User 类,但是这次没有自己来创建(没有自己new出来),而是交由给 UserFactory 来创建出来,MyClass就做了最后的赋值工作。

对于 MyClass 来说,这就是一次依赖注入,和上面例子相比,把对象创建的过程交由给了别的类。

所以我们通过上面两个例子就能知道依赖注入的本质是什么:借由外部得到对象。依赖注入框架就是这个外部

现在流行的 Dagger2、Koin框架,只是让我们更轻松、更容易的去得到对象。

Dagger的中文翻译是 “刀”,它就像一把刀,插进我们代码中。那相信你也知道 ButterKnife 为什么这么取名了吧。

Hilt使用

导入

在 app 的 build.gradle 中加入:

plugins {
    ...
    id 'kotlin-kapt'
    id 'dagger.hilt.android.plugin'
}
dependencies {
    ...
    implementation 'com.google.dagger:hilt-android:2.28-alpha'
    kapt 'com.google.dagger:hilt-android-compiler:2.28-alpha'
}

在 project的 build.gradle 中加入:

classpath 'com.google.dagger:hilt-android-gradle-plugin:2.28-alpha'

一个简单的例子 Hilt 需要 AndroidManifest 使用带有 @HiltAndroidApp 注解的 Application 类,所以我们的 Application需要这样:

@HiltAndroidApp
class HiltApp : Application() {
   ...
}

然后在 AndroidManifest 文件中声明:

<application
        android:name=".HiltApp"
        ...
    </application>

假如我们要在 MainActivity 中注入一个 User 对象, 我们首先编写一个 User 类,User类有两个属性 name 和 age 。 诶,这个时候有同学就会问了:我通过 @Inject 声明一个User,Hilt就能给我创建一个 User 对象,那这个User对象里面的name和age是啥?答案是:编译会报错,因为我们自己都不知道这两个参数是啥,Hilt怎么可能会知道,所以这两个属性也要通过依赖注入的方式来注入。

为了简化这个问题,我定义一个默认的无参构造函数,反正创建之后,里面的值也是可以修改的嘛。

data class User(var name: String, var age: Int) {
    // 定义一个默认的无参构造函数,并使用 @Inject 注解修饰
    @Inject
    constructor() : this("Rikka", 23)
}

接着我们在 MainActivity 中声明一个 User,通过 @Inject 来修饰,并且MainActivity 需要通过 @AndroidEntryPoint 修饰:

// 1
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    // 2
    @Inject
    lateinit var user: User
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        Log.d(TAG, "user name:${user.name} age:${user.age}")
    }
}

Logcat 打印结果如下:

代码解析:

注释1: 为 MainActivity 修饰 @AndroidEntryPoint,该注解表明 该类为需要进行依赖注入的 Android类,是Dagger针对Android场景化的地方。当我们类中需要进行依赖注入,我们为该类加入这个注解,它会帮助创建一个单独的 Hilt组件。它不能修饰Abstract,它只能修饰:

  • ComponentActivity
  • (Support)Fragment
  • View
  • Service
  • BroadcastReceiver

注释2:我们需要注入一个 User,所以我们给它加一个 @Inject 注解,告诉 Hilt。因为Kotlin的语法问题,这里不得不声明 lateinit(而这里Koin的写法更加优雅),接下来步骤大概是这样的:

  • Hilt 会去找User 这个类的构造函数,以此来创建一个对象
  • Hilt 发现 有两个个构造函数,而无参构造函数被@Inject 声明
  • Hilt 会去调用被@Inject 的构造函数,创建一个User(“Rikka”, 23) 对象
  • 返回这个对象, MainActivity 实现外部帮忙创建 User对象,实现 User 的依赖注入。

Inject 的中文翻译是 “注入、注射”,所以可以形象的认为, @Inject 修饰的变量是被外界通过针筒注入进来的。

  • @Inject 可以修饰
  • 构造函数 Constructors
  • 变量 Fields
  • 方法 Methods

构造函数是最先被注解的,然后再是变量和方法。所以它修饰构造函数和修饰变量,其实是不同的作用。但为了便于理解,我们可以把它看成是一个插眼工具,便于Hilt去寻找要注入的地方。

我们上面的 User 类是无参构造函数,这次假设我们要有参数的呢?其实就是参数也要注入嘛,这就是套娃来的,来看看我们给User新增一个 属性:Clothes:

class Clothes @Inject constructor() {
}
class User @Inject constructor(var clothes: Clothes){
}
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    ...
        Log.d(TAG, "user clothes:${user.clothes}")
}

打印结果:

PS:大家不要太拘泥于有参构造函数的创建,我认为注入的作用是创建出一个对象,这个对象里面的内容可以后续再传入,它更多的体现、或者我们需要注意的是 “分离关注点”

实现接口实例注入

因为接口没有构造函数,所以当我们想要依赖一些接口时,该怎么办。

我们来下面的示例,我们写一个 Profession 接口,代表职业:

interface Profession {
    fun doJob()
}

假设我们有两个实现接口的类:医生类和程序猿类:

class Doctor : Profession{
    override fun doJob() {
        Log.d("Doctor", "doctor do job")
    }
}
class Programmer : Profession{
    override fun doJob() {
        Log.d("Programmer", "programmer do job")
    }
}

这个时候我给 User 类添加一个职业的属性,并希望它能够自动注入:

class User @Inject constructor(var clothes: Clothes){
    @Inject
    lateinit var profession: Profession
}

因为 Profession 是一个接口,它有两个实现类,所以这样 Hilt 并不能知道我们要实例化哪个具体的实现类,所以编译的时候就会报错。

而 Hilt 也解决这种问题,首先我们要在每个实现类上注入构造函数:

class Doctor @Inject constructor() : Profession{
    ...
}
class Programmer @Inject constructor() : Profession{
    ...
}

接着我们需要实现一个和该接口有关的 XXXModule类,它被 @Module 修饰,这个和 Dagger 中的一样,代表它会为接口提供一个创建实例的工厂,同时需要加上 @InstallIn 注解,用来声明它是被安装到哪个组件中,该注解后面会说到。 代码如下:

@Module
@InstallIn(ActivityComponent::class)
abstract class ProfessionModule {  // 1
    // 2
    @Binds
    abstract fun bindDoctor(doctor: Doctor): Profession
}

注释1: 我们写出来的类是一个抽象类,因为我们不需要具体的实现它,而且它没有具体的命名规则,因为我们也不会在代码中直接调用它,但是为了便于理解,我们起名一般叫 接口名 + Module。

注释2: 我们假设该Module提供一个 Doctor 的职业,那我们需要定义一个 抽象方法 来获取一个Doctor类。 并且 该方法需要被 @Binds 注解修饰。这样就能被 Hilt 识别。

这样一来,我们就实现了接口的一个实例化的注入,我们来实验一下,在 User 中去展示它:

class User @Inject constructor(var clothes: Clothes){
    @Inject
    lateinit var profession: Profession
    fun showMyself() {
        profession.doJob()
    }
}
// MainActivity
@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    @Inject
    lateinit var user: User
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        user.showMyself()
    }
}

打印结果为:

可以看到我们的 Doctor 成功的注入了。

OK,我们了解了接口某一个实现类的注入 (Doctor),那假设这个时候,另外一个类需要注入接口的另一个实现类 Programmer,那我们是不是也得按照同样的做法,在 Module类中添加呢?

@Module
@InstallIn(ActivityComponent::class)
abstract class ProfessionModule {
    @Binds
    abstract fun bindDoctor(doctor: Doctor): Profession
    @Binds
    abstract fun bindProgrammer(programmer: Programmer): Profession
}

这个时候发现运行,编译也会报错:

提示我们被绑定多次了。

这是因为 Doctor 和 Programmer 都是相同类型,当他们一起被 Binds 注解,那 Hilt 不知道要去绑定哪一个。

这个时候就需要使用 @Qualifier 注解来帮助我们了,它就是为了这种 相同类型 依赖注入而产生的:

@Qualifier
@Retention(AnnotationRetention.BINARY)
annotation class BindDoctor
@Qualifier
@Retention(AnnotationRetention.BINARY)
annotation class

我们创建了新的注解 BindDoctor 和 BindProgrammer,他们都被 @Qualifier 修饰,表示他们用来作用在同种类型上, @Retention 选择使用 BINARY类型,表明该注解保留到编译后,但无法通过反射来得到,是比较适合的注解。

接下来,我们要将这些注解作用在被 Binds 注解的抽象方法上:

@Module
@InstallIn(ActivityComponent::class)
abstract class ProfessionModule {
    @BindDoctor
    @Binds
    abstract fun bindDoctor(doctor: Doctor): Profession
    @BindProgrammer
    @Binds
    abstract fun bindProgrammer(programmer: Programmer): Profession
}

最后,在 User 中声明使用哪一个类型的注入:

class User @Inject constructor(var clothes: Clothes){
    @BindProgrammer  // 这次注入一个 Programmer
    @Inject
    lateinit var profession: Profession
    fun showMyself() {
        profession.doJob()
    }
}

打印结果如下所示:

这下我们就实现了具体某个实例的注入啦。

实现第三方依赖注入

假设一些类不是由我们自己写的,而是由第三方库导入的。比如 OkHttp ,我们在使用网络请求的时候,需要使用它,为了分离关注点,我们需要对他进行依赖注入。

但是 OkHttp 是我们不能修改的类,所以我们不能在它的构造函数上加入 @Inject, 这个时候该怎么办呢?

Dagger 中也有类似的场景,我们需要 @Providers 来帮助我们。除此之外,我们也需要 @Module 注解来声明一个 Module 类, 基于上面的例子,我们可以把这种 Module 类看成是一个工厂:

@Module
@InstallIn(ApplicationComponent::class)
class NetModule { // 1
    // 2
    @Provides
    fun provideOkHttpClient(): OkHttpClient {
        // 3
        return OkHttpClient.Builder().build()
    }
}

注释1: 声明一个 NetModule,提供网络库相关的组件,并没有和上面例子一样声明为抽象函数,这是因为里面的都有具体的实现方法。

注释2: 编写一个 provideOkHttpClient() 方法,返回一个 OkHttpClient对象。 声明一个 @Providers 注解,表示这个提供的依赖对象,是第三方的类或者系统类,我们因为不能直接更改其构造函数,所以得加上这个注解。

注释3:new 一个对象,并返回。

这样,我们就能在我们代码中直接使用了:

@Inject
    lateinit var okHttpClient:

@Providers 的本质是什么? 第三方类因为其只读性,Hilt不能找到其构造函数,所以需要我们自己手动的创建,创建的方法被 @Providers 修饰, Hilt 找到这个方法,并提供由我们手动创建的对象。

所以 @Providers 的本质,是由我们自己创建对象, Hilt 帮我们注入。

现在大家都不会直接使用 OkHttp,而是使用 Retrofit,所以我们来提供一个 Retrofit 把:

...
    @Provides
    fun provideRetrofit(okHttpClient: OkHttpClient): Retrofit {
        return Retrofit.Builder()
            .addConverterFactory(GsonConverterFactory.create())
            .client(okHttpClient)
            .build()
    }

因为 Retrofit的创建需要依赖一个 OkHttpClient 对象,所以我们需要创建一个,但是我们也可以注入一个,因为我们之前已经有 provideOkHttpClient,所以它就能提供一个实例,我们不用在担心什么了。

Hilt 的内置组件和作用域

@InstallIn 注解

我们之前看到了 @InstallIn 这个注解,它的作用是用来表明 Module 作用的地方,它的参数时 xxxComponent格式,前面xx代表作用域。

因为 Hilt 是Dagger的Android场景化,所以它能作用的地方和我们Android息息相关,有下面几处:

  • Application ->ApplicationComponent
  • ViewModel ->ActivityRetainedComponent
  • Activity ->ActivityComponent
  • Fragment ->FragmentComponent
  • View ->ViewComponent
  • Service ->ServiceComponent
  • View Annotation with@WithFragmentBindings ->ViewWithFragemntComponent

除了最后一个,别的作用域还是挺常见的。他们都要通过 @InstallIn 注入。

比如我们ProfessionModule是声明成 @InstallIn(ActivityComponent::class),这就说明只有在 Activity 的代码中可以使用它,而在 Service 中是不能使用的。 而 NetModule 则是声明成 InstallIn(ApplicationComponent::class)的,这说明在全局都可以使用它提供的 OkHttpClient 和 Retrofit 对象。

使注入对象单例

像 Retrofit 、 OkHttpClient 这样的全局都需要使用到的对象,我们希望它的作用域是全局,并且单例的。

但是 Hilt 提供的 @Inject 对象并不是单例的,每次 注入时都会重新生成一个新的实例,这就说明,假设我们要使用 Retrofit 来做网络请求, @Providers 每次提供的都是不一样的,这样对性能来说很不友好,而且不符合常规的逻辑设定。

按照以往,我们可以通过给 NetModule 声明一个 @Singleton 注解,来让这个类实现单例,来解决这个问题。

Hilt 也有自己的解决方案,那就是使用 @xxxScope 注解,它和上面的 xxxComponent所对应,表示 在这个作用域内单例,来看看对应关系:

  • Application ->ApplicationComponent ->@Singleton
  • ViewModel ->ActivityRetainedComponent ->@ActivityRetainedScoped
  • Activity ->ActivityComponent ->@ActivityScoped
  • Fragment ->FragmentComponent ->@FragmentScoped
  • View ->ViewComponent ->@ViewScoped
  • Service ->ServiceComponent ->@ServiceScoped
  • View Annotation with@WithFragmentBindings ->ViewWithFragemntComponent ->@ViewScoped

使用 @xxScoped 来替代 @InstallIn(xxxComponent::class) 声明组件为单例。

因为 Application 是作用于全局,所以它的注解是 @Singleton,比较好理解。

作用域的包含关系

作用域也有自己的包含关系,比如被 @ActivityScoped声明的组件,可以在 Fragment 或者 View 中使用,他们的具体包含关系如下图所示:

Hilt 预置的 Qualifier

我介绍过 Hilt 是 Dagger针对Android的场景化,所以它低层做了很多事情,使得在Android上更好的使用。除了上面介绍过的那些注解外,还有很多别的东西,可以让我们去探索,同时也了解了Dagger本身。

Context 上下文是Android 独特的存在,它代表着 Application、Activity、Service的一些fwk层的东西。

而我们的代码中经常会需要 Context 来创建一些东西:

class A @Inject constructor(context: Context) {
   ...
}

但是我们知道,它是系统类,我们无法注入 Context。那我们可以通过使用 @Providers 来创建吗?

@Providers
fun provideContext() {
   ???
}

很明显,Context 是由AMS来创建的,我们无法直接创建一个上下文出来。这个问题该如何解决呢?

答案是:我们不用解决,Hilt 为我们提供了它自己预置的注解 @ApplicationContext 和 @ActivityContext,我们直接使用,Hilt会帮我们注入上下文。

class A @Inject constructor(@ApplicaitonContext context: Context)

而现在没有 ServiceContext,可能是用的比较少吧?

@ApplicationContext 提供的类型是 Application, 而不是我们自己的 App 自定义的 Application,加入我们要使用自己的该怎么办呢?答案是也很简单:

@Providers
fun provideApplicaiton(application: Application): MyApplication {
    return  applicaiton as MyApplication
}

直接在 Module 中提供一个,并强转就 OK啦。

注意

ApplicationContext 的作用域是全局, 所以它修饰的类的作用只能是 @InstallIn(Applicaiton) 或 @Singleton,其他的也同理。

之前没有用过 Dagger,因为项目不需要,且难学,问题多。 Hilt 出来之后解决了大部分的痛点,再不上车属实就有点说不过去了。

Hilt 相较与 Dagger,肯定是更好用,更适合Android来使用。 它和 Koin的比较,只是性能上的差异,网上大部分的文章都认为 Hilt 性能更优,但是代码量更多,在大的项目使用 Hilt 会更好,而小的项目两者差别不会太大。具体还请开发者自己研究。

Hilt 作用是 提供依赖注入,帮助程序分离关注点,帮助搭建低耦合高内聚的框架,学习它,有利于我们学习 Android应用架构 方面的技能。

到此这篇关于移动端开发之Jetpack Hilt技术实现解耦的文章就介绍到这了,更多相关Jetpack Hilt解耦内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网!

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

移动端开发之Jetpack Hilt技术实现解耦

下载Word文档到电脑,方便收藏和打印~

下载Word文档

猜你喜欢

移动端开发之Jetpack Hilt技术实现解耦

Hilt的出现解决前两点问题,因为Hilt是Dagger针对Android平台的场景化框架,比如Dagger需要我们手动声明注入的地方,而Android声明的地方不都在onCreate()吗,所以Hilt就帮我们做了,除此之外还做了很多事情
2023-02-17

JSBridge框架如何解决通信问题以及实现移动端跨平台开发

这期内容当中小编将会给大家带来有关JSBridge框架如何解决通信问题以及实现移动端跨平台开发,文章内容丰富且以专业的角度为大家分析和叙述,阅读完这篇文章希望大家可以有所收获。一、跨平台开发是趋势目前主流的移动端平台主要是Android和i
2023-06-05

编程热搜

  • Android:VolumeShaper
    VolumeShaper(支持版本改一下,minsdkversion:26,android8.0(api26)进一步学习对声音的编辑,可以让音频的声音有变化的播放 VolumeShaper.Configuration的三个参数 durati
    Android:VolumeShaper
  • Android崩溃异常捕获方法
    开发中最让人头疼的是应用突然爆炸,然后跳回到桌面。而且我们常常不知道这种状况会何时出现,在应用调试阶段还好,还可以通过调试工具的日志查看错误出现在哪里。但平时使用的时候给你闹崩溃,那你就欲哭无泪了。 那么今天主要讲一下如何去捕捉系统出现的U
    Android崩溃异常捕获方法
  • android开发教程之获取power_profile.xml文件的方法(android运行时能耗值)
    系统的设置–>电池–>使用情况中,统计的能耗的使用情况也是以power_profile.xml的value作为基础参数的1、我的手机中power_profile.xml的内容: HTC t328w代码如下:
    android开发教程之获取power_profile.xml文件的方法(android运行时能耗值)
  • Android SQLite数据库基本操作方法
    程序的最主要的功能在于对数据进行操作,通过对数据进行操作来实现某个功能。而数据库就是很重要的一个方面的,Android中内置了小巧轻便,功能却很强的一个数据库–SQLite数据库。那么就来看一下在Android程序中怎么去操作SQLite数
    Android SQLite数据库基本操作方法
  • ubuntu21.04怎么创建桌面快捷图标?ubuntu软件放到桌面的技巧
    工作的时候为了方便直接打开编辑文件,一些常用的软件或者文件我们会放在桌面,但是在ubuntu20.04下直接直接拖拽文件到桌面根本没有效果,在进入桌面后发现软件列表中的软件只能收藏到面板,无法复制到桌面使用,不知道为什么会这样,似乎并不是很
    ubuntu21.04怎么创建桌面快捷图标?ubuntu软件放到桌面的技巧
  • android获取当前手机号示例程序
    代码如下: public String getLocalNumber() { TelephonyManager tManager =
    android获取当前手机号示例程序
  • Android音视频开发(三)TextureView
    简介 TextureView与SurfaceView类似,可用于显示视频或OpenGL场景。 与SurfaceView的区别 SurfaceView不能使用变换和缩放等操作,不能叠加(Overlay)两个SurfaceView。 Textu
    Android音视频开发(三)TextureView
  • android获取屏幕高度和宽度的实现方法
    本文实例讲述了android获取屏幕高度和宽度的实现方法。分享给大家供大家参考。具体分析如下: 我们需要获取Android手机或Pad的屏幕的物理尺寸,以便于界面的设计或是其他功能的实现。下面就介绍讲一讲如何获取屏幕的物理尺寸 下面的代码即
    android获取屏幕高度和宽度的实现方法
  • Android自定义popupwindow实例代码
    先来看看效果图:一、布局
  • Android第一次实验
    一、实验原理 1.1实验目标 编程实现用户名与密码的存储与调用。 1.2实验要求 设计用户登录界面、登录成功界面、用户注册界面,用户注册时,将其用户名、密码保存到SharedPreference中,登录时输入用户名、密码,读取SharedP
    Android第一次实验

目录