告别KAPT!使用 KSP 为 Kotlin 编译提速

简介: 告别KAPT!使用 KSP 为 Kotlin 编译提速

今年初 Android 发布了 Kotlin Symbol Processing(KSP)的首个 Alpha 版,几个月过去,KSP 已经更新到 Beta3 了, 目前 API 已经基本稳定,相信距离稳定版发布也不会很远了。

为什么使用 KSP ?

不少人吐槽 Kotlin 的编译速度,KAPT 便是拖慢编译的元凶之一。

很多库都会使用注解简化模板代码,例如 Room、Dagger、Retrofit 等,Kotlin 代码使用 KAPT 处理注解。 KAPT 本质上是基于 APT 工作的,APT 只能处理 Java 注解,因此需要先生成 APT 可解析的 stub (Java代码),这拖慢了 Kotlin 的整体编译速度。

KSP 正是在这个背景下诞生的,它基于 Kotlin Compiler Plugin(简称KCP) 实现,不需要生成额外的 stub,编译速度是 KAPT 的 2 倍以上

KSP 与 KCP

Kotlin Compiler Plugin 在 kotlinc 过程中提供 hook 时机,可以再次期间解析 AST、修改字节码产物等,Kotlin 的不少语法糖都是 KCP 实现的,例如 data class@Parcelizekotlin-android-extension 等, 如今火爆的 Compose 其编译期工作也是借助 KCP 完成的。

理论上 KCP 的能力是 KAPT 的超集,可以替代 KAPT 以提升编译速度。但是 KCP 的开发成本太高,涉及 Gradle Plugin、Kotlin Plugin 等的使用,API 涉及一些编译器知识的了解,一般开发者很难掌握。

一个标准 KCP 的开发涉及以下诸多内容:

image.png

  • Plugin:Gradle 插件用来读取 Gradle 配置传递给 KCP(Kotlin Plugin)
  • Subplugin:为 KCP 提供自定义 KP 的 maven 库地址等配置信息
  • CommandLineProcessor:将参数转换为 KP 可识别参数
  • ComponentRegistrar:注册 Extension 到 KCP 不同流程中
  • Extension:实现自定义的 KP 功能

KSP 简化了上述流程,开发者无需了解编译器工作原理,处理注解等成本像 KAPT 一样低。

KSP 与 KAPT

KSP 顾名思义,在 Symbols 级别对 Kotlin 的 AST 进行处理,访问类、类成员、函数、相关参数等类型的元素。可以类比 PSI 中的 Kotlin AST

image.png

一个 Kotlin 源文件经 KSP 解析后的结果如下:

KSFile
  packageName: KSName
  fileName: String
  annotations: List<KSAnnotation>  (File annotations)
  declarations: List<KSDeclaration>
    KSClassDeclaration // class, interface, object
      simpleName: KSName
      qualifiedName: KSName
      containingFile: String
      typeParameters: KSTypeParameter
      parentDeclaration: KSDeclaration
      classKind: ClassKind
      primaryConstructor: KSFunctionDeclaration
      superTypes: List<KSTypeReference>
      // contains inner classes, member functions, properties, etc.
      declarations: List<KSDeclaration>
    KSFunctionDeclaration // top level function
      simpleName: KSName
      qualifiedName: KSName
      containingFile: String
      typeParameters: KSTypeParameter
      parentDeclaration: KSDeclaration
      functionKind: FunctionKind
      extensionReceiver: KSTypeReference?
      returnType: KSTypeReference
      parameters: List<KSVariableParameter>
      // contains local classes, local functions, local variables, etc.
      declarations: List<KSDeclaration>
    KSPropertyDeclaration // global variable
      simpleName: KSName
      qualifiedName: KSName
      containingFile: String
      typeParameters: KSTypeParameter
      parentDeclaration: KSDeclaration
      extensionReceiver: KSTypeReference?
      type: KSTypeReference
      getter: KSPropertyGetter
        returnType: KSTypeReference
      setter: KSPropertySetter
        parameter: KSVariableParameter
    KSEnumEntryDeclaration
      // same as KSClassDeclaration

