Kotlinアノテーションの基本と定義方法をわかりやすく解説

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

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

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

class Example {
    companion object {
        @JvmStatic
        fun staticFunction() {
            println("This is a static function")
        }
    }
}

@Suppress("UNUSED_PARAMETER")
fun exampleFunction(unusedParam: String) {
    println("This function has an unused parameter")
}

@Retention(AnnotationRetention.RUNTIME)
annotation class CustomAnnotation

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

@MyAnnotation(description = "This is a sample class")
class SampleClass {

    @MyAnnotation(description = "This is a sample function")
    fun sampleFunction() {
        println("This function has a custom annotation")
    }
}

fun main() {
    val clazz = SampleClass::class
    val annotations = clazz.annotations

    for (annotation in annotations) {
        if (annotation is MyAnnotation) {
            println("Class Annotation: ${annotation.description}")
        }
    }
}

@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
annotation class MyAnnotation

@Target(AnnotationTarget.FUNCTION, AnnotationTarget.VALUE_PARAMETER)
annotation class ExampleAnnotation

class DemoClass {
    @ExampleAnnotation
    fun demoFunction(@ExampleAnnotation parameter: String) {
        println("This function uses an annotated parameter")
    }
}

@Target(AnnotationTarget.CLASS, AnnotationTarget.PROPERTY, AnnotationTarget.FUNCTION)
annotation class MultiTargetAnnotation

@Target(AnnotationTarget.FIELD, AnnotationTarget.CONSTRUCTOR)
annotation class ImportantField

annotation class CustomAnnotation(val name: String, val priority: Int)

@CustomAnnotation(name = "Example", priority = 1)
class AnnotatedClass {
    @CustomAnnotation(name = "ImportantFunction", priority = 2)
    fun importantFunction() {
        println("This function has a priority of 2")
    }
}

annotation class DefaultAnnotation(val message: String = "Default Message")

@DefaultAnnotation
class DefaultAnnotatedClass

annotation class MultiValueAnnotation(val tags: Array<String>)

@MultiValueAnnotation(tags = ["tag1", "tag2", "tag3"])
class MultiTaggedClass

@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class ApiVersion(val version: Int, val deprecated: Boolean = false)

@ApiVersion(version = 2)
class NewApi

@ApiVersion(version = 1, deprecated = true)
fun oldApiFunction() {
    println("This API is deprecated.")
}

annotation class ExampleAnnotation(val description: String)

@ExampleAnnotation(description = "This is a sample class")
class SampleClass

fun main() {
    val clazz = SampleClass::class
    val annotations = clazz.annotations

    for (annotation in annotations) {
        if (annotation is ExampleAnnotation) {
            println("Annotation found: ${annotation.description}")
        }
    }
}

@ExampleAnnotation(description = "This is a sample function")
fun sampleFunction() {
    println("Sample Function")
}

fun main() {
    val function = ::sampleFunction
    val annotations = function.annotations

    for (annotation in annotations) {
        if (annotation is ExampleAnnotation) {
            println("Function Annotation: ${annotation.description}")
        }
    }
}

annotation class Task(val priority: Int)

@Task(priority = 1)
fun lowPriorityTask() {
    println("Low priority task executed")
}

@Task(priority = 5)
fun highPriorityTask() {
    println("High priority task executed")
}

fun executeTasks() {
    val tasks = listOf(::lowPriorityTask, ::highPriorityTask)

    val sortedTasks = tasks.sortedBy {
        it.annotations.filterIsInstance<Task>().firstOrNull()?.priority ?: 0
    }

    for (task in sortedTasks) {
        task.call()
    }
}

fun main() {
    executeTasks()
}

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

dependencies {
    implementation "com.google.dagger:dagger:2.x"
    kapt "com.google.dagger:dagger-compiler:2.x"
}

@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)) {
            // アノテーションが付与された要素を処理する
            processingEnv.messager.printMessage(Diagnostic.Kind.NOTE, "Processing: ${element.simpleName}")
        }
        return true
    }
}

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

override fun process(annotations: Set<TypeElement>, roundEnv: RoundEnvironment): Boolean {
    for (element in roundEnv.getElementsAnnotatedWith(GenerateModel::class.java)) {
        val className = "${element.simpleName}Model"
        val fileContent = """
            package com.example.generated
            class $className {
                // Generated code here
            }
        """.trimIndent()

        val file = processingEnv.filer.createSourceFile("com.example.generated.$className")
        file.openWriter().use { it.write(fileContent) }
    }
    return true
}

@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class Endpoint(val path: String, val method: String)

class ApiController {
    @Endpoint(path = "/users", method = "GET")
    fun getUsers() {
        println("Fetching users...")
    }

    @Endpoint(path = "/users", method = "POST")
    fun createUser() {
        println("Creating user...")
    }
}

fun registerEndpoints(controller: Any) {
    val methods = controller::class.members
    for (method in methods) {
        val endpoint = method.annotations.filterIsInstance<Endpoint>().firstOrNull()
        if (endpoint != null) {
            println("Registering endpoint: ${endpoint.method} ${endpoint.path}")
        }
    }
}

fun main() {
    val apiController = ApiController()
    registerEndpoints(apiController)
}

@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class Validate(val maxLength: Int)

data class User(
    @Validate(maxLength = 50)
    val name: String,

    @Validate(maxLength = 100)
    val email: String
)

fun validate(obj: Any) {
    val properties = obj::class.members.filterIsInstance<kotlin.reflect.KProperty<*>>()
    for (property in properties) {
        val annotation = property.annotations.filterIsInstance<Validate>().firstOrNull()
        if (annotation != null) {
            val value = property.call(obj) as? String
            if (value != null && value.length > annotation.maxLength) {
                throw IllegalArgumentException("${property.name} exceeds max length of ${annotation.maxLength}")
            }
        }
    }
}

fun main() {
    val user = User(name = "John Doe", email = "johndoe@example.com")
    validate(user)  // 正常動作

    val invalidUser = User(name = "A very long name that exceeds fifty characters", email = "johndoe@example.com")
    validate(invalidUser)  // IllegalArgumentExceptionがスローされる
}