如何在Java/Kotlin中通过注解处理器为已有类追加方法？

嘿，很高兴你已经迈出注解处理器的第一步了！针对你想要给已有类追加方法（甚至最好直接修改原类）的需求，我来分享几个完全适配Android平台、无反射开销的编译时解决方案：

一、复制原类并追加新方法（注解处理器标准实现路径） #

因为Java/Kotlin的注解处理器体系本身不允许直接修改已有的类文件（只能生成新文件），所以复制原类并添加新方法是最直接的方案，完全贴合你的需求示例。具体步骤如下：

1. 解析原类的完整元数据
   在你的注解处理器process方法中，先拿到原类对应的TypeElement（比如SourceClass的元素实例），然后遍历它的enclosedElements，区分出所有字段、属性、方法（包括未被@CustomAnnotation标记的someOtherFun）。同时收集被@CustomAnnotation标记的方法名称，这是生成新增方法的核心数据。

2. 用代码生成工具构建新类
   推荐用KotlinPoet（适配Kotlin语法，比手动拼接字符串靠谱太多）来生成ResultClass：

   • 先把原类的所有成员（字段、属性、方法）完整复制到新类中；
   • 再添加你需要的hasFunWithName和callFunByName方法。

   举个核心代码片段示例：

   // 收集被注解的方法名
   val annotatedFunNames = roundEnvironment.getElementsAnnotatedWith(CustomAnnotation::class.java)
       .filterIsInstance<ExecutableElement>()
       .map { it.simpleName.toString() }
   
   // 构建新类
   val resultClass = TypeSpec.classBuilder("ResultClass")
       // 第一步：复制原类的所有成员
       .apply {
           val sourceClass = elementUtils.getTypeElement("com.yourpackage.SourceClass")
           sourceClass.enclosedElements.forEach { enclosedElement ->
               when (enclosedElement.kind) {
                   ElementKind.FIELD -> {
                       // 构建字段并添加到新类
                       val field = PropertySpec.builder(enclosedElement.simpleName.toString(), enclosedElement.asType())
                           .addModifiers(enclosedElement.modifiers.map { it.toKModifier() })
                           .build()
                       addProperty(field)
                   }
                   ElementKind.METHOD -> {
                       // 构建方法并添加到新类（实际场景可通过Element API获取原方法体代码）
                       val method = enclosedElement as ExecutableElement
                       val funSpec = FunSpec.builder(method.simpleName.toString())
                           .addParameters(method.parameters.map {
                               ParameterSpec.builder(it.simpleName.toString(), it.asType())
                                   .addModifiers(it.modifiers.map { mod -> mod.toKModifier() })
                                   .build()
                           })
                           .returns(method.returnType)
                           .addModifiers(method.modifiers.map { it.toKModifier() })
                           .addStatement("// 原方法体内容")
                           .build()
                       addFunction(funSpec)
                   }
                   // 处理Kotlin属性等其他元素类型
               }
           }
       }
       // 第二步：添加新增的hasFunWithName方法
       .addFunction(
           FunSpec.builder("hasFunWithName")
               .addParameter("name", String::class)
               .returns(Boolean::class)
               .addStatement("return (name in arrayOf(%L))", annotatedFunNames.joinToString { "\"$it\"" })
               .build()
       )
       // 第三步：添加新增的callFunByName方法
       .addFunction(
           FunSpec.builder("callFunByName")
               .addParameter("name", String::class)
               .addParameter("arguments", Any::class, KModifier.VARARG)
               .beginControlFlow("when (name)")
               .apply {
                   annotatedFunNames.forEach { funName ->
                       addStatement("%S -> %L(*arguments)", funName, funName)
                   }
               }
               .endControlFlow()
               .build()
       )
       .build()
   
   // 生成最终文件
   val file = FileSpec.builder("com.yourpackage", "ResultClass")
       .addType(resultClass)
       .build()
   file.writeTo(filer)
   

二、近似“直接修改原类”的替代方案 #

如果不想生成全新类，想要更接近“修改原类”的使用体验，可以试试这两种思路：

1. 生成子类 #

让生成的子类继承原类，子类会自动继承原类的所有公开/保护成员，然后在子类中添加新增方法。这种方式的好处是用户可以直接用子类替代原类，无需改动太多调用代码。

2. 生成委托类 #

如果原类是final类无法继承，或者你不想用继承关系，可以生成一个委托类：持有原类的实例，把原类的所有方法委托给这个实例，同时在委托类中添加新增方法。示例结构如下：

class ResultClass(private val delegate: SourceClass) {
    // 委托原类的方法
    fun annotatedFun1(vararg argument: Any) = delegate.annotatedFun1(*argument)
    fun annotatedFun2(vararg argument: Any) = delegate.annotatedFun2(*argument)
    fun someOtherFun() = delegate.someOtherFun()

    // 新增方法
    fun hasFunWithName(name: String): Boolean { /* 实现逻辑 */ }
    fun callFunByName(name: String, vararg arguments: Any) { /* 实现逻辑 */ }
}

三、关键注意事项 #

• 处理私有成员：如果原类有私有字段/方法，复制到新类或子类中会无法访问。如果是你自己维护的原类，可以把这些成员改成internal（Kotlin），让生成的类在同一个模块内可访问；如果是第三方类，委托方案会更合适。
• 避免重复生成：注解处理器会在每次编译时运行，要确保不会重复生成相同的类。Filer的createSourceFile方法会自动处理重复请求，尽量用这个API来生成文件。
• 适配Kotlin特性：如果原类用了Kotlin的特性（比如默认参数、data class、vararg），一定要用KotlinPoet而非JavaPoet，否则容易生成不符合Kotlin语法的代码。

这样既满足了编译时处理、无反射的要求，又能实现你想要的追加方法的需求。

内容的提问来源于stack exchange，提问作者Andrei Vinogradov