Gradle (build.gradle.kts):

dependencies {
    implementation("org.jetbrains.kotlin:kotlin-reflect:1.9.22") // 2025년 3월 기준 최신 버전 사용
}

Maven (pom.xml):

<dependency>
    <groupId>org.jetbrains.kotlin</groupId>
    <artifactId>kotlin-reflect</artifactId>
    <version>1.9.22</version>
</dependency>

import kotlin.reflect.KClass
import kotlin.reflect.full.*

// 간단한 클래스 정의
class Person(val name: String, var age: Int) {
    fun introduce() = "안녕, 나는 $name이고, $age살이야."
    private fun secretMethod() = "이건 비밀이야!"
}

fun main() {
    // 클래스 참조 얻기
    val personClass: KClass<Person> = Person::class
    
    // 클래스 이름 출력
    println("클래스 이름: ${personClass.simpleName}")  // 출력: 클래스 이름: Person
    
    // 생성자 정보 얻기
    val constructor = personClass.primaryConstructor
    println("생성자 파라미터: ${constructor?.parameters?.joinToString { it.name ?: "" }}")
    
    // 프로퍼티 목록 얻기
    val properties = personClass.memberProperties
    println("프로퍼티 목록: ${properties.joinToString { it.name }}")
    
    // 함수 목록 얻기
    val functions = personClass.memberFunctions
    println("함수 목록: ${functions.joinToString { it.name }}")
    
    // 객체 생성 및 함수 호출
    val person = Person("코틀린", 11)
    val introduceFunc = Person::introduce
    println(introduceFunc.invoke(person))  // 출력: 안녕, 나는 코틀린이고, 11살이야.
}

// 1. 클래스 이름으로 직접 참조 얻기
val personClass = Person::class

// 2. 객체로부터 클래스 참조 얻기
val person = Person("코틀린", 11)
val personClassFromObj = person::class

val personClass = Person::class

// 클래스 기본 정보
println("클래스 이름: ${personClass.simpleName}")
println("패키지: ${personClass.java.`package`?.name ?: "default package"}")
println("추상 클래스인가? ${personClass.isAbstract}")
println("데이터 클래스인가? ${personClass.isData}")
println("내부 클래스인가? ${personClass.isInner}")
println("Companion 객체가 있는가? ${personClass.companionObject != null}")

// 상속 관계 확인
println("슈퍼클래스: ${personClass.supertypes.joinToString()}")
println("모든 슈퍼타입: ${personClass.allSupertypes.joinToString()}")

// 가시성 확인
println("가시성: ${personClass.visibility}")

// 제네릭 타입 파라미터
println("타입 파라미터: ${personClass.typeParameters.joinToString { it.name }}")

import kotlin.reflect.full.primaryConstructor

fun main() {
    val personClass = Person::class
    
    // 기본 생성자 가져오기
    val constructor = personClass.primaryConstructor
    
    if (constructor != null) {
        // 생성자 파라미터 정보 출력
        println("생성자 파라미터:")
        constructor.parameters.forEach { param ->
            println("- ${param.name}: ${param.type}")
        }
        
        // 객체 생성하기
        val person = constructor.call("리플렉션", 3)
        println("생성된 객체: $person")
        println("자기소개: ${person.introduce()}")
    }
}

fun examineObject(any: Any) {
    val kClass = any::class
    
    println("객체 타입: ${kClass.qualifiedName}")
    
    when (any) {
        is Person -> println("이 객체는 Person 타입이고, 이름은 ${any.name}이야.")
        is String -> println("이 객체는 String 타입이고, 길이는 ${any.length}야.")
        is List<*> -> println("이 객체는 List 타입이고, 크기는 ${any.size}야.")
        else -> println("알 수 없는 타입의 객체야.")
    }
    
    // 특정 인터페이스 구현 여부 확인
    if (kClass.java.interfaces.any { it.name == "java.io.Serializable" }) {
        println("이 객체는 Serializable을 구현했어.")
    }
}

import kotlin.reflect.KFunction
import kotlin.reflect.full.functions
import kotlin.reflect.full.memberFunctions

class Calculator {
    fun add(a: Int, b: Int): Int = a + b
    fun multiply(a: Int, b: Int): Int = a * b
    private fun secretOperation(x: Int): Int = x * x * x
}

