使用注解自动生成代码

abstract class Car {
  fun brand(): String // 每辆车都有一个品牌
}
复制代码

class BMW : Car {
	override fun brand(): String {
    return "BMW"
  }
}

class Benz : Car {
	override fun brand(): String {
    return "Benz"
  }
}

class Audi : Car {
	override fun brand(): String {
    return "Audi"
  }
}
复制代码

class CardFactory {
  fun produceCar(brand: String): Car {
        when (brand) {
            "BMW" -> return BMW()
            "Benz" -> return Benz()
            "Audi" -> return Audi()
        }
    }
}
复制代码

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
@MustBeDocumented
annotation class CarAnnotation(val brand: String)
复制代码

@CarAnnotation("BMW")
class BMW : Car {
	override fun brand(): String {
    return "BMW"
  }
}

@CarAnnotation("Benz")
class Benz : Car {
	override fun brand(): String {
    return "Benz"
  }
}

@CarAnnotation("Audi")
class Audi : Car {
	override fun brand(): String {
    return "Audi"
  }
}
复制代码

class CardFactory {
  fun produceCar(brand: String): Car {
        when (brand) {
            "BMW" -> return BMW()
            "Benz" -> return Benz()
            "Audi" -> return Audi()
        }
    }
}
复制代码

implementation project(':car-anntation') // 注解工程
kapt project(':car-processor') // 注解处理器工程, for kotlin (如果使用注解的代码是 Kotlin 代码，必须加上这个，否则注解处理器不生效)
annotationProcessor project(':car-processor') // 注解处理器工程, for java (kapt 可以兼容 annotationProcessor，反之不行) 

// 注意 Kotlin 版本要加上  
apply kapy
// 或者
plugins {
    id 'kotlin-kapt'
}
复制代码

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface CarAnnotation {
   String brand();
}
复制代码

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
@MustBeDocumented
annotation class CarAnnotation(val brand: String)
复制代码

@AutoService(Processor::class)
@SupportedSourceVersion(SourceVersion.RELEASE_8)
class CarAnnotationProcessor : AbstractProcessor() {

    override fun getSupportedAnnotationTypes(): MutableSet<String> {
        return mutableSetOf(CarAnnotation::class.java.canonicalName)
    }

    override fun process(
        set: MutableSet<out TypeElement>,
        roundEnvironment: RoundEnvironment
    ): Boolean {
      // 在这里实现逻辑
     	// 返回 false 代表不处理，交给其他注解处理器继续处理，否则返回 true
    }
}
复制代码

com.example.code.CarAnnotationProcessor

implementation 'com.google.auto.service:auto-service:1.0-rc4'
kapt 'com.google.auto.service:auto-service:1.0-rc4' // kotlin 版本
annotationProcessor 'com.google.auto.service:auto-service:1.0-rc4' // Java 版本

plugins {
    id 'kotlin-kapt'
}
// 或者
apply kapt

// 获取所有标注了 @Car 的类
val cardList = roundEnvironment.getElementsAnnotatedWith(CarAnnotation::class.java)
     // 这里强转成 TypeElement 是为了方便获取更多有用的信息
    .map { it as TypeElement }
    .map {
        val annotation = it.getAnnotation(CarAnnotation::class.java) // 获取注解实例
        val brand = annotation.brand // 拿到注解中的 brand
        val carClazz = it.javaClass.canonicalName // 拿到被注解的类名
        brand to carClazz // 准换成一个 Map
    }

// 根据 Map 生成 "brand" -> return Car() 的代码
val sb = StringBuilder()
sb.appendln("when(brand) {")
cardList.forEach {
    sb.appendln("\"${it.first}\" -> return ${it.second}()")
}
sb.append("}")

FileSpec.builder("com.example.code", "CarFactory")
            .addType(
                TypeSpec.classBuilder("CarFactory")
                    .addFunction(
                        FunSpec.builder("produceCar")
                            .addParameter("brandName", String::class.asTypeName())
                            .addModifiers(KModifier.PUBLIC)
                            .returns(Car::class.asTypeName().copy(nullable = true))
                            .addStatement(sb.toString())
                            .build()
                    )
                    .build()
            )
            .build()
            .writeTo(File(kaptKotlinGeneratedDir)) // 写入文件

kapt.use.worker.api=true

./gradlew --no-daemon -Dorg.gradle.debug=true -Dkotlin.daemon.jvm.options="-Xdebug,-Xrunjdwp:transport=dt_socket\,address=5005\,server=y\,suspend=n" {module}:assembleDebug

> Configure project :app
app: 'annotationProcessor' dependencies won't be recognized as kapt annotation processors. Please change the configuration name to 'kapt' for these artifacts: 'xxxx'.

val parserClazzName = try {
 	// 如果类已经编译了，这里可以直接拿到名字，否则会抛出 MirroredTypeException 异常
 	val clazz = it.getAnnotation(HyperSpan::class.java).parser
 	clazz.java.canonicalName
} catch (mte: MirroredTypeException) {
  // 如果还没有编译，则通过这里拿到类名，之后尝试使用反射的方式拿到 Class
  ((mte.typeMirror as DeclaredType).asElement() as TypeElement).qualifiedName.toString()
}