只给个泛型，如何自动初始化ViewModel与ViewBinding？这几种方案值得了解

最新推荐文章于 2024-07-08 13:02:04 发布
最新推荐文章于 2024-07-08 13:02:04 发布
阅读量170 收藏
点赞数
分类专栏： mvvm jetpack 文章标签： python java 开发语言
原文链接：https://juejin.cn/post/7357546247849197606
版权
jetpack 同时被 2 个专栏收录
190 篇文章 15 订阅
订阅专栏
mvvm
40 篇文章 3 订阅
订阅专栏

自动完成VM和VB初始化的几种方案

前言

例如我们的 Activity/Fragment 内部的对象初始化，如果是常规的通用的对象初始化，我们当然可以在基类中就定义了。但是对于一些类似ViewModel，ViewBindig之类的对象初始化，我们需要明确知道是哪一个类型才能初始化的怎么办？

类似我们在具体的页面定义泛型：

class ProfileActivity : BaseActivity<ProfileViewModel, ActivityProfileBinding>() {}

但是我不想在具体的页面去写这些手动的调用：

ViewModelProvider(owner).get(%T::class.java)
%T.inflate(layoutInflater)

或者基类抽象实现:

public abstract class BaseActivity<VM extends ViewModel, VB extends ViewBinding> extends AppCompatActivity {
    protected VM viewModel;
    protected VB binding;

    protected abstract Class<VM> getViewModelClass();
    protected abstract VB inflateViewBinding(LayoutInflater inflater);
}

具体还是让子类去实现：

public class ProfileActivity extends BaseActivity<ProfileViewModel, ActivityProfileBinding> {

    @Override
    protected Class<ProfileViewModel> getViewModelClass() {
        return ProfileViewModel.class;
    }

    @Override
    protected ActivityProfileBinding inflateViewBinding(LayoutInflater inflater) {
        return ActivityProfileBinding.inflate(inflater);
    }

    // ...
}

可以是可以，但是好麻烦哦，我想只给个泛型，让基类去自动帮我初始化，能不能直接在基类中：

ViewModelProvider(this).get(VM::class.java)
VB.inflate(inflater)

这样会报错的，因为运行期间泛型会被擦除也无法实例化对应的对象。

那...可如何是好呐。

其实我们想要在基类完成泛型的实例化，我们目前是有两种思路，一种是反射获取到泛型的实例，一种是通过编译器代码生成完成对象的实例创建，其中又分为APT代码生成和ASM字节码插桩两个小分支。

一、使用反射

平常我们的封装就算再简单，我们也需要传入 ViewMiel 的 class 对象，或者 DataBinding::inflate 对象。

abstract class BaseVDBActivity<VM : ViewModel,VB : ViewBinding>(
   private val vmClass: Class<VM>， private val vb: (LayoutInflater) -> VB,
) : AppCompatActivity() {
}

class MainActivity : BaseVDBActivity<ActivityMainBinding, MainViewModel>(
    ActivityMainBinding::inflate,
    MainViewModel::class.java
){}

类似于上面这种写法，定义了泛型对象，在通过构造传入对应的Class对象和函数对象。我们才能在基类中正常的初始化 ViewModel 和 ViewBinding ，这是很好的封装方式，性能也好，没用到反射，其实已经很优秀了，你绝对可以使用这种方式封装。

本文我们也是从懒人的角度看，除了这种方式之外我们还能用哪些更“懒”的方式来实现自动的初始化。

这里就得提到反射的作用了。

abstract class BaseActivity<VM : ViewModel, VB : ViewBinding> : AppCompatActivity() {

    protected lateinit var viewModel: VM
    protected lateinit var binding: VB

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        viewModel = getViewModelInstance()
        binding = getViewBindingInstance(layoutInflater)
        setContentView(binding.root)
    }

    private fun getViewModelInstance(): VM {
        val superClass = javaClass.genericSuperclass as ParameterizedType
        val vmClass = (superClass.actualTypeArguments[0] as Class<VM>).kotlin
        return ViewModelProvider(this, ViewModelProvider.NewInstanceFactory()).get(vmClass.java)
    }

 
    private fun getViewBindingInstance(inflater: LayoutInflater): VB {
        val superClass = javaClass.genericSuperclass as ParameterizedType
        val vbClass = superClass.actualTypeArguments[1] as Class<VB>
        val method = vbClass.getMethod("inflate", LayoutInflater::class.java)
        return method.invoke(null, inflater) as VB
    }
}

