Kotlinでカスタムアノテーションを作成する方法を完全解説

class Example {
    companion object {
        @JvmStatic
        fun printMessage() {
            println("Hello from a static method!")
        }
    }
}

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

@Target(AnnotationTarget.FUNCTION)
annotation class LogExecution

@Retention(AnnotationRetention.RUNTIME)
annotation class Persistent

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

@CustomAnnotation(description = "This is a custom annotation example")
class AnnotatedClass {
    @CustomAnnotation(description = "Annotated function")
    fun annotatedFunction() {
        println("This function is annotated.")
    }
}

fun main() {
    val clazz = AnnotatedClass::class
    // クラスのアノテーションを取得
    val classAnnotation = clazz.annotations.find { it is CustomAnnotation } as? CustomAnnotation
    println("Class annotation: ${classAnnotation?.description}")

    // 関数のアノテーションを取得
    val function = clazz.members.find { it.name == "annotatedFunction" }
    val functionAnnotation = function?.annotations?.find { it is CustomAnnotation } as? CustomAnnotation
    println("Function annotation: ${functionAnnotation?.description}")
}

@CustomAnnotation(description = "Log this method execution")
fun loggedFunction() {
    println("This method will be logged.")
}

fun invokeAnnotatedMethods(instance: Any) {
    instance::class.members.filter { it.annotations.any { it is CustomAnnotation } }.forEach {
        println("Invoking annotated method: ${it.name}")
        it.call(instance)
    }
}

@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class LogExecution(val logLevel: String = "INFO", val isEnabled: Boolean = true)

@LogExecution(logLevel = "DEBUG", isEnabled = true)
fun debugFunction() {
    println("Debugging in progress...")
}

fun main() {
    val function = ::debugFunction
    val annotation = function.annotations.find { it is LogExecution } as? LogExecution
    if (annotation != null && annotation.isEnabled) {
        println("Log Level: ${annotation.logLevel}")
        function.call()
    }
}

@LogExecution(logLevel = "ERROR", isEnabled = true)
fun errorFunction() {
    println("An error occurred!")
}

fun invokeFunctionsWithLogging(instance: Any) {
    instance::class.members.filter { 
        it.annotations.any { annotation -> 
            annotation is LogExecution && annotation.isEnabled 
        } 
    }.forEach { method ->
        val annotation = method.annotations.find { it is LogExecution } as? LogExecution
        println("Executing ${method.name} with log level ${annotation?.logLevel}")
        method.call(instance)
    }
}

@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class LogExecution(val logLevel: String)

class Example {
    @LogExecution(logLevel = "INFO")
    fun annotatedFunction() {
        println("This is a logged function.")
    }
}

fun main() {
    val clazz = Example::class
    clazz.members.forEach { member ->
        member.annotations.forEach { annotation ->
            if (annotation is LogExecution) {
                println("Function: ${member.name}, Log Level: ${annotation.logLevel}")
            }
        }
    }
}

fun invokeAnnotatedMethods(instance: Any) {
    val clazz = instance::class
    clazz.members.forEach { member ->
        val annotation = member.annotations.find { it is LogExecution } as? LogExecution
        if (annotation != null) {
            println("Executing ${member.name} with log level: ${annotation.logLevel}")
            member.call(instance)
        }
    }
}

class Service {
    @LogExecution(logLevel = "DEBUG")
    fun debugTask() {
        println("Executing debug task.")
    }

    @LogExecution(logLevel = "ERROR")
    fun errorTask() {
        println("Executing error task.")
    }
}

fun main() {
    val service = Service()
    invokeAnnotatedMethods(service)
}

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

class AppConfig {
    @ConfigProperty(key = "app.name")
    val appName: String = "MyApplication"

    @ConfigProperty(key = "app.version")
    val appVersion: String = "1.0.0"
}

fun loadConfig(instance: Any) {
    val clazz = instance::class
    clazz.members.forEach { member ->
        val annotation = member.annotations.find { it is ConfigProperty } as? ConfigProperty
        if (annotation != null) {
            println("Config key: ${annotation.key}, Value: ${member.call(instance)}")
        }
    }
}

fun main() {
    val config = AppConfig()
    loadConfig(config)
}

@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class AutoLog(val logLevel: String = "INFO")

class LoggerService {
    @AutoLog(logLevel = "DEBUG")
    fun processDebug() {
        println("Debugging...")
    }

    @AutoLog
    fun processInfo() {
        println("Processing info...")
    }
}

fun logAnnotatedMethods(instance: Any) {
    instance::class.members.forEach { member ->
        val annotation = member.annotations.find { it is AutoLog } as? AutoLog
        if (annotation != null) {
            println("[${annotation.logLevel}] Executing ${member.name}")
            member.call(instance)
        }
    }
}

fun main() {
    val service = LoggerService()
    logAnnotatedMethods(service)
}

@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class Validate(val regex: String)

data class User(
    @Validate(regex = "^[a-zA-Z]+$")
    val name: String,

    @Validate(regex = "^[0-9]{10}$")
    val phoneNumber: String
)