fun main() {
    val calculator = Calculator()
    val calculatorClass = Calculator::class
    
    // 1. 클래스에서 모든 함수 가져오기
    val allFunctions = calculatorClass.memberFunctions
    println("모든 함수: ${allFunctions.joinToString { it.name }}")
    
    // 2. 특정 이름의 함수 찾기
    val addFunction = calculatorClass.functions.find { it.name == "add" }
    
    if (addFunction != null) {
        // 함수 정보 출력
        println("함수 이름: ${addFunction.name}")
        println("반환 타입: ${addFunction.returnType}")
        println("파라미터: ${addFunction.parameters.joinToString { "${it.name}: ${it.type}" }}")
        
        // 함수 호출하기
        val result = addFunction.call(calculator, 10, 20)
        println("10 + 20 = $result")  // 출력: 10 + 20 = 30
    }
    
    // 3. private 함수에 접근하기
    val secretFunction = calculatorClass.functions.find { it.name == "secretOperation" }
    if (secretFunction != null) {
        // 접근 제한 우회하기
        secretFunction.isAccessible = true
        val result = secretFunction.call(calculator, 4)
        println("비밀 연산 결과: $result")  // 출력: 비밀 연산 결과: 64
    }
}

val calculator = Calculator()

// 클래스의 함수 참조 얻기
val addRef = Calculator::add
val result1 = addRef.invoke(calculator, 5, 7)  // 12

// 특정 인스턴스에 바인딩된 함수 참조
val boundAddRef = calculator::add
val result2 = boundAddRef.invoke(5, 7)  // 12 (인스턴스가 이미 바인딩되어 있음)

// 최상위 함수 참조
fun square(n: Int): Int = n * n
val squareRef = ::square
val result3 = squareRef.invoke(4)  // 16

import kotlin.reflect.KProperty1
import kotlin.reflect.full.memberProperties
import kotlin.reflect.jvm.isAccessible

class User(val username: String, private var _password: String, var email: String) {
    val isAdmin: Boolean get() = username == "admin"
}

fun main() {
    val user = User("kotlin", "secret123", "kotlin@example.com")
    val userClass = User::class
    
    // 1. 모든 프로퍼티 가져오기
    val properties = userClass.memberProperties
    println("모든 프로퍼티: ${properties.joinToString { it.name }}")
    
    // 2. 특정 프로퍼티 찾기
    val emailProperty = userClass.memberProperties.find { it.name == "email" }
    
    if (emailProperty != null) {
        // 프로퍼티 정보 출력
        println("프로퍼티 이름: ${emailProperty.name}")
        println("프로퍼티 타입: ${emailProperty.returnType}")
        
        // 프로퍼티 값 읽기
        val email = emailProperty.get(user)
        println("이메일: $email")  // 출력: 이메일: kotlin@example.com
        
        // 프로퍼티 값 변경하기 (가변 프로퍼티인 경우)
        if (emailProperty is kotlin.reflect.KMutableProperty1) {
            emailProperty.set(user, "new.kotlin@example.com")
            println("변경된 이메일: ${emailProperty.get(user)}")
        }
    }
    
    // 3. private 프로퍼티 접근하기
    val passwordProperty = userClass.memberProperties.find { it.name == "_password" }
    if (passwordProperty != null) {
        // 접근 제한 우회하기
        passwordProperty.isAccessible = true
        val password = passwordProperty.get(user)
        println("비밀번호: $password")  // 출력: 비밀번호: secret123
    }
    
    // 4. 계산 프로퍼티 접근하기
    val isAdminProperty = userClass.memberProperties.find { it.name == "isAdmin" }
    if (isAdminProperty != null) {
        val isAdmin = isAdminProperty.get(user)
        println("관리자 여부: $isAdmin")  // 출력: 관리자 여부: false
    }
}

// 필드 검증용 애노테이션
@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class MaxLength(val length: Int)