我们指定第一个泛型为ViewModel，第二个泛型为ViewBinding，那么我们就能找到当前类的泛型对象的class，更进一步我们甚至能通过反射调用它的方法得到 VB 的实例对象。

此时我们就能达到文章开始的效果：

class ProfileActivity : BaseActivity<ProfileViewModel, ActivityProfileBinding>() {}

反射的方案有没有缺点？

反射太慢了可能有些人会脱口而出，其实反射真的慢吗？这不属于本文探讨的范围，随着越多越多的一些对比评测大家其实也明白过来，反射其实并没有比正常调用慢多少。

虽然反射需要在运行时动态解析类的元数据，执行安全权限检查，以及进行方法调用，虽然反射调用时，JVM会进行额外的安全检查，增加了性能开销，但是如果调用次数很少基本和正常方法调用区别不大，特别是对于 Android 开发的场景，特别还是这种只调用一次的场景，其实运行速度差别真的不大。

混淆，这才是大问题，反射代码在混淆过程中我们需要额外的注意，因为类和成员的名称可能会被改变。如果不正确配置混淆规则，可能导致在运行时无法正确地通过名称找到相应的类、方法或字段，引发异常。

例如我们混淆打包之后，如果通过反射，必须保证反射的直接对象需要保存不被混淆。

我们注释掉混淆规则

# 保持ViewModel和ViewBinding不混淆，否则无法反射自动创建
-keep class * implements androidx.viewbinding.ViewBinding { *; }
-keep class * extends androidx.lifecycle.ViewModel { *; }

然后反编译我们的apk很容易的就能找到为混淆的类:

图片

类型安全与可读性 反射调用减少了编译时类型检查的机会，增加了运行时错误的风险。例如，如果通过反射错误地调用了方法或访问了字段，可能会在运行时引发ClassCastException等异常，并且由于是硬编码不好调试不说，如果被反射方改变了方法那么会增加错误的风险。

二、使用APT代码生成

其实相比ASM的字节码插桩，使用APT生成代码相对简单很多，我们可以生成对应的 ViewBinding 和 ViewModel 的初始化对象。

如果你不会 APT 的代码生成，那么跟着过一遍就回了，下面的代码会给出详细的注释。

我们先定义对应的注解：

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.SOURCE)
annotation class AutoInject

我们添加 auto-service 和 kotlinpoet 代码生成器的依赖

implementation 'com.squareup:kotlinpoet:1.4.0'
compileOnly "com.google.auto.service:auto-service:1.0.1"
kapt 'com.google.auto.service:auto-service:1.0.1'

auto-service是一种用于生成APT（Annotation Processing Tool）代码的方案之一。APT是Java编译器提供的一个工具，用于在编译期间处理注解，并生成相应的代码。

auto-service是一个Google开源的库，它简化了使用APT生成代码的过程。它提供了一个注解@AutoService和一个抽象类AutoService，通过在实现类上添加@AutoService注解，并继承AutoService抽象类，可以自动生成用于注册该实现类的META-INF/services文件。

在你的代码中，你使用了auto-service库，并使用@AutoService注解和AutoService抽象类来自动生成META-INF/services文件，用于注册你的注解处理器。这样，当你的项目构建时，编译器会自动调用APT并生成相应的代码。

kotlinpoet 是一个用于生成 Kotlin 代码的库，由 Square 公司开发。KotlinPoet 通过提供一个强大的 DSL（领域特定语言）来帮助开发者编程地构建 Kotlin 源文件。这个库特别适合那些需要自动生成 Kotlin 代码的场景，比如编写编译时注解处理器（Annotation Processors）或是其他需要生成 Kotlin 代码的工具。

