Sword - 为 Kotlin 函数增加代理功能(三)_valfq，面试必备技巧

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数HarmonyOS鸿蒙开发工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年HarmonyOS鸿蒙开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上HarmonyOS鸿蒙开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新

如果你觉得这些内容对你有帮助，可以添加VX：vip204888 （备注鸿蒙获取）

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

 }

}

笔者创建了两个测试函数：`getTextNoArg` 和 `getTextArg`，一个函数没有参数，另一个函数有多个不同类型的参数。这两个函数上都有 `Proxy` 注解，并且注解的参数 `enable` 都处于开启状态，`handler` 参数都注入了对应 `InvocationHandler` 实现类的全限定名。


下面执行测试逻辑，分别调用上述两个函数：

val test = Test()
​
val textNoArg = test.getTextNoArg()
Log.e(TAG, “onCreate: textNoArg = ${textNoArg.length}”)
​
val textArg = test.getTextArg(
1,
false,
‘A’,
1,
1,
1,
1F,
1.0,
“test”,
intArrayOf(),
Array(0) { “” },
listOf(),
listOf(),
mapOf(),
User(“1”, 1),
object : Callback {
override fun onSuccess() {
}
​
override fun onFailure(cause: Throwable) {
}
})
Log.e(TAG, “onCreate: textArg = $textArg”)

原始输出结果：

1.MainActivity: onCreate: textNoArg = 14
2.MainActivity: onCreate: textArg = User(name=guodongAndroid-Release, age=28)

代理输出结果：

1.GetTextNoArgInvocationHandler: invoke: className = Test, methodName = getTextNoArg, args(0) =
2.MainActivity: onCreate: textNoArg = 20
3.GetTextArgInvocationHandler: invoke: className = Test, methodName = getTextArg, args(16) = 1, false, A, 1, 1, 1, 1.0, 1.0, test, [I@156552e7, [Ljava.lang.String;@110de94, [], [], {}, User(name=1, age=1), com.guodong.android.sword.app.MainActivity$onCreate$textArg$2@12780d3d
4.onCreate: textArg = User(name=guodongAndroid-Debug, age=18)

从上面的输出结果可以看出，`Proxy` 注解生效了：调用上述两个函数后成功执行了代理类的 `invoke` 函数。


至此，`Sword` 的使用就结束了，是不是比较简单呢？


但是这里有个问题：我们在给 `Proxy` 注解的 `handler` 参数注入 `InvocationHandler` 实现类的全限定名时使用的是硬编码，如果我们修改了实现类的类名，而忘记修改此处的全限定名，代码在运行时就会发生错误了。


针对这个问题，笔者的第一想法是使用 `handler = GetTextNoArgInvocationHandler::class.java.name`，但是不行，**注解参数必须是编译期常量**，此路不通了。


后面笔者想到一种方案：为 `InvocationHandler` 的实现类生成全限定名索引。


此方案参考自 `EventBus` 为 `Event` 事件生成 `EventIndex` ，不过 `EventBus` 使用 `APT` 技术进行实现，而 `Sword` 选择使用 `KSP` 实现。


接下来我们就看看如何为 `InvocationHandler` 的实现类生成全限定名索引吧。


首先看下最后的索引类 `HandlerFqName` 效果：


### HandlerFqName

// The file is automatic generated by Sword, don’t modify it.
package com.guodong.android.sword.app
​
import kotlin.String
​
/**

• The class is automatic generated by Sword, don’t modify it.
• [com.guodong.android.sword.api.kt.InvocationHandler]实现类的全限定名
  /
  public object HandlerFqName {
  /*
  • [com.guodong.android.sword.app.GetTextArgInvocationHandler]
    /
    public const val GetTextArgInvocationHandler: String =
    “com.guodong.android.sword.app.GetTextArgInvocationHandler”
    ​
    /*
  • [com.guodong.android.sword.app.GetTextNoArgInvocationHandler]
    */
    public const val GET_TEXT_NO_ARG: String =
    “com.guodong.android.sword.app.GetTextNoArgInvocationHandler”
    }

### ProxyHandler

/**

• 标记[InvocationHandler]的实现类, 为其生成FqName索引类HandlerFqName
• 使用 ksp 实现
  /
  @Target(AnnotationTarget.CLASS)
  @Retention(AnnotationRetention.BINARY)
  annotation class ProxyHandler(
  /*
  • 生成字段的名称, 默认为类名
  • paramName参数名称不要随意变动
    */
    val paramName: String = “”
    )

在 `api-kotlin` 模块中新增 `ProxyHandler` 注解，此注解用于标记 `InvocationHandler` 的实现类，为其生成`FqName`索引，比如我们标记在 `GetTextNoArgInvocationHandler` 类上：

@ProxyHandler(“GET_TEXT_NO_ARG”)
class GetTextNoArgInvocationHandler : InvocationHandler

其中 `paramName` 参数可以指定生成字段的名称，如果没有设置，默认生成的字段名称为实现类的类名：`HandlerFqName.GetTextArgInvocationHandler`。


### KSP


[KSP]( ) 基于 `KCP` 实现，提供了一个简化的编译器插件 API，与 `KCP` 陡峭的学习曲线相比，`KSP` 的学习曲线要平滑一些。


如何使用 `KSP` 读者可以参考[官网]( )，本文就不记录搭建 `KSP` 开发环境了，直接进入正题。