// HTTP 요청 매핑용 애노테이션
@Target(AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
annotation class HttpEndpoint(val path: String, val method: String = "GET")

// 직렬화 제외 애노테이션
@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class Exclude

class UserProfile(
    @MaxLength(50) val username: String,
    @MaxLength(100) val bio: String,
    @Exclude val internalId: String
) {
    @HttpEndpoint("/profile", "GET")
    fun getProfile(): Map<String, String> {
        return mapOf("username" to username, "bio" to bio)
    }
    
    @HttpEndpoint("/profile", "PUT")
    fun updateProfile(newBio: String) {
        // 업데이트 로직
    }
}

import kotlin.reflect.full.findAnnotation
import kotlin.reflect.full.hasAnnotation
import kotlin.reflect.full.memberFunctions
import kotlin.reflect.full.memberProperties

fun main() {
    val userProfileClass = UserProfile::class
    
    // 1. 프로퍼티의 애노테이션 확인하기
    println("=== 프로퍼티 애노테이션 ===")
    userProfileClass.memberProperties.forEach { property ->
        // MaxLength 애노테이션 확인
        val maxLengthAnnotation = property.findAnnotation<MaxLength>()
        if (maxLengthAnnotation != null) {
            println("${property.name}: 최대 길이는 ${maxLengthAnnotation.length}자")
        }
        
        // Exclude 애노테이션 확인
        if (property.hasAnnotation<Exclude>()) {
            println("${property.name}: 직렬화에서 제외됨")
        }
    }
    
    // 2. 함수의 애노테이션 확인하기
    println("\n=== 함수 애노테이션 ===")
    userProfileClass.memberFunctions.forEach { function ->
        val httpEndpoint = function.findAnnotation<HttpEndpoint>()
        if (httpEndpoint != null) {
            println("${function.name}: ${httpEndpoint.method} ${httpEndpoint.path}")
        }
    }
    
    // 3. 애노테이션 기반 검증 로직 구현하기
    val user = UserProfile(
        username = "verylongusernamethatexceedsthelimit",
        bio = "Hello!",
        internalId = "12345"
    )
    
    validateObject(user)
}

// 객체 검증 함수
fun validateObject(obj: Any) {
    println("\n=== 객체 검증 ===")
    val kClass = obj::class
    
    kClass.memberProperties.forEach { property ->
        val maxLengthAnnotation = property.findAnnotation<MaxLength>()
        if (maxLengthAnnotation != null) {
            val value = property.get(obj) as? String
            if (value != null && value.length > maxLengthAnnotation.length) {
                println("검증 실패: ${property.name}의 길이가 ${value.length}로, 최대 허용 길이 ${maxLengthAnnotation.length}를 초과함")
            }
        }
    }
}

// 간단한 HTTP 라우터 구현
class SimpleHttpRouter {
    private val routes = mutableMapOf<Pair<String, String>, (Any, Map<String, Any>) -> Any>()
    
    // 컨트롤러 등록 함수
    fun registerController(controllerClass: KClass<*>) {
        val instance = controllerClass.constructors.first().call()
        
        controllerClass.memberFunctions.forEach { function ->
            val endpoint = function.findAnnotation<HttpEndpoint>() ?: return@forEach
            
            val routeKey = Pair(endpoint.method, endpoint.path)
            routes[routeKey] = { controller, params ->
                function.call(controller, *params.values.toTypedArray())
            }
            
            println("라우트 등록: ${endpoint.method} ${endpoint.path} -> ${function.name}")
        }
    }
    
    // 요청 처리 함수
    fun handleRequest(method: String, path: String, params: Map<String, Any> = emptyMap()): Any? {
        val routeKey = Pair(method, path)
        val handler = routes[routeKey]
        
        return handler?.invoke(instance, params)
    }
}

// 사용 예시
class UserController {
    @HttpEndpoint("/users", "GET")
    fun getUsers(): List<String> {
        return listOf("User1", "User2", "User3")
    }
    
    @HttpEndpoint("/users/{id}", "GET")
    fun getUser(id: String): String {
        return "User $id details"
    }
    
    @HttpEndpoint("/users", "POST")
    fun createUser(name: String, email: String): String {
        return "User created: $name ($email)"
    }
}

fun main() {
    val router = SimpleHttpRouter()
    router.registerController(UserController::class)
    
    // 요청 시뮬레이션
    val users = router.handleRequest("GET", "/users")
    println("결과: $users")
    
    val userDetails = router.handleRequest("GET", "/users/{id}", mapOf("id" to "42"))
    println("결과: $userDetails")
    
    val createResult = router.handleRequest("POST", "/users", 
                                          mapOf("name" to "코틀린", "email" to "kotlin@example.com"))
    println("결과: $createResult")
}

// 제네릭 클래스 예시
class Box<T>(val value: T)

fun main() {
    val stringBox = Box("Hello")
    val intBox = Box(42)
    
    // 런타임에는 두 객체의 클래스가 동일하게 보임
    println(stringBox::class == intBox::class)  // true
    
    // 타입 파라미터 정보는 소거됨
    println(stringBox::class.java.typeParameters)  // [T]
    println(intBox::class.java.typeParameters)    // [T]
}

import kotlin.reflect.KClass
import kotlin.reflect.full.createInstance

// 제네릭 타입 토큰 활용 예시
inline fun <reified T : Any> createInstance(): T {
    return T::class.createInstance()
}

// 타입 토큰을 매개변수로 받는 함수
fun <T : Any> deserialize(json: String, clazz: KClass<T>): T {
    // JSON을 파싱하여 객체로 변환하는 로직
    println("${clazz.simpleName} 타입으로 역직렬화: $json")
    
    // 간단한 구현을 위해 createInstance 사용
    return clazz.createInstance()
}

// reified 타입 파라미터를 사용한 버전
inline fun <reified T : Any> deserializeReified(json: String): T {
    return deserialize(json, T::class)
}

class User(val name: String = "기본이름", val age: Int = 0)
class Product(val id: String = "기본ID", val price: Double = 0.0)

fun main() {
    // KClass를 직접 전달하는 방식
    val user = deserialize("""{"name":"코틀린","age":11}""", User::class)
    println(user)  // User(name="기본이름", age=0)
    
    // reified 타입 파라미터를 사용한 방식
    val product = deserializeReified<Product>("""{"id":"kotlin-book","price":29.99}""")
    println(product)  // Product(id="기본ID", price=0.0)
    
    // createInstance 사용 예시
    val newUser = createInstance<User>()
    println(newUser)  // User(name="기본이름", age=0)
}

import kotlin.reflect.full.functions
import kotlin.reflect.full.memberProperties
import kotlin.reflect.jvm.javaType
import kotlin.reflect.jvm.jvmErasure

class Repository<T> {
    private val items = mutableListOf<T>()
    
    fun add(item: T) {
        items.add(item)
    }
    
    fun getAll(): List<T> {
        return items.toList()
    }
    
    fun <R> map(transform: (T) -> R): List<R> {
        return items.map(transform)
    }
}

class GenericHolder {
    val stringList: List<String> = listOf("a", "b", "c")
    val intMap: Map<Int, String> = mapOf(1 to "one", 2 to "two")
    
    fun <T> process(item: T): T {
        return item
    }
}

fun main() {
    val holderClass = GenericHolder::class
    
    // 제네릭 프로퍼티 분석
    println("=== 제네릭 프로퍼티 분석 ===")
    holderClass.memberProperties.forEach { property ->
        println("${property.name}: ${property.returnType}")
        
        // 제네릭 타입의 인자 정보 가져오기
        val typeArguments = property.returnType.arguments
        if (typeArguments.isNotEmpty()) {
            println("  제네릭 타입 인자:")
            typeArguments.forEach { typeArg ->
                println("  - ${typeArg.type}")
            }
        }
    }
    
    // 제네릭 함수 분석
    println("\n=== 제네릭 함수 분석 ===")
    val processFunction = holderClass.functions.find { it.name == "process" }
    if (processFunction != null) {
        println("함수: ${processFunction.name}")
        println("타입 파라미터: ${processFunction.typeParameters.joinToString { it.name }}")
        println("파라미터: ${processFunction.parameters.drop(1).joinToString { "${it.name}: ${it.type}" }}")
        println("반환 타입: ${processFunction.returnType}")
    }
    
    // Repository 클래스 분석
    println("\n=== Repository 클래스 분석 ===")
    val repoClass = Repository::class
    println("클래스 타입 파라미터: ${repoClass.typeParameters.joinToString { it.name }}")
    
    val getAllFunction = repoClass.functions.find { it.name == "getAll" }
    if (getAllFunction != null) {
        println("getAll() 반환 타입: ${getAllFunction.returnType}")
        println("반환 타입의 JVM 소거 타입: ${getAllFunction.returnType.jvmErasure}")
        println("반환 타입의 Java 타입: ${getAllFunction.returnType.javaType}")
    }
}

import kotlin.reflect.KClass
import kotlin.reflect.full.isSubclassOf
import kotlin.reflect.full.isSuperclassOf

// 타입 안전한 컨테이너 클래스
class TypeSafeMap {
    private val map = mutableMapOf<KClass<*>, Any>()
    
    // 값 저장 (타입 안전)
    fun <T : Any> set(clazz: KClass<T>, value: T) {
        map[clazz] = value
    }
    
    // 값 조회 (타입 안전)
    @Suppress("UNCHECKED_CAST")
    fun <T : Any> get(clazz: KClass<T>): T? {
        val value = map[clazz]
        
        // 타입 검사
        if (value != null && clazz.isInstance(value)) {
            return value as T
        }
        return null
    }
    
    // 상속 관계까지 고려한 조회
    @Suppress("UNCHECKED_CAST")
    fun <T : Any> getCompatible(clazz: KClass<T>): T? {
        // 정확히 일치하는 타입이 있으면 반환
        val exactMatch = get(clazz)
        if (exactMatch != null) return exactMatch
        
        // 호환 가능한 타입 찾기
        for ((storedClass, value) in map) {
            if (storedClass.isSubclassOf(clazz) && clazz.isInstance(value)) {
                return value as T
            }
        }
        
        return null
    }
}

// 테스트용 클래스 계층
open class Animal
class Dog : Animal()
class Cat : Animal()

fun main() {
    val container = TypeSafeMap()
    
    // 다양한 타입의 객체 저장
    container.set(String::class, "Hello Kotlin")
    container.set(Int::class, 42)
    container.set(Dog::class, Dog())
    
    // 타입 안전하게 조회
    val str = container.get(String::class)
    println("String 값: $str")  // String 값: Hello Kotlin
    
    val num = container.get(Int::class)
    println("Int 값: $num")  // Int 값: 42
    
    val dog = container.get(Dog::class)
    println("Dog 객체: ${dog?.javaClass?.simpleName}")  // Dog 객체: Dog
    
    // 존재하지 않는 타입
    val cat = container.get(Cat::class)
    println("Cat 객체: $cat")  // Cat 객체: null
    
    // 상속 관계 활용
    val animal = container.getCompatible(Animal::class)
    println("Animal 호환 객체: ${animal?.javaClass?.simpleName}")  // Animal 호환 객체: Dog
}

import kotlin.reflect.KClass
import kotlin.reflect.full.createInstance
import kotlin.reflect.full.findAnnotation
import kotlin.reflect.full.primaryConstructor

// 의존성 주입 관련 애노테이션
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class Component

@Target(AnnotationTarget.CONSTRUCTOR, AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class Inject

@Target(AnnotationTarget.VALUE_PARAMETER)
@Retention(AnnotationRetention.RUNTIME)
annotation class Value(val value: String)

// 간단한 DI 컨테이너
class DIContainer {
    private val components = mutableMapOf<KClass<*>, Any>()
    
    // 컴포넌트 등록
    fun <T : Any> register(clazz: KClass<T>, instance: T) {
        components[clazz] = instance
    }
    
    // 컴포넌트 조회
    @Suppress("UNCHECKED_CAST")
    fun <T : Any> get(clazz: KClass<T>): T {
        // 이미 등록된 인스턴스가 있으면 반환
        components[clazz]?.let { return it as T }
        
        // 클래스에 @Component 애노테이션이 있는지 확인
        if (clazz.findAnnotation<Component>() == null) {
            throw IllegalArgumentException("${clazz.simpleName}는 @Component로 등록되지 않았습니다.")
        }
        
        // 생성자 찾기
        val constructor = clazz.primaryConstructor
            ?: throw IllegalArgumentException("${clazz.simpleName}에 기본 생성자가 없습니다.")
        
        // 생성자 파라미터 분석
        val parameters = constructor.parameters
        val arguments = parameters.map { param ->
            // @Value 애노테이션이 있으면 해당 값 사용
            param.findAnnotation<Value>()?.let { return@map it.value }
            
            // 아니면 타입에 맞는 컴포넌트 조회
            val paramType = param.type.classifier as? KClass<*>
                ?: throw IllegalArgumentException("${param.name}의 타입을 결정할 수 없습니다.")
            
            // 재귀적으로 의존성 해결
            get(paramType)
        }.toTypedArray()
        
        // 인스턴스 생성 및 등록
        val instance = constructor.call(*arguments)
        register(clazz, instance)
        return instance
    }
    
    // 타입 안전한 버전
    inline fun <reified T : Any> get(): T = get(T::class)
    
    // 컴포넌트 스캔 (패키지 내 모든 @Component 클래스 등록)
    fun scanComponents(packageName: String) {
        // 실제 구현에서는 클래스패스 스캐닝 로직이 필요함
        println("$packageName 패키지의 컴포넌트를 스캔합니다...")
        // 여기서는 예시로 몇 가지 클래스만 등록
    }
}

// 테스트용 클래스들
@Component
class UserRepository {
    fun findAll(): List<String> = listOf("User1", "User2", "User3")
}

@Component
class UserService(private val repository: UserRepository) {
    fun getUsers(): List<String> = repository.findAll()
}

@Component
class UserController(
    private val service: UserService,
    @Value("api/v1") private val apiPath: String
) {
    fun listUsers(): String {
        return "$apiPath/users: ${service.getUsers().joinToString()}"
    }
}

fun main() {
    val container = DIContainer()
    
    // 수동 등록
    container.register(UserRepository::class, UserRepository())
    
    // 자동 의존성 주입으로 인스턴스 얻기
    val controller = container.get<UserController>()
    println(controller.listUsers())  // 출력: api/v1/users: User1, User2, User3
    
    // 컴포넌트 스캔 (실제 구현에서는 패키지 내 모든 @Component 클래스를 찾아 등록)
    container.scanComponents("com.example")
}

import kotlin.reflect.KClass
import kotlin.reflect.full.memberProperties
import kotlin.reflect.full.primaryConstructor

// JSON 직렬화 제외 애노테이션
@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class JsonExclude

// 프로퍼티 이름 변경 애노테이션
@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class JsonProperty(val name: String)

// 간단한 JSON 변환기
class SimpleJsonConverter {
    // 객체를 JSON 문자열로 변환
    fun toJson(obj: Any): String {
        val kClass = obj::class
        val properties = kClass.memberProperties
        
        val jsonProps = properties
            .filter { prop -> prop.findAnnotation<JsonExclude>() == null }
            .map { prop ->
                val jsonName = prop.findAnnotation<JsonProperty>()?.name ?: prop.name
                val value = prop.get(obj)
                "\"$jsonName\": ${valueToJson(value)}"
            }
        
        return "{${jsonProps.joinToString(", ")}}"
    }
    
    // 값을 JSON 형식으로 변환
    private fun valueToJson(value: Any?): String {
        return when (value) {
            null -> "null"
            is String -> "\"$value\""
            is Number, is Boolean -> value.toString()
            is Collection<*> -> "[${value.joinToString(", ") { valueToJson(it) }}]"
            is Map<*, *> -> {
                val entries = value.entries.joinToString(", ") { (k, v) ->
                    "\"$k\": ${valueToJson(v)}"
                }
                "{$entries}"
            }
            else -> toJson(value)  // 중첩 객체
        }
    }
    
    // JSON 문자열을 객체로 변환 (간소화된 버전)
    inline fun <reified T : Any> fromJson(json: String): T {
        return fromJson(json, T::class)
    }
    
    // 실제 역직렬화 구현 (매우 간소화됨)
    fun <T : Any> fromJson(json: String, clazz: KClass<T>): T {
        // 실제 구현에서는 JSON 파싱 로직이 필요함
        println("JSON 파싱 중: $json -> ${clazz.simpleName}")
        
        // 여기서는 예시를 위해 기본 생성자로 인스턴스만 생성
        val constructor = clazz.primaryConstructor
            ?: throw IllegalArgumentException("${clazz.simpleName}에 기본 생성자가 없습니다.")
        
        // 모든 파라미터에 기본값 사용 (실제로는 JSON에서 값을 추출해야 함)
        val instance = constructor.callBy(emptyMap())
        
        // 실제 구현에서는 여기서 JSON 값을 객체의 프로퍼티에 설정해야 함
        return instance
    }
}

// 테스트용 클래스
data class Person(
    val name: String,
    val age: Int,
    @JsonProperty("emailAddress") val email: String,
    @JsonExclude val password: String
)

data class Team(
    val name: String,
    val members: List<Person>,
    val stats: Map<String, Int>
)

fun main() {
    val converter = SimpleJsonConverter()
    
    // 객체 -> JSON
    val person = Person("코틀린", 11, "kotlin@example.com", "secret123")
    val personJson = converter.toJson(person)
    println("Person JSON: $personJson")
    
    // 복잡한 객체 -> JSON
    val team = Team(
        "코틀린 팀",
        listOf(
            Person("코틀린", 11, "kotlin@example.com", "pass1"),
            Person("자바", 26, "java@example.com", "pass2")
        ),
        mapOf("wins" to 10, "losses" to 2)
    )
    val teamJson = converter.toJson(team)
    println("Team JSON: $teamJson")
    
    // JSON -> 객체 (실제 구현에서는 JSON 파싱 후 객체 생성)
    val newPerson = converter.fromJson<Person>(personJson)
    println("역직렬화된 Person: $newPerson")
}

import kotlin.reflect.KClass
import kotlin.reflect.full.findAnnotation
import kotlin.reflect.full.functions
import kotlin.reflect.full.hasAnnotation
import kotlin.reflect.full.memberFunctions

// 테스트 관련 애노테이션
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class TestClass

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

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

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

// 간단한 테스트 러너
class SimpleTestRunner {
    fun runTests(testClass: KClass<*>) {
        // 테스트 클래스 확인
        if (!testClass.hasAnnotation<TestClass>()) {
            println("${testClass.simpleName}는 @TestClass 애노테이션이 없습니다.")
            return
        }
        
        println("테스트 시작: ${testClass.simpleName}")
        
        // 테스트 인스턴스 생성
        val testInstance = testClass.constructors.first().call()
        
        // 모든 함수 찾기
        val allFunctions = testClass.memberFunctions
        val beforeEachFunctions = allFunctions.filter { it.hasAnnotation<BeforeEach>() }
        val testFunctions = allFunctions.filter { it.hasAnnotation<Test>() }
        val afterEachFunctions = allFunctions.filter { it.hasAnnotation<AfterEach>() }
        
        var passed = 0
        var failed = 0
        
        // 각 테스트 함수 실행
        for (testFunction in testFunctions) {
            println("  실행 중: ${testFunction.name}")
            
            try {
                // BeforeEach 함수 실행
                for (before in beforeEachFunctions) {
                    before.call(testInstance)
                }
                
                // 테스트 함수 실행
                testFunction.call(testInstance)
                
                // 테스트 성공
                println("    ✅ 성공")
                passed++
            } catch (e: Exception) {
                // 테스트 실패
                println("    ❌ 실패: ${e.message}")
                failed++
            } finally {
                // AfterEach 함수 실행
                for (after in afterEachFunctions) {
                    try {
                        after.call(testInstance)
                    } catch (e: Exception) {
                        println("    ⚠️ AfterEach 실패: ${e.message}")
                    }
                }
            }
        }
        
        // 결과 출력
        println("테스트 완료: 성공 $passed, 실패 $failed")
    }
    
    // 타입 안전한 버전
    inline fun <reified T : Any> runTests() = runTests(T::class)
}

// 테스트 클래스 예시
@TestClass
class CalculatorTest {
    private lateinit var calculator: Calculator
    
    @BeforeEach
    fun setup() {
        calculator = Calculator()
        println("    🔧 Calculator 인스턴스 생성됨")
    }
    
    @Test
    fun testAddition() {
        val result = calculator.add(2, 3)
        if (result != 5) {
            throw AssertionError("2 + 3 = 5여야 하는데, $result가 반환됨")
        }
    }
    
    @Test
    fun testMultiplication() {
        val result = calculator.multiply(2, 3)
        if (result != 6) {
            throw AssertionError("2 * 3 = 6이어야 하는데, $result가 반환됨")
        }
    }
    
    @Test
    fun testDivision() {
        val result = calculator.divide(6, 2)
        if (result != 3) {
            throw AssertionError("6 / 2 = 3이어야 하는데, $result가 반환됨")
        }
    }
    
    @Test
    fun testDivisionByZero() {
        try {
            calculator.divide(6, 0)
            throw AssertionError("0으로 나누기 시 예외가 발생해야 함")
        } catch (e: ArithmeticException) {
            // 예상대로 예외 발생
        }
    }
    
    @AfterEach
    fun cleanup() {
        println("    🧹 테스트 정리 완료")
    }
}

// 테스트 대상 클래스
class Calculator {
    fun add(a: Int, b: Int): Int = a + b
    fun multiply(a: Int, b: Int): Int = a * b
    fun divide(a: Int, b: Int): Int = a / b  // 0으로 나누면 ArithmeticException 발생
}

fun main() {
    val runner = SimpleTestRunner()
    runner.runTests<CalculatorTest>()
}

import kotlin.reflect.full.memberFunctions
import kotlin.system.measureTimeMillis

class PerformanceTest {
    fun directMethod(iterations: Int): Int {
        var sum = 0
        for (i in 0 until iterations) {
            sum += i
        }
        return sum
    }
}

fun main() {
    val test = PerformanceTest()
    val iterations = 1_000_000
    
    // 직접 호출 성능 측정
    val directTime = measureTimeMillis {
        for (i in 0..100) {
            test.directMethod(iterations)
        }
    }
    println("직접 호출 시간: $directTime ms")
    
    // 리플렉션 호출 성능 측정
    val method = PerformanceTest::class.memberFunctions.first { it.name == "directMethod" }
    val reflectionTime = measureTimeMillis {
        for (i in 0..100) {
            method.call(test, iterations)
        }
    }
    println("리플렉션 호출 시간: $reflectionTime ms")
    
    // 차이 계산
    val ratio = reflectionTime.toDouble() / directTime
    println("리플렉션은 직접 호출보다 약 ${String.format("%.2f", ratio)}배 느림")
}

import kotlin.reflect.KClass
import kotlin.reflect.KFunction
import kotlin.reflect.KProperty1
import kotlin.reflect.full.memberFunctions
import kotlin.reflect.full.memberProperties
import kotlin.system.measureTimeMillis

class ReflectionOptimization {
    // 리플렉션 정보 캐싱
    class ReflectionCache<T : Any>(private val kClass: KClass<T>) {
        // 프로퍼티 캐시
        private val propertyCache = mutableMapOf<String, KProperty1<T, *>>()
        
        // 함수 캐시
        private val functionCache = mutableMapOf<String, KFunction<*>>()
        
        // 프로퍼티 조회 (캐시 활용)
        fun getProperty(name: String): KProperty1<T, *>? {
            return propertyCache.getOrPut(name) {
                kClass.memberProperties.find { it.name == name } ?: return null
            }
        }
        
        // 함수 조회 (캐시 활용)
        fun getFunction(name: String): KFunction<*>? {
            return functionCache.getOrPut(name) {
                kClass.memberFunctions.find { it.name == name } ?: return null
            }
        }
    }
    
    // 테스트용 클래스
    class User(val name: String, val age: Int) {
        fun greet(): String = "안녕, 나는 $name이고, $age살이야."
        fun calculateBirthYear(currentYear: Int): Int = currentYear - age
    }
    
    fun main() {
        val user = User("코틀린", 11)
        val iterations = 10_000
        
        // 캐시 없이 리플렉션 사용
        val noCacheTime = measureTimeMillis {
            for (i in 0 until iterations) {
                val nameProperty = User::class.memberProperties.find { it.name == "name" }
                val greetFunction = User::class.memberFunctions.find { it.name == "greet" }
                
                nameProperty?.get(user)
                greetFunction?.call(user)
            }
        }
        println("캐시 없는 리플렉션 시간: $noCacheTime ms")
        
        // 캐시를 사용한 리플렉션
        val cache = ReflectionCache(User::class)
        val cacheTime = measureTimeMillis {
            for (i in 0 until iterations) {
                val nameProperty = cache.getProperty("name")
                val greetFunction = cache.getFunction("greet")
                
                nameProperty?.get(user)
                greetFunction?.call(user)
            }
        }
        println("캐시 사용 리플렉션 시간: $cacheTime ms")
        
        // 개선율 계산
        val improvement = (noCacheTime - cacheTime) * 100.0 / noCacheTime
        println("성능 개선: ${String.format("%.2f", improvement)}%")
    }
}

import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty

// 1. 위임 프로퍼티 (Delegated Properties)
class User(val map: MutableMap<String, Any?>) {
    var name: String by map
    var age: Int by map
}

// 2. 커스텀 위임 (Custom Delegation)
class ValidatedProperty<T>(private var value: T, private val validator: (T) -> Boolean) : ReadWriteProperty<Any?, T> {
    override fun getValue(thisRef: Any?, property: KProperty<*>): T = value
    
    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        if (validator(value)) {
            this.value = value
        } else {
            throw IllegalArgumentException("Invalid value for ${property.name}: $value")
        }
    }
}

// 사용 예시
class Person {
    var name: String by ValidatedProperty("") { it.isNotBlank() }
    var age: Int by ValidatedProperty(0) { it >= 0 }
}

// 3. 인라인 함수와 reified 타입 파라미터
inline fun <reified T> Any.castTo(): T {
    return this as T
}

// 4. 함수형 프로그래밍 접근법
fun processObject(obj: Any, processor: (Any) -> Unit) {
    processor(obj)
}

fun main() {
    // 위임 프로퍼티 사용
    val userData = mutableMapOf(
        "name" to "코틀린",
        "age" to 11
    )
    val user = User(userData)
    println("이름: ${user.name}, 나이: ${user.age}")
    
    // 값 변경
    user.age = 12
    println("변경된 맵: $userData")  // 맵도 함께 업데이트됨
    
    // 커스텀 위임 사용
    val person = Person()
    person.name = "코틀린"
    person.age = 11
    println("사람: 이름=${person.name}, 나이=${person.age}")
    
    try {
        person.age = -1  // 유효성 검사 실패
    } catch (e: IllegalArgumentException) {
        println("예외 발생: ${e.message}")
    }
    
    // 인라인 함수와 reified 타입 파라미터
    val any: Any = "Hello"
    val str = any.castTo<String>()
    println("캐스팅 결과: $str")
    
    // 함수형 접근법
    processObject(user) { obj ->
        when (obj) {
            is User -> println("User 객체: 이름=${obj.name}")
            is Person -> println("Person 객체: 이름=${obj.name}")
            else -> println("알 수 없는 객체 타입")
        }
    }
}