fun validateData(instance: Any) {
    instance::class.members.filter { it.annotations.any { it is Validate } }.forEach { member ->
        val annotation = member.annotations.find { it is Validate } as? Validate
        val value = member.call(instance) as? String
        if (value != null && !value.matches(Regex(annotation!!.regex))) {
            throw IllegalArgumentException("Invalid value for ${member.name}: $value")
        }
    }
}

fun main() {
    val user = User(name = "John", phoneNumber = "1234567890")
    validateData(user) // 成功

    val invalidUser = User(name = "John123", phoneNumber = "123")
    validateData(invalidUser) // エラー
}

@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class Route(val path: String, val method: String = "GET")

class WebController {
    @Route(path = "/home")
    fun home() {
        println("Welcome to Home Page")
    }

    @Route(path = "/about", method = "POST")
    fun about() {
        println("About Page")
    }
}

fun routeRequest(controller: Any, path: String, method: String) {
    controller::class.members.forEach { member ->
        val annotation = member.annotations.find { it is Route } as? Route
        if (annotation != null && annotation.path == path && annotation.method == method) {
            member.call(controller)
        }
    }
}

fun main() {
    val controller = WebController()
    routeRequest(controller, "/home", "GET")  // Welcome to Home Page
    routeRequest(controller, "/about", "POST") // About Page
}

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

class ApplicationConfig {
    @Config(key = "app.name")
    val appName: String = "MyApp"

    @Config(key = "app.version")
    val appVersion: String = "1.0.0"
}

fun loadConfiguration(instance: Any, configMap: Map<String, String>) {
    instance::class.members.filter { it.annotations.any { it is Config } }.forEach { member ->
        val annotation = member.annotations.find { it is Config } as? Config
        val key = annotation?.key
        val value = configMap[key]
        println("${member.name} loaded with value: $value")
    }
}

fun main() {
    val appConfig = ApplicationConfig()
    val configMap = mapOf("app.name" to "SuperApp", "app.version" to "2.0.0")
    loadConfiguration(appConfig, configMap)
}

@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class TestCase(val description: String = "Default Test Case")

class MathTests {
    @TestCase(description = "Test addition of two numbers")
    fun testAddition() {
        val result = 2 + 3
        assert(result == 5) { "Addition test failed" }
    }

    @TestCase(description = "Test subtraction of two numbers")
    fun testSubtraction() {
        val result = 10 - 4
        assert(result == 6) { "Subtraction test failed" }
    }
}

fun executeTests(testClass: Any) {
    val clazz = testClass::class
    clazz.members.filter { it.annotations.any { it is TestCase } }.forEach { member ->
        val annotation = member.annotations.find { it is TestCase } as? TestCase
        println("Running test: ${annotation?.description}")
        try {
            member.call(testClass)
            println("Test passed: ${member.name}")
        } catch (e: AssertionError) {
            println("Test failed: ${member.name} - ${e.message}")
        }
    }
}

fun main() {
    val tests = MathTests()
    executeTests(tests)
}

@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class TestGroup(val groupName: String)

class AdvancedTests {
    @TestGroup(groupName = "Math")
    fun testMultiplication() {
        val result = 3 * 4
        assert(result == 12) { "Multiplication test failed" }
    }

    @TestGroup(groupName = "Math")
    fun testDivision() {
        val result = 12 / 3
        assert(result == 4) { "Division test failed" }
    }

    @TestGroup(groupName = "String")
    fun testStringConcatenation() {
        val result = "Hello" + " " + "World"
        assert(result == "Hello World") { "String concatenation test failed" }
    }
}

fun executeTestsByGroup(testClass: Any, group: String) {
    val clazz = testClass::class
    clazz.members.filter { 
        it.annotations.any { it is TestGroup && (it as TestGroup).groupName == group } 
    }.forEach { member ->
        val annotation = member.annotations.find { it is TestGroup } as? TestGroup
        println("Running test in group '${annotation?.groupName}': ${member.name}")
        try {
            member.call(testClass)
            println("Test passed: ${member.name}")
        } catch (e: AssertionError) {
            println("Test failed: ${member.name} - ${e.message}")
        }
    }
}

fun main() {
    val advancedTests = AdvancedTests()
    executeTestsByGroup(advancedTests, "Math")
}

// 修正前
@Retention(AnnotationRetention.BINARY)
annotation class Example

// 修正後
@Retention(AnnotationRetention.RUNTIME)
annotation class Example

// 修正前
@Target(AnnotationTarget.CLASS)
annotation class Example

// 修正後
@Target(AnnotationTarget.FUNCTION, AnnotationTarget.CLASS)
annotation class Example

// 修正前
annotation class Example(val unsupported: List<String>)

// 修正後
annotation class Example(val supported: Array<String>)

val annotation = member.annotations.find { it is ExampleAnnotation } as? ExampleAnnotation

// 修正前
annotation class Example(val value: String)

// 修正後
annotation class Example(val value: String = "Default")

val annotations = member.annotations
annotations.forEach {
    when (it) {
        is FirstAnnotation -> println("Processing FirstAnnotation")
        is SecondAnnotation -> println("Processing SecondAnnotation")
    }
}

@Target(AnnotationTarget.FIELD)
annotation class Example

class ExampleClass {
    @JvmField
    @Example
    val exampleField: String = "Example"
}