Kotlinで学ぶアノテーションを活用したメタプログラミング入門

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class ExampleAnnotation(val value: String)

@ExampleAnnotation("Sample")
class MyClass

@Entity
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    val email: String
)

@Entity
data class Product(
    @PrimaryKey val id: Int,
    val name: String,
    val price: Double
)

@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class LogExecution

@LogExecution
fun processData() {
    println("Processing data...")
}

@Deprecated("Use newFunction() instead", ReplaceWith("newFunction()"))
fun oldFunction() {
    println("This function is deprecated.")
}

fun newFunction() {
    println("This is the new function.")
}

class Utility {
    companion object {
        @JvmStatic
        fun printMessage() {
            println("Static method accessible from Java")
        }
    }
}

Utility.printMessage();

@Suppress("UNCHECKED_CAST")
fun castToList(any: Any): List<String> {
    return any as List<String>
}

@Serializable
data class User(val id: Int, val name: String)

fun main() {
    val user = User(1, "John Doe")
    val json = Json.encodeToString(user)
    println(json) // {"id":1,"name":"John Doe"}
}

class MyTests {
    @Test
    fun testAddition() {
        assert(2 + 2 == 4)
    }
}

@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class MyAnnotation(val description: String)

@MyAnnotation(description = "This is a custom annotation")
class MyClass {
    @MyAnnotation(description = "Annotated function")
    fun myFunction() {
        println("Function with custom annotation")
    }
}

fun main() {
    val clazz = MyClass::class
    val annotations = clazz.annotations
    for (annotation in annotations) {
        if (annotation is MyAnnotation) {
            println("Class annotation: ${annotation.description}")
        }
    }

    val function = clazz.members.find { it.name == "myFunction" }
    val functionAnnotations = function?.annotations
    if (functionAnnotations != null) {
        for (annotation in functionAnnotations) {
            if (annotation is MyAnnotation) {
                println("Function annotation: ${annotation.description}")
            }
        }
    }
}

plugins {
    id 'org.jetbrains.kotlin.kapt'
}

dependencies {
    kapt "com.google.auto.service:auto-service:1.0.1" // アノテーションプロセッサの登録用
    implementation "com.squareup:kotlinpoet:1.13.2" // コード生成ライブラリ
}

@SupportedAnnotationTypes("com.example.MyAnnotation")
@SupportedSourceVersion(SourceVersion.RELEASE_8)
class MyAnnotationProcessor : AbstractProcessor() {
    override fun process(annotations: Set<TypeElement>, roundEnv: RoundEnvironment): Boolean {
        for (element in roundEnv.getElementsAnnotatedWith(MyAnnotation::class.java)) {
            if (element.kind == ElementKind.CLASS) {
                generateCode(element as TypeElement)
            }
        }
        return true
    }
}

val annotatedElements = roundEnv.getElementsAnnotatedWith(MyAnnotation::class.java)
for (element in annotatedElements) {
    val className = element.simpleName.toString()
    val packageName = processingEnv.elementUtils.getPackageOf(element).toString()
    println("Found class: $className in package: $packageName")
}

fun generateCode(element: TypeElement) {
    val className = element.simpleName.toString()
    val fileSpec = FileSpec.builder("com.example.generated", "${className}Generated")
        .addType(
            TypeSpec.classBuilder("${className}Generated")
                .addFunction(
                    FunSpec.builder("printInfo")
                        .addStatement("println(\"This is a generated class.\")")
                        .build()
                )
                .build()
        )
        .build()
    fileSpec.writeTo(processingEnv.filer)
}

package com.example.generated

class MyClassGenerated {
    fun printInfo() {
        println("This is a generated class.")
    }
}

@Entity
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    val email: String
)

interface UserDao {
    fun insert(user: User)
    fun delete(user: User)
    fun getAll(): List<User>
}

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

@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.SOURCE)
annotation class PrimaryKey

class EntityProcessor : AbstractProcessor() {
    override fun process(annotations: Set<TypeElement>, roundEnv: RoundEnvironment): Boolean {
        val annotatedClasses = roundEnv.getElementsAnnotatedWith(Entity::class.java)
        for (classElement in annotatedClasses) {
            generateDao(classElement as TypeElement)
        }
        return true
    }

    private fun generateDao(classElement: TypeElement) {
        val className = classElement.simpleName.toString()
        val packageName = processingEnv.elementUtils.getPackageOf(classElement).toString()
        val fileName = "${className}Dao"

        val fileSpec = FileSpec.builder(packageName, fileName)
            .addType(
                TypeSpec.interfaceBuilder(fileName)
                    .addFunction(
                        FunSpec.builder("insert")
                            .addParameter("entity", ClassName(packageName, className))
                            .build()
                    )
                    .addFunction(
                        FunSpec.builder("delete")
                            .addParameter("entity", ClassName(packageName, className))
                            .build()
                    )
                    .addFunction(
                        FunSpec.builder("getAll")
                            .returns(List::class.asClassName().parameterizedBy(ClassName(packageName, className)))
                            .build()
                    )
                    .build()
            )
            .build()

        fileSpec.writeTo(processingEnv.filer)
    }
}

com.example.EntityProcessor

package com.example.generated

interface UserDao {
    fun insert(entity: User)
    fun delete(entity: User)
    fun getAll(): List<User>
}

@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class LogExecution

class LogHandler {
    fun handle(target: Any) {
        val methods = target::class.members.filter { it.annotations.any { it is LogExecution } }
        for (method in methods) {
            println("Executing: ${method.name}")
            method.call(target)
            println("Execution finished: ${method.name}")
        }
    }
}

class SampleClass {
    @LogExecution
    fun sayHello() {
        println("Hello, world!")
    }
}

fun main() {
    val handler = LogHandler()
    handler.handle(SampleClass())
}

Executing: sayHello
Hello, world!
Execution finished: sayHello

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.SOURCE)
annotation class Endpoint(val baseUrl: String)

@Endpoint(baseUrl = "https://api.example.com")
data class User(val id: Int, val name: String)

class UserApiClient {
    private val baseUrl = "https://api.example.com"

    fun getUser(id: Int): User {
        // APIリクエストロジックをここに記述
        return User(id, "Generated Name")
    }
}

@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class Debug

data class Person(
    @Debug val id: Int,
    @Debug val name: String,
    val email: String
)

fun debugLog(obj: Any) {
    val clazz = obj::class
    val debugProperties = clazz.members.filter { it.annotations.any { it is Debug } }
    debugProperties.forEach { property ->
        println("${property.name}: ${property.call(obj)}")
    }
}

fun main() {
    val person = Person(1, "John Doe", "john.doe@example.com")
    debugLog(person)
}

id: 1
name: John Doe

@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class ConfigKey(val key: String)

data class AppConfig(
    @ConfigKey("app.name") val appName: String,
    @ConfigKey("app.version") val appVersion: String
)

class ConfigMapper {
    fun loadConfig(): AppConfig {
        return AppConfig(
            appName = "MyApp",
            appVersion = "1.0.0"
        )
    }
}