리플렉션
_리플렉션(Reflection)_은 런타임에 프로그램의 구조를 검사(introspect)할 수 있게 해주는 언어 및 라이브러리 기능 모음입니다. 예를 들어, 프로퍼티를 읽거나 업데이트하고, 함수를 호출하거나, 클래스 생성자를 호출하여 인스턴스를 생성할 수 있습니다. 이는 컴파일 시점에 선언을 알 수 없을 때 유용합니다.
리플렉션은 컴파일된 선언을 설명하는 런타임 객체를 제공합니다. 예를 들어 클래스는 KClass로, 타입은 KType으로, 프로퍼티나 함수는 KCallable의 서브타입으로 표현됩니다. 이러한 객체를 검사하여 값에 접근하거나 함수를 호출하는 데 사용할 수 있습니다.
리플렉션의 동작 원리
리플렉션 API는 KClass나 KFunction과 같은 Kotlin 타입을 통해 컴파일된 선언을 나타냅니다. 리플렉션 객체는 선언된 객체의 값이 아니라 선언 자체를 나타냅니다. 예를 들어 KProperty를 사용하면 객체에서 해당 프로퍼티의 값을 읽지 않고도 프로퍼티의 이름을 가져오고 반환 타입을 얻을 수 있습니다.
Kotlin은 클래스 리터럴이나 호출 가능한 참조(callable reference)와 같은 일부 기본적인 기능을 언어 및 표준 라이브러리의 일부로 제공합니다. 더 광범위한 런타임 인트로스펙션을 사용하려면 kotlin-reflect 라이브러리를 임포트해야 합니다.
리플렉션 API는 다음과 같은 패키지로 구성됩니다:
kotlin.reflect: 표준 라이브러리의 일부이며 핵심 리플렉션 타입과 함수를 포함합니다.kotlin.reflect.full: Kotlin 선언을 검사하기 위한 확장 기능을 제공합니다.kotlin.reflect.jvm: Kotlin과 Java 리플렉션을 연결하는 JVM 전용 확장 기능을 제공합니다.
플랫폼마다 리플렉션 지원 수준이 다를 수 있습니다. 이 페이지는 Kotlin/JVM 리플렉션 API를 기준으로 설명합니다. Kotlin/JS에서의 리플렉션에 대해서도 자세히 알아볼 수 있습니다.
Java 리플렉션과의 상호 운용성
JVM에서 kotlin-reflect 라이브러리는 Kotlin과 Java 리플렉션 객체 간의 상호 변환을 위해 kotlin.reflect.jvm 패키지의 확장 기능을 제공합니다. 예를 들어, Kotlin 프로퍼티 게터를 구현하는 Java 메서드와 프로퍼티의 뒷받침하는 필드(backing field)를 찾을 수 있습니다:
import kotlin.reflect.jvm.*
class User(val name: String)
fun main() {
println(User::name.javaGetter)
// public final java.lang.String User.getName()
println(User::name.javaField)
// private final java.lang.String User.name
}Kotlin 프로퍼티에 항상 대응하는 Java 필드나 게터가 있는 것은 아니므로, 일치하는 Java 리플렉션 객체가 없으면 두 프로퍼티 모두 null을 반환합니다.
또한 Kotlin KClass와 Java Class 객체 간에도 상호 변환할 수 있습니다. Java 클래스에 해당하는 Kotlin 클래스를 가져오려면 .kotlin 확장 프로퍼티를 사용하세요:
fun getKClass(o: Any): KClass<Any> = value.javaClass.kotlin런타임 클래스 얻기
대부분의 리플렉션 작업은 KClass에서 시작됩니다. 이를 얻는 방법은 해당 클래스를 컴파일 타임에 알고 있는지 여부에 따라 다릅니다:
- 컴파일 타임에 알려진 클래스를 참조하려면
ClassName::class를 사용합니다. - 런타임 값의 실제 클래스를 얻으려면
value::class를 사용합니다. 이 클래스는 선언된 타입보다 더 구체적일 수 있습니다.
import kotlin.reflect.KClass
class User(val name: String)
open class Language
class Kotlin : Language()
fun main() {
// User를 나타내는 KClass를 반환합니다.
val userClass: KClass<User> = User::class
println(userClass.simpleName)
// User
val language: Language = Kotlin()
// 런타임 시점의 값의 구체적인 클래스를
// 나타내는 KClass를 반환합니다.
val runtimeClass: KClass<out Language> = language::class
println(runtimeClass.simpleName)
// Kotlin
}Kotlin 표준 라이브러리는 클래스를 검사하기 위한 기본적인 도구를 제공합니다. 더 광범위한 런타임 인트로스펙션이 필요하다면 kotlin-reflect 의존성을 추가하고 해당 API를 사용하세요.
JVM 의존성 추가
JVM 플랫폼에서 Kotlin 컴파일러 배포판은 리플렉션 기능을 사용하는 데 필요한 런타임 컴포넌트를 별도의 아티팩트인 kotlin-reflect.jar로 포함합니다. 덕분에 리플렉션 기능을 사용하지 않는 애플리케이션은 이 아티팩트를 제외하여 런타임 클래스패스 크기를 줄일 수 있습니다.
Gradle이나 Maven 프로젝트에서 리플렉션을 사용하려면 kotlin-reflect 의존성을 추가하세요:
dependencies {
implementation(kotlin("reflect"))
}<dependencies>
<dependency>
<groupId>org.jetbrains.kotlin</groupId>
<artifactId>kotlin-reflect</artifactId>
<version>${kotlin.version}</version>
</dependency>
</dependencies>Gradle이나 Maven을 사용하지 않는 경우, 프로젝트 클래스패스에 kotlin-reflect.jar가 포함되어 있는지 확인하세요. 커맨드라인 컴파일러는 이 라이브러리를 기본적으로 추가합니다. 클래스패스에서 제외하려면 -no-reflect 컴파일러 옵션을 사용하세요.
타입 검사
KClass와 KType은 서로 다른 정보를 나타냅니다. KClass는 타입 인자나 널 가능성(nullability)을 보존하지 않고 클래스 자체를 나타냅니다. 예를 들어 List<String>과 List<Int>는 동일한 List::class 표현을 공유하며, String과 String?은 String::class를 공유합니다. 따라서 타입 인자와 널 가능성을 포함하여 정적으로 알려진 타입 T에 대한 KType을 얻으려면 typeOf<T>() 함수를 사용하세요.
다음 예제에서 classifier 프로퍼티는 타입을 해당 클래스 또는 타입 파라미터에 연결합니다. arguments 컬렉션에는 타입 인자가 포함되어 있습니다. 따라서 코드를 통해 List와 별개로 String?을 검사할 수 있습니다:
import kotlin.reflect.typeOf
fun main() {
val type = typeOf<List<String?>>()
println(type.classifier)
// class kotlin.collections.List
println(type.arguments.single().type)
// kotlin.String?
}JVM에서는 소스 코드에서 타입에 애너테이션을 지정했더라도 생성된 타입에 애너테이션이 포함되지 않습니다. 타입 애너테이션에 대한 지원은 향후 kotlin-reflect 라이브러리 버전에 추가될 수 있습니다.
값 확인 및 캐스팅
is, as, as? 연산자는 대상 타입을 코드에 직접 작성할 때 작동합니다. 하지만 대상 클래스를 KClass에 저장하고 있는 경우에는 다음을 사용하세요:
- 값이 해당 클래스의 인스턴스인지 확인하려면
isInstance()함수를 사용합니다.true또는false를 반환합니다. - 대상 타입으로 캐스팅된 값을 반환하려면
cast()함수를 사용합니다. 값이null이거나 호환되지 않는 타입인 경우 예외를 던집니다. - 대상 타입으로 캐스팅된 값을 반환하거나, 값이
null이거나 호환되지 않는 타입인 경우null을 반환하려면safeCast()함수를 사용합니다.
import kotlin.reflect.cast
import kotlin.reflect.safeCast
fun main() {
val expectedClass = String::class
val value: Any = "Kotlin"
// 캐스팅하지 않고 값을 확인합니다
println(expectedClass.isInstance(value))
// true
// 값을 String으로 반환합니다
val text = expectedClass.cast(value)
println(text.length)
// 6
// 호환되지 않는 캐스트는 예외를 던집니다
val failedCast = runCatching {
Int::class.cast(value)
}
println(failedCast.isFailure)
// true
// 세이프 캐스트(safe cast)는 동일한 불일치 상황에 대해 null을 반환합니다
val number = Int::class.safeCast(value)
println(number)
// null
}클래스 검사
KClass를 얻은 후에는 해당 클래스의 멤버를 검사할 수 있습니다. 이를 통해 선언을 사용하기 전에 어떤 선언이 존재하는지 파악할 수 있습니다. 클래스의 함수와 프로퍼티를 검사하려면 members 프로퍼티를 사용하세요. 여기에는 상속된 선언을 포함하여 클래스에서 접근할 수 있는 모든 선언이 담긴 KCallable 객체 컬렉션이 포함됩니다.
예를 들어, 다음 코드는 데이터 클래스에서 접근 가능한 함수와 프로퍼티를 나열합니다:
data class User(val name: String, val age: Int)
fun main() {
println(User::class.members.map { it.name }.sorted())
// [age, component1, component2, copy, equals, hashCode, name, toString]
}kotlin.reflect.full 패키지는 종류(kind), 스코프, 수신 객체(receiver)별로 선언을 필터링하여 선택할 수 있는 보다 구체적인 프로퍼티를 제공합니다:
| 프로퍼티 | 반환값 |
|---|---|
declaredMembers | 상속된 선언을 제외하고 클래스에 직접 선언된 함수 및 프로퍼티 |
functions | 클래스에서 사용 가능한 모든 함수: 클래스 및 상위 클래스의 비정적(non-static) 함수와 클래스에 선언된 정적(static) 함수 |
declaredFunctions | 클래스에 선언된 모든 함수 |
memberFunctions | 클래스 및 상위 클래스에 선언된 비확장(non-extension), 비정적 함수 |
declaredMemberFunctions | 클래스에 선언된 비확장, 비정적 함수 |
memberExtensionFunctions | 클래스 또는 상위 클래스의 멤버로 선언된 확장 함수 |
declaredMemberExtensionFunctions | 클래스에 멤버로 선언된 확장 함수 |
staticFunctions | 클래스에 선언된 정적 함수 |
memberProperties | 클래스 및 상위 클래스에 선언된 비확장 프로퍼티 |
declaredMemberProperties | 클래스에 선언된 비확장 프로퍼티 |
memberExtensionProperties | 클래스 또는 상위 클래스의 멤버로 선언된 확장 프로퍼티 |
declaredMemberExtensionProperties | 클래스에 멤버로 선언된 확장 프로퍼티 |
staticProperties | Java 클래스에 선언된 정적 필드를 나타내는 프로퍼티 |
코드에서 필요한 선언과 일치하는 가장 좁은 범위의 프로퍼티를 선택하세요. 예를 들어, 직렬화기(serializer)는 특정 클래스에서 도입된 프로퍼티만 처리하기 위해 declaredMemberProperties를 사용할 수 있지만, 호출 가능한 API를 검색하는 프레임워크는 상속된 memberFunctions도 함께 필요할 수 있습니다.
리플렉션을 사용하여 sealed 서브클래스를 검사할 수도 있습니다.
프로퍼티 읽기
리플렉션을 사용하면 런타임에 선택된 프로퍼티를 읽을 수 있습니다. 예를 들어 User 객체에서 표시할 프로퍼티로 name을 지정하는 UI 설정이 있다고 가정해 보겠습니다. 이를 위해 애플리케이션은 일치하는 프로퍼티 선언을 찾은 다음 해당 게터를 호출해야 합니다:
import kotlin.reflect.full.memberProperties
data class User(val name: String, val age: Int)
fun readProperty(instance: Any, propertyName: String): Any? {
// 런타임 클래스 검사
val runtimeClass = instance::class
// 프로퍼티 선언 찾기
val property = runtimeClass.memberProperties
.firstOrNull { it.name == propertyName }
?: error("알 수 없는 프로퍼티: $propertyName")
// 객체를 수신 객체로 전달하여 게터 호출
return property.getter.call(instance)
}
fun main() {
val user = User("Jane Doe", 22)
println(readProperty(user, "name"))
// Jane Doe
println(readProperty(user, "age"))
// 22
}이 예제에서는 memberProperties를 사용하여 바인딩되지 않은(unbound) 프로퍼티 객체를 반환합니다. 이러한 객체는 클래스에 속하지만 특정 인스턴스에 연결되지 않은 프로퍼티를 설명합니다. 따라서 getter.call()의 수신 객체로 instance를 전달해야 합니다. 런타임에 선택된 프로퍼티는 어떤 타입이든 반환할 수 있으므로 결과는 Any? 타입을 가집니다.
컴파일 시점에 프로퍼티를 알고 있다면 리플렉션 대신 직접 프로퍼티에 접근하거나 호출 가능한 참조를 사용하세요.
함수 호출
동적 함수 호출도 프로퍼티와 동일한 패턴을 따릅니다. 선언된 순서대로 모든 인자를 전달할 수 있다면 call()을 사용할 수 있습니다. 바인딩되지 않은 멤버 함수를 호출할 때는 먼저 객체 인스턴스를 전달한 다음 일반 인자들을 추가합니다:
import kotlin.reflect.full.memberFunctions
class Formatter {
fun format(text: String, uppercase: Boolean): String =
if (uppercase) text.uppercase() else text
}
fun main() {
val formatter = Formatter()
// 런타임에 이름으로 함수 찾기
val function = Formatter::class.memberFunctions
.single { it.name == "format" }
// 수신 객체를 먼저 제공한 다음 선언된 순서대로 인자 전달
val result = function.call(formatter, "Kotlin", true)
println(result)
// KOTLIN
}이 예제에서 호출에는 세 가지 값(Formatter 수신 객체, text, uppercase)이 포함됩니다. 또한 Any? 타입을 반환하며 호환되지 않는 수신 객체나 인자가 전달되면 런타임에 오류를 발생시킵니다.
위치에 따라 인자를 제공하는 대신 KParameter 객체에 값을 매핑할 수도 있습니다. 이를 위해서는 callBy() 함수를 사용합니다:
import kotlin.reflect.full.instanceParameter
import kotlin.reflect.full.memberFunctions
import kotlin.reflect.full.valueParameters
class Greeter {
fun greet(name: String, punctuation: String = "!") =
"Hello, $name$punctuation"
}
fun main() {
val greeter = Greeter()
val function = Greeter::class.memberFunctions
.single { it.name == "greet" }
// valueParameters에는 greet()에 선언된 파라미터가 포함되며
// Greeter 수신 객체는 포함되지 않습니다
val nameParameter = function.valueParameters
.single { it.name == "name" }
val result = function.callBy(
mapOf(
// 멤버 함수는 인스턴스 수신 객체가 필요합니다
function.instanceParameter!! to greeter,
nameParameter to "Kotlin"
)
)
println(result)
// Hello, Kotlin!
}이 예제에서 instanceParameter는 멤버 함수의 수신 객체를 식별하며, valueParameters에는 함수 시그니처에 선언된 파라미터만 포함됩니다.
순서대로 정렬된 전체 인자 목록이 이미 준비되어 있는 경우 call()을 사용하세요.
인자를 파라미터 객체에 매핑하거나 선택적(optional) 파라미터가 기본값을 사용하도록 하려면 callBy()를 사용하세요.