这是 KSP 中的 Kotlin AST 抽象。 类似的, APT/KAPT 中有对 Java 的 AST 抽象,其中能找到一些对应关系,比如 Java 使用 Element 描述包、类、方法或者变量等, KSP 中使用 Declaration

Java/APT Kotlin/KSP Description
PackageElement KSFile 表示一个包程序元素。提供对有关包及其成员的信息的访问
ExecuteableElement KSFunctionDeclaration 表示某个类或接口的方法、构造方法或初始化程序(静态或实例),包括注释类型元素
TypeElement KSClassDeclaration 表示一个类或接口程序元素。提供对有关类型及其成员的信息的访问。注意,枚举类型是一种类,而注解类型是一种接口
VariableElement KSVariableParameter / KSPropertyDeclaration 表示一个字段、enum 常量、方法或构造方法参数、局部变量或异常参数

Declaration 之下还有 Type 信息 ,比如函数的参数、返回值类型等,在 APT 中使用 TypeMirror 承载类型信息 ,KSP 中详细的能力由 KSType 实现。

KSP 的开发流程和 KAPT 类似:

  1. 解析源码AST
  2. 生成代码
  3. 生成的代码与源码一起参与 Kotlin 编译

需要注意 KSP 不能用来修改原代码,只能用来生成新代码

KSP 入口:SymbolProcessorProvider

KSP 通过 SymbolProcessor 来具体执行。SymbolProcessor 需要通过一个 SymbolProcessorProvider 来创建。因此 SymbolProcessorProvider 就是 KSP 执行的入口

interface SymbolProcessorProvider {
    fun create(environment: SymbolProcessorEnvironment): SymbolProcessor
}

SymbolProcessorEnvironment 获取一些 KSP 运行时的依赖,注入到 Processor

interface SymbolProcessor {
    fun process(resolver: Resolver): List<KSAnnotated> // Let's focus on this
    fun finish() {}
    fun onError() {}
}

process() 提供一个 Resolver , 解析 AST 上的 symbols。 Resolver 使用访问者模式去遍历 AST。

如下,Resolver 使用 FindFunctionsVisitor 找出当前 KSFile 中 top-level 的 function 以及 Class 成员方法:

class HelloFunctionFinderProcessor : SymbolProcessor() {
    ...
    val functions = mutableListOf<String>()
    val visitor = FindFunctionsVisitor()
    override fun process(resolver: Resolver) {
        //使用 FindFunctionsVisitor 遍历访问 AST
        resolver.getAllFiles().map { it.accept(visitor, Unit) }
    }
    inner class FindFunctionsVisitor : KSVisitorVoid() {
        override fun visitClassDeclaration(classDeclaration: KSClassDeclaration, data: Unit) {
            //访问 Class 节点
            classDeclaration.getDeclaredFunctions().map { it.accept(this, Unit) }
        }
        override fun visitFunctionDeclaration(function: KSFunctionDeclaration, data: Unit) {
            // 访问 function 节点
            functions.add(function)
        }
        override fun visitFile(file: KSFile, data: Unit) {
            //访问 file
            file.declarations.map { it.accept(this, Unit) }
        }
    }
    ...
}

KSP API 示例

举几个例子看一下 KSP 的 API 是如何工作的

访问类中的所有成员方法

fun KSClassDeclaration.getDeclaredFunctions(): List<KSFunctionDeclaration> {
    return this.declarations.filterIsInstance<KSFunctionDeclaration>()
}

判断一个类或者方法是否是局部类或局部方法

fun KSDeclaration.isLocal(): Boolean {
    return this.parentDeclaration != null && this.parentDeclaration !is KSClassDeclaration
}

判断一个类成员是否对其他Declaration可见

fun KSDeclaration.isVisibleFrom(other: KSDeclaration): Boolean {
    return when {
        // locals are limited to lexical scope
        this.isLocal() -> this.parentDeclaration == other
        // file visibility or member
        this.isPrivate() -> {
            this.parentDeclaration == other.parentDeclaration
                    || this.parentDeclaration == other
                    || (
                        this.parentDeclaration == null
                            && other.parentDeclaration == null
                            && this.containingFile == other.containingFile
                    )
        }
        this.isPublic() -> true
        this.isInternal() && other.containingFile != null && this.containingFile != null -> true
        else -> false
    }
}

获取注解信息

// Find out suppressed names in a file annotation:
// @file:kotlin.Suppress("Example1", "Example2")
fun KSFile.suppressedNames(): List<String> {
    val ignoredNames = mutableListOf<String>()
    annotations.forEach {
        if (it.shortName.asString() == "Suppress" && it.annotationType.resolve()?.declaration?.qualifiedName?.asString() == "kotlin.Suppress") {
            it.arguments.forEach {
                (it.value as List<String>).forEach { ignoredNames.add(it) }
            }
        }
    }
    return ignoredNames
}

代码生成的示例

最后看一个相对完整的例子,用来替代APT的代码生成

@IntSummable
data class Foo(
  val bar: Int = 234,
  val baz: Int = 123
)

我们希望通过KSP处理@IntSummable,生成以下代码

public fun Foo.sumInts(): Int {
  val sum = bar + baz
  return sum
}

Dependencies

开发 KSP 需要添加依赖:

plugins {
    kotlin("jvm") version "1.4.32"
}
repositories {
    mavenCentral()
    google()
}
dependencies {
    implementation(kotlin("stdlib"))
    implementation("com.google.devtools.ksp:symbol-processing-api:1.5.10-1.0.0-beta01")
}

IntSummableProcessorProvider

我们需要一个入口的 Provider 来构建 Processor

import com.google.devtools.ksp.symbol.*
class IntSummableProcessorProvider : SymbolProcessorProvider {
    override fun create(environment: SymbolProcessorEnvironment): SymbolProcessor {
        return IntSummableProcessor(
            options = environment.options,
            codeGenerator = environment.codeGenerator,
            logger = environment.logger
        )
    }
}

通过 SymbolProcessorEnvironment 可以为 Processor 注入了 optionsCodeGeneratorlogger 等所需依赖

IntSummableProcessor

class IntSummableProcessor() : SymbolProcessor {
    private lateinit var intType: KSType
    override fun process(resolver: Resolver): List<KSAnnotated> {
        intType = resolver.builtIns.intType
        val symbols = resolver.getSymbolsWithAnnotation(IntSummable::class.qualifiedName!!).filterNot{ it.validate() }
        symbols.filter { it is KSClassDeclaration && it.validate() }
            .forEach { it.accept(IntSummableVisitor(), Unit) }
        return symbols.toList()
    }
}    
  • builtIns.intType 获取到 kotlin.IntKSType, 在后面需要使用。
  • getSymbolsWithAnnotation 获取注解为 IntSummable 的 symbols 列表
  • 当 symbol 是 Class 时,使用 Visitor 对其进行处理

IntSummableVisitor

Visitor 的接口一般如下,DR 代表 Visitor 的输入和输出,

interface KSVisitor<D, R> {
    fun visitNode(node: KSNode, data: D): R
    fun visitAnnotated(annotated: KSAnnotated, data: D): R
    // etc.
}

我们的需求没有输入输出,所以实现KSVisitorVoid即可,本质上是一个 KSVisitor<Unit, Unit>

inner class Visitor : KSVisitorVoid() {
    override fun visitClassDeclaration(classDeclaration: KSClassDeclaration, data: Unit) {
        val qualifiedName = classDeclaration.qualifiedName?.asString()
        //1. 合法性检查
        if (!classDeclaration.isDataClass()) {
            logger.error(
                "@IntSummable cannot target non-data class $qualifiedName",
                classDeclaration
            )
            return
        }
        if (qualifiedName == null) {
            logger.error(
                "@IntSummable must target classes with qualified names",
                classDeclaration
            )
            return
        }
        //2. 解析Class信息
        //...
        //3. 代码生成
        //...
    }
    private fun KSClassDeclaration.isDataClass() = modifiers.contains(Modifier.DATA)
}

如上,我们判断这个Class是不是data class、其类名是否合法

解析Class信息

接下来需要获取 Class 中的相关信息,用于我们的代码生成:

inner class IntSummableVisitor : KSVisitorVoid() {
    private lateinit var className: String
    private lateinit var packageName: String
    private val summables: MutableList<String> = mutableListOf()
    override fun visitClassDeclaration(classDeclaration: KSClassDeclaration, data: Unit) {
        //1. 合法性检查
        //...
        //2. 解析Class信息
        val qualifiedName = classDeclaration.qualifiedName?.asString()
        className = qualifiedName
        packageName = classDeclaration.packageName.asString()
        classDeclaration.getAllProperties()
            .forEach {
                it.accept(this, Unit)
            }
        if (summables.isEmpty()) {
            return
        }
        //3. 代码生成
        //...
    }
    override fun visitPropertyDeclaration(property: KSPropertyDeclaration, data: Unit) {
        if (property.type.resolve().isAssignableFrom(intType)) {
            val name = property.simpleName.asString()
            summables.add(name)
        }
    }
}
  • 通过 KSClassDeclaration 获取了classNamepackageName,以及 Properties 并将其存入 summables
  • visitPropertyDeclaration 中确保 Property 必须是 Int 类型,这里用到了前面提到的 intType

代码生成

收集完 Class 信息后,着手代码生成。 我们引入 KotlinPoet 帮助我们生成 Kotlin 代码

dependencies {
    implementation("com.squareup:kotlinpoet:1.8.0")
}
override fun visitClassDeclaration(classDeclaration: KSClassDeclaration, data: Unit) {
    //1. 合法性检查
    //...
    //2. 解析Class信息
    //...
    //3. 代码生成
    if (summables.isEmpty()) {
        return
    }
    val fileSpec = FileSpec.builder(
        packageName = packageName,
        fileName = classDeclaration.simpleName.asString()
    ).apply {
        addFunction(
            FunSpec.builder("sumInts")
                .receiver(ClassName.bestGuess(className))
                .returns(Int::class)
                .addStatement("val sum = ${summables.joinToString(" + ")}")
                .addStatement("return sum")
                .build()
        )
    }.build()
    codeGenerator.createNewFile(
        dependencies = Dependencies(aggregating = false),
        packageName = packageName,
        fileName = classDeclaration.simpleName.asString()
    ).use { outputStream ->
        outputStream.writer()
            .use {
                fileSpec.writeTo(it)
            }
    }
}
  • 使用 KotlinPoet 的 FunSpec 生成 function 代码
  • 前面SymbolProcessorEnvironment 提供的CodeGenerator用来创建文件,并写入生成的FileSpec代码

总结

通过 IntSummable 的例子可以看到 KSP 完全可以替代 APT/KAPT 进行注解处理,且性能更出色。

目前,已有不少使用 APT 的三方库增加了对 KSP 的支持

Library Status Tracking issue for KSP
Room Experimentally supported
Moshi Experimentally supported
Kotshi Experimentally supported
Lyricist Experimentally supported
Auto Factory Not yet supported Link
Dagger Not yet supported Link
Hilt Not yet supported Link
Glide Not yet supported Link
DeeplinkDispatch Not yet supported Link

将 KAPT 替换为 KSP 也非常简单,以 Moshi 为例

当然,也可以在项目中同时使用 KAPT 和 KSP ,他们互不影响。KSP 取代 KAPT 的趋势越来越明显,果你的项目也处理注解的需求,不妨试试 KSP ?

github.com/google/ksp

目录
相关文章
|
Java Android开发 Kotlin
kotlin查看编译后的Java代码
kotlin查看编译后的Java代码
|
Java Android开发 Kotlin
【错误记录】记录 Android 命令行执行 Java 程序中出现的错误 ( dx 打包 PC 可执行文件报错 | dalvik 命令执行 kotlin 编译的 dex 文件报错 )
【错误记录】记录 Android 命令行执行 Java 程序中出现的错误 ( dx 打包 PC 可执行文件报错 | dalvik 命令执行 kotlin 编译的 dex 文件报错 )
376 0
【错误记录】记录 Android 命令行执行 Java 程序中出现的错误 ( dx 打包 PC 可执行文件报错 | dalvik 命令执行 kotlin 编译的 dex 文件报错 )
|
Android开发 Kotlin
【错误记录】Kotlin 编译报错 ( Not nullable value required to call an ‘iterator()‘ method on for-loop range )
【错误记录】Kotlin 编译报错 ( Not nullable value required to call an ‘iterator()‘ method on for-loop range )
215 0
【错误记录】Kotlin 编译报错 ( Not nullable value required to call an ‘iterator()‘ method on for-loop range )
|
Android开发 Kotlin
【错误记录】Kotlin 编译报错 ( Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable ... )
【错误记录】Kotlin 编译报错 ( Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable ... )
463 0
【错误记录】Kotlin 编译报错 ( Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable ... )
|
Android开发 Kotlin
【错误记录】Android Studio 编译时 Kotlin 代码编译报错 ( Not enough information to infer type variable T )
【错误记录】Android Studio 编译时 Kotlin 代码编译报错 ( Not enough information to infer type variable T )
209 0
|
Android开发 Kotlin
【错误记录】Android Studio 编译时 Kotlin 代码编译报错 ( 升级支持库时处理 @NonNull 参数 )
【错误记录】Android Studio 编译时 Kotlin 代码编译报错 ( 升级支持库时处理 @NonNull 参数 )
148 0
【错误记录】Android Studio 编译时 Kotlin 代码编译报错 ( 升级支持库时处理 @NonNull 参数 )
|
Java Scala Kotlin
JVM语言生态结构原理图 从Java,Kotlin,Scala,Groovy等语言的编译、执行全过程图示解析
JVM语言生态结构原理图 从Java,Kotlin,Scala,Groovy等语言的编译、执行全过程图示解析 JVM语言生态 by 陈光剑.png
1044 0
|
18天前
|
移动开发 Java Android开发
构建高效Android应用:探究Kotlin与Java的性能差异
【4月更文挑战第3天】在移动开发领域,性能优化一直是开发者关注的焦点。随着Kotlin的兴起,其在Android开发中的地位逐渐上升,但关于其与Java在性能方面的对比,尚无明确共识。本文通过深入分析并结合实际测试数据,探讨了Kotlin与Java在Android平台上的性能表现,揭示了在不同场景下两者的差异及其对应用性能的潜在影响,为开发者在选择编程语言时提供参考依据。
|
19天前
|
数据库 Android开发 开发者
构建高效Android应用:Kotlin协程的实践指南
【4月更文挑战第2天】随着移动应用开发的不断进步,开发者们寻求更流畅、高效的用户体验。在Android平台上,Kotlin语言凭借其简洁性和功能性赢得了开发社区的广泛支持。特别是Kotlin协程,作为一种轻量级的并发处理方案,使得异步编程变得更加简单和直观。本文将深入探讨Kotlin协程的核心概念、使用场景以及如何将其应用于Android开发中,以提高应用性能和响应能力。通过实际案例分析,我们将展示协程如何简化复杂任务,优化资源管理,并为最终用户提供更加流畅的体验。
|
28天前
|
调度 数据库 Android开发
构建高效Android应用:Kotlin协程的实践与优化
在Android开发领域,Kotlin以其简洁的语法和平台友好性成为了开发的首选语言。其中,Kotlin协程作为处理异步任务的强大工具,它通过提供轻量级的线程管理机制,使得开发者能够在不阻塞主线程的情况下执行后台任务,从而提升应用性能和用户体验。本文将深入探讨Kotlin协程的核心概念,并通过实例演示如何在实际的Android应用中有效地使用协程进行网络请求、数据库操作以及UI的流畅更新。同时,我们还将讨论协程的调试技巧和常见问题的解决方法,以帮助开发者避免常见的陷阱,构建更加健壮和高效的Android应用。
35 4