笔者先描述下自己的实现思路：


0. 首先判断当前模块是否有 `InvocationHandler` 接口，如若没有，则不处理，
1. 其次判断当前模块是否有 `ProxyHandler` 注解，如若没有，则不处理，
2. 以上两个条件都满足的，再获取包含 `ProxyHandler` 注解的所有 `Kotlin` 符号，
3. 对获取的 `Kotlin` 符号进行几种条件过滤，目的是确保此符号是 `InvocationHandler` 接口的实现类，过滤条件：


	0. 判断是否是类，而不是接口、枚举类等，
	1. 判断类是否是公开且不是抽象类，确保当前类可以访问并直接实例化，
	2. 判断是否有主构造方法或主构造方法没有参数，确保有无参构造方法，
	3. 最后判断当前类是否实现了 `InvocationHandler` 接口。
4. 通过过滤后的符号，收集并存储要生成的字段名和全限定名，
5. 最后通过 `KotlinPoet` 生成索引类。


![](https://img-blog.csdnimg.cn/img_convert/22945fa0d09b45518c8b8c0bccdbaa25.png)


下面根据实现思路依次实现。 首先定义一些常量，用于后面代码的编写：

companion object {
// 对应ProxyHandler注解里的paramName参数名称
private const val PARAM_NAME = “paramName”
​
// 生成索引类的包名，提供给外部配置，默认com.guodong.android.sword
private const val PACKAGE_NAME_PARAM_NAME = “sword.pkg”
​
// 默认索引类的包名
private const val DEFAULT_PACKAGE_NAME = “com.guodong.android.sword”

 // 索引类所在文件名
 private const val FILE_NAME = "HandlerFqName"

 // 索引类的类名
 private const val CLASS_NAME = "HandlerFqName"

}

再定义一个实体，用于存储生成的字段名和全限定名：

data class ProxyHandlerParam(
/**
* 参数名称, 默认为类名
/
val paramName: String,
​
/*
* [InvocationHandler]实现类的全限定名
*
* e.g. com.example.ProxyTestInvocationHandler
*/
val fqName: String,
)

接下来主要分析 `SymbolProcessor` 的 `process(resolver: Resolver)` 函数，下面代码是思路中前两步的具体实现：

private val mInvocationHandlerName = requireNotNull(InvocationHandler::class.qualifiedName)
private val mProxyHandlerName = requireNotNull(ProxyHandler::class.qualifiedName)
​
override fun process(resolver: Resolver): List {
// 判断当前模块是否有 InvocationHandler 接口，如若没有，则不处理
val mProxyHandlerType =
resolver.getClassDeclarationByName(mProxyHandlerName)?.asType(emptyList())
if (mProxyHandlerType == null) {
logger.warn(“KaTeX parse error: Expected 'EOF', got '}' at position 66: …ptyList() }̲ ​ // 判断当…TAG: Not found InvocationHandler”)
return emptyList()
}

 ...

}

获取包含 `ProxyHandler` 注解的所有 `Kotlin` 符号比较简单，通过 `KSP` 提供的 API，我们可以很方便的获取到：

val symbols = resolver.getSymbolsWithAnnotation(mProxyHandlerName)

下面根据实现思路的第四步过滤我们获取到的符号：

val classDeclaration = symbols
.filter { it.validate() }
.filterIsInstance()
.filter { declaration ->
// Class
val isClass = declaration.classKind == ClassKind.CLASS
​
// Public && !Abstract
val isPublic =
Modifier.PUBLIC in declaration.modifiers || declaration.modifiers.isEmpty()
val isNotAbstract = Modifier.ABSTRACT !in declaration.modifiers
​
// 无参构造方法
val primaryConstructor = declaration.primaryConstructor
val hasNoArgumentConstructor =
primaryConstructor == null || primaryConstructor.parameters.isEmpty()
​
// 实现InvocationHandler接口
val isImplInvocationHandler =
declaration.superTypes.any { ref -> ref.resolve() == mInvocationHandlerType }
​
isClass && isPublic && isNotAbstract && hasNoArgumentConstructor && isImplInvocationHandler
}

过滤符号后，就可以收集并存储要生成的字段名和全限定名了：

val params = mutableListOf()
for (declaration in classDeclaration) {
for (annotation in declaration.annotations) {
// 这里笔者没有判断当前annotation是否是ProxyHandler可能会存在问题
// 因为resolve()函数的注释中描述调用此函数的代价比较昂贵, 应尽可能避免调用，这里又是在遍历中调用，所以笔者就没有判断
// 如果存在问题，我们可以给ProxyHandler注解的paramName参数换个唯一不会重复的名称
/if (annotation.annotationType.resolve() != mProxyHandlerType) {
continue
}/

     for (argument in annotation.arguments) {
         val name = argument.name?.asString() ?: continue
         // 判断是否是`ProxyHandler`注解中的参数名称
         if (name == PARAM_NAME) {
             // 获取注解中的参数值
     /*if (annotation.annotationType.resolve() != mProxyHandlerType) {
         continue
     }*/

     for (argument in annotation.arguments) {
         val name = argument.name?.asString() ?: continue
         // 判断是否是`ProxyHandler`注解中的参数名称
         if (name == PARAM_NAME) {
             // 获取注解中的参数值