两者经常被一起使用，尤其是在创建编译时注解处理器时，当你编写一个注解处理器来处理注解时，可能会用到 KotlinPoet 来生成一些 Kotlin 代码，同时用 AutoService 来注册注解处理器，使得在编译时可以被 javac 工具自动发现和调用。这样可以大大简化注解处理器的开发过程，使得开发者更专注于处理注解的逻辑，而不是服务文件的细节。

本场景的 Processor 定义如下：

@Suppress("unused")
@AutoService(Processor::class)
@SupportedSourceVersion(SourceVersion.RELEASE_8)
@SupportedOptions(AutoInjectAnnotationProcessor.KAPT_KOTLIN_GENERATED_OPTION_NAME)
class AutoInjectAnnotationProcessor : AbstractProcessor() {

    override fun getSupportedAnnotationTypes(): Set<String> = setOf(
        AutoInject::class.java.canonicalName,
    )

    override fun process(annotations: MutableSet<out TypeElement>?, roundEnv: RoundEnvironment): Boolean {
        roundEnv.getElementsAnnotatedWith(AutoInject::class.java).forEach { element ->
            if (element.kind != ElementKind.CLASS) {
                processingEnv.messager.printMessage(Diagnostic.Kind.ERROR, "@AutoInject can only be applied to classes.")
                return true
            }

            val typeElement = element as TypeElement
            generateCodeForViewModel(element, typeElement)
        }

        return true
    }

    private fun generateCodeForViewModel(element: Element, typeElement: TypeElement) {
        val className = element.simpleName.toString()
        val pack = processingEnv.elementUtils.getPackageOf(element).toString()
        val fileName = "${className}ViewModelInit"
        val superClassType = (element as TypeElement).superclass //泛型指定在父类上
        val typeArguments = (superClassType as? DeclaredType)?.typeArguments ?: emptyList()  //获取到所有的泛型

        if (typeArguments.isEmpty()) return // 如果没有泛型参数，则不生成代码

        val viewModelName = typeArguments[0].asTypeName().toString() // 第一个泛型参数总是用于ViewModel

        val typeSpecBuilder = TypeSpec.classBuilder(fileName) // 生成的主要类
            .addModifiers(KModifier.PUBLIC) // 指定类是公有的

        // 添加方法provideViewModel
        typeSpecBuilder.addFunction(
            FunSpec.builder("provideViewModel") // 方法名
                .addModifiers(KModifier.PUBLIC) // 指定方法是公有的
                .addParameter("owner", ClassName("androidx.lifecycle", "ViewModelStoreOwner")) // 参数
                .returns(ClassName(pack, viewModelName)) // 返回类型
                .addStatement("return ViewModelProvider(owner).get(%T::class.java)", ClassName(pack, viewModelName)) // 具体的方法
                .build()
        )

        // 如果有第二个泛型参数，则生成provideViewBinding方法
        if (typeArguments.size > 1) {
            val viewBindingName = typeArguments[1].asTypeName().toString()
            typeSpecBuilder.addFunction(
                FunSpec.builder("provideViewBinding") // 方法名
                    .addModifiers(KModifier.PUBLIC) // 指定方法是公有的
                    .addParameter("layoutInflater", ClassName("android.view", "LayoutInflater")) // 参数
                    .returns(ClassName(pack, viewBindingName)) // 返回类型
                    .addStatement("return %T.inflate(layoutInflater)", ClassName(pack, viewBindingName)) // 具体的方法
                    .build()
            )
        }

        val fileSpec = FileSpec.builder(pack, fileName)
            .addImport("androidx.lifecycle", "ViewModelProvider")  //指定导入类
            .addImport("android.view", "LayoutInflater")
            .addType(typeSpecBuilder.build())
            .build()

        val kaptKotlinGeneratedDir = processingEnv.options[KAPT_KOTLIN_GENERATED_OPTION_NAME]
        fileSpec.writeTo(File(kaptKotlinGeneratedDir, "$fileName.kt"))
    }


    companion object {
        const val KAPT_KOTLIN_GENERATED_OPTION_NAME = "kapt.kotlin.generated"
    }
}

那么我们只需要标记哪些类需要生成对应的文件即可，例如：

@AutoInject
class ProfileActivity : BaseActivity<ProfileViewModel, ActivityProfileBinding>() {}

生成的代码：

public class ProfileActivityViewModelInit {
  public fun provideViewModel(owner: ViewModelStoreOwner): com.newki.profile.mvi.vm.ProfileViewModel
      = ViewModelProvider(owner).get(com.newki.profile.mvi.vm.ProfileViewModel::class.java)

  public fun provideViewBinding(layoutInflater: LayoutInflater):
      com.newki.profile.databinding.ActivityProfileBinding =
      com.newki.profile.databinding.ActivityProfileBinding.inflate(layoutInflater)
}

基类中调用：

  protected open fun createViewBinding() {

        try {
            val currentPackageName = this::class.java.`package`?.name
            val className = currentPackageName + "." + this::class.java.simpleName + "ViewModelInit"
            val generatedClass = Class.forName(className)
            val method = generatedClass.getDeclaredMethod("provideViewBinding", LayoutInflater::class.java)
            val generatedClassInstance = generatedClass.getDeclaredConstructor().newInstance()
            _binding = method.invoke(generatedClassInstance, layoutInflater) as VB
        } catch (e: Exception) {
            e.printStackTrace()
        
        }

    }

    protected open fun createViewModel(): VM {
        try {
            val currentPackageName = this::class.java.`package`?.name
            val className = currentPackageName + "." + this::class.java.simpleName + "ViewModelInit"
            val generatedClass = Class.forName(className)
            val method = generatedClass.getDeclaredMethod("provideViewModel", ViewModelStoreOwner::class.java)
            val generatedClassInstance = generatedClass.getDeclaredConstructor().newInstance()
            return method.invoke(generatedClassInstance, this) as VM
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

我们同样可以无感的在基类自动创建对应的初始化代码，需要注意的是我同样需要混淆生成的代码

#自定义的自动注入生成类，保护实现
-keep class **.*ViewModelInit { *; }

当然了，理论上我们可以直接在 ASM 字节码插桩生成的代码中直接在onCreate方法中自动调用给 mViewModel 和 mViewBinding 这两个固定的字段赋值，但是这有点"硬编码"的意思了，一旦在基类中修改了这个变量的名字就会导致异常，如果你确保不会变动，其实也可以直接用字节码插桩或者AOP面向切面自动赋值到这两个变量中。

后记

本文详细介绍了常用的三种封装方案，所以这三种方案你更喜欢哪一种？

原始的：

abstract class BaseActivity<VM : ViewModel,VB : ViewBinding>(
   private val vmClass: Class<VM>， private val vb: (LayoutInflater) -> VB,
) : AppCompatActivity() {
}

class ProfileActivity : BaseActivity<ActivityProfileBinding, ProfileViewModel>(
    ActivityProfileBinding::inflate,
    ProfileViewModel::class.java
){}

反射：

abstract class BaseActivity<VM : ViewModel,VB : ViewBinding>(){

    //...

    private fun getViewModelInstance(): VM {
        val superClass = javaClass.genericSuperclass as ParameterizedType
        val vmClass = (superClass.actualTypeArguments[0] as Class<VM>).kotlin
        return ViewModelProvider(this, ViewModelProvider.NewInstanceFactory()).get(vmClass.java)
    }

 
    private fun getViewBindingInstance(inflater: LayoutInflater): VB {
        val superClass = javaClass.genericSuperclass as ParameterizedType
        val vbClass = superClass.actualTypeArguments[1] as Class<VB>
        val method = vbClass.getMethod("inflate", LayoutInflater::class.java)
        return method.invoke(null, inflater) as VB
    }
}

使用：

class ProfileActivity : BaseActivity<ProfileViewModel, ActivityProfileBinding>() {}

APT的使用:

@AutoInject  //自定义注解，自己定义
class ProfileActivity : BaseActivity<ProfileViewModel, ActivityProfileBinding>() {}

总的来说三种方案各有利弊，都是可以实现的，用哪一种方案完全看自己的意愿。

【Android】只给个泛型，如何自动初始化ViewModel与ViewBinding？这几种方案值得了解

作者：Newki
链接：https://juejin.cn/post/7357546247849197606
来源：稀土掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

锐湃
关注
专栏目录
Jetpack明星组件 —ViewModel 这些知识点你必须知道！
chuhe1989的博客
08-18 899
前言 ViewModel 作为 Jetpack 中的明星组件，相信大家都对其有一定的了解。在 Google 的官方介绍中也详细的罗列了 ViewModel 的优点，如： 可以提供和管理UI界面数据。(将加载数据与数据恢复从 Activity or Fragment中解耦) 可感知生命周期的组件。 不会因配置改变而销毁。 可以配合 LiveData 使用。 多个 Fragment 可以共享同一 ViewModel。 等等等… 你也可以通过下列两个视频，更为详细的了解 ViewModel： ViewMo.
优雅地封装和使用 ViewBinding，该替代 Kotlin synthetic 和 ButterKnife 了
m0_70083038的博客
04-29 519
override fun onCreate(savedInstanceState: Bundle?) { super.onCr 《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》无偿开源 徽信搜索公众号【编程进阶路】 eate(savedInstanceState) binding = ActivityMainBinding.inflate(layoutInflater) setContentView(binding.root) binding.tvHelloWorld.t
ViewModel变量初始化方式
YDDUONG的博客
02-12 2959
class WordViewModel(application: Application) : AndroidViewModel(application) { //方式一： private val _allWord: LiveData<List<Word>> by lazy { WordRepository.getInstance(appli...
【Android Jetpack实战追踪】ViewModel的初始化及dagger的使用
m0_48179608的博客
03-16 932
在上一章节【Android Jetpack实战追踪】从一个简单的登录页开始 我们知道如何利用Jetpack搭一个简单的MVVM项目的框架，但很多细节并没有介绍，比如ViewModel的创建。 那么今天我们就分别说下ViewModel的几种创建方式。 ViewModelProvider(s) 在lifecycle1.1.1(android.arch.lifecycle:extensions:1.1.1)之前，我们使用以下方式创建ViewModel。 ViewModelProviders.of(this).ge
创建泛型ViewModel时报错(Kotlin get type of generic class without instance)
feipengwang的博客
04-23 764
错误示例 话不多说，直接上代码 abstract class BaseAct<T:BaseViewModel> :AppCompatActivity(){ protected lateinit var mActivity:AppCompatActivity protected lateinit var mContext: Context protected lateinit var mViewModel: T override fun onCreate(save
初探ViewBinding
chends
10-27 1万+
视图访问的方式有常用的findViewById，ButterKnife等多种方式，这些方式的各方面对比如下 如上图所示，在简明、编译安全和编译速度上都各有优势，那么有没有一种方式可以一石"三"鸟呢。谷歌在Android Studio 3.6 Canary 11版本中正式推出视图绑定(View Binding)，来看下使用方法， 首先需要使用AS 3.6 Canary 11之上的版本，这...
Android Data Binding数据绑定详解（基础篇）
weixin_42046829的博客
03-19 1639
简介 在2015年的谷歌IO大会上，Android UI Toolkit团队发布了DataBinding 框架，将数据绑定引入了Android开发。以后可以直接在 layout 布局 xml 文件中绑定数据了，无需再 findViewById 然后手工设置数据了。 构建环境 使用之前，需要在Android Studio中build.gradle配置开启Data Binding，具体如下： andr...
Android技术栈(四)Android-Jetpack-MVVM-完全实践，Android组件化开发教程
m0_64604178的博客
11-30 840
你在xml设置的变量他会在这个类中为你生成对应的Getter和Setter.你可以调用它们给界面赋值,比如之前的我们定义的action. //这里的代码是Java8的lambda mBinding.setAction(v->{ //TODO }) 2.3.5 使用BR文件 它还会为你生成一个类似R的BR文件,里面包含了你在DataBinding风格xml中定义的所有变量名的引用(由于使用的是APT生成,有时候需要Rebuild Project才能刷新),比如我们之前的action,它会为我们生成BR.
( 持续更新，目前含 200+ 工具类 ) DevUtils 是一个 Android 工具库, 主要根据不同功能模块，封装快捷使用的工具类及 API 方法调用。
afkT 的博客
09-24 5103
About DevUtils 是一个 Android 工具库, 主要根据不同功能模块，封装快捷使用的工具类及 API 方法调用。 该项目尽可能的便于开发人员，快捷、快速开发安全可靠的项目，以及内置部分常用的资源文件，如color.xml、(toast) layout.xml等 Gradle Step 1. Add the JitPack repository to your build fil...
ViewModel 初探
qq_32086641的博客
03-12 197
ViewModel 专门用于存放应用程序页面所需的数据。它将页面所需的数据从页面中剥离出来，页面只需要处理用户交互，以及负责展示数据的工作。 生命周期 ViewModel是一个抽象类，其中有一个方法onCleared()，当ViewModel不再被需要的时候，也就是与之相关的Activity或其他LifecycleOwner都被销毁时，该方法会被系统调用，我们可以在这个方法里面执行一些资源释放的操作，以免内存泄漏。 使用 这里直接贴上官方demo的部分代码。 class SharedViewMod
Android将 ViewBinding封装到BaseActivity基类中（Java版）1
qianfeifeio的专栏
02-23 1425
项目已经启用了ViewBinding。“ViewBinding的类型”
Android通过注解初始化绑定View
2401_84121603的博客
04-17 847
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
Android ViewModel探索
u012108336的博客
05-09 374
ViewModel原理分析
Android Jetpack之ViewModel简单封装
WJC2015的博客
06-01 572
可能有的同学不知道sealed class是什么意思，这里简单说明一下，sealed class中文翻译是密封类，跟枚举类有点类似，但是比枚举类功能更加强大。获取界面上的数据，一般要有请求参数,不妨用P(parameter)表示，然后必定有一个方法，根据参数P获取数据。处理界面UI的接口ViewHandler代码如下，很容易理解，没什么需要特别说明的。重点关注红色笔圈起来的部分，在适当的时机给BaseViewModel里的LiveData数据赋值。写完了，若有不正确的地方，欢迎指正。
kotlin：viewModel跟viewBinding的基本用法
最新发布
m0_46366678的博客
07-08 453
kotlin中viewBinding跟viewModel的基本使用
Android业务架构 · 基础篇 · Jetpack四件套
BASK2312的博客
03-10 879
Android Jetpack Lifecycle是Android Jetpack组件库中的一部分，Lifecycle是基于Android Framework中的Lifecycle概念而构建的。Lifecycle提供了一种轻松管理组件（如Activity和Fragment）生命周期的方式，同时也支持自定义组件的生命周期。Jetpack Lifecycle提供了一组类和接口，使得开发者可以在组件的生命周期各个阶段执行相应的操作。
Java通过泛型的模板类型实例化对象
Android开源技术交流
06-08 1万+
通过泛型的模板类型实例化对象 最近自己研究了下mvvm框架，使用泛型的方式可节省很多代码，并且可以合并很多冗余代码，为了最大化的精简代码想到了通过泛型的type用反射的方式实例化对象，这样对象的实例化代码就不用每次都去复写函数来创建了，下面来看看代码。 public class BaseViewModel&amp;lt;M extends Model&amp;gt; implements ViewMode...
Model 层数据在哪初始化？ View层数据又在哪初始化?
bellazhouyi的专栏
10-02 1149
//M层数据写在初始化方法，每一个item都是M层 //初始化本身就是管理数据的。 -(instancetype)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil {          if (self = [super initWithNibName:nibNameOrN
安卓开发，ViewBinding的简单使用和封装。
weixin_45920642的博客
06-20 705
ViewBinding是什么？ViewBinding是一项功能，可以让你轻松地编写与视图的交互代码，它可以自动为每个sml布局文件生成一个绑定类，包含了所有ID的视图的直接引用。非常方便。
Android开发——View Binding的使用与解析
热门推荐
关于Android开发的一些技术点总结 ╮(￣▽￣”)╭
04-24 2万+
1. 前言 如何干掉模版代码是很多第三方框架的设计初衷，在Android开发中，findViewById()是必不可少的存在，这样的冗余代码在很久以前充斥在Android工程中，因此也出现了很多精简写法，代表方案罗列如下： 1.1 Butter Knife/Kotter Knife Butter Knife框架是17年前后很火的存在。但是在Kotlin中直接使用ButterKnife的注解方式的话...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值