Kotlin में रिफ्लेक्शन और इंट्रोस्पेक्शन: JVM के हुड के नीचे झाँकना

Kotlin में रिफ्लेक्शन और इंट्रोस्पेक्शन: अपने कोड के अंदर कैसे झाँकें

कल्पना करें कि आप एक प्रोग्रामर हैं जो ऐसा कोड लिखता है जो स्वयं का विश्लेषण करता है। विज्ञान कथा जैसा लगता है? Kotlin की दुनिया में यह वास्तविकता है। रिफ्लेक्शन और इंट्रोस्पेक्शन वे उपकरण हैं जो आपके कोड को एक साधारण निष्पादक से एक सच्चे मेटा-प्रोग्रामर में बदल देते हैं। यदि आप कभी भी कक्षाओं के बारे में गतिशील रूप से जानकारी प्राप्त करना, नाम से विधियों को कॉल करना, या रनटाइम पर एनोटेशन के साथ काम करना चाहते हैं, तो यह लेख आपके लिए है।

हम समझेंगे कि कैसे Kotlin, JVM के ऊपर काम करने वाली भाषा होने के नाते, रिफ्लेक्शन का उपयोग करता है, और सरल उदाहरणों की मदद से आप अपने प्रोजेक्ट्स में जादू कैसे जोड़ सकते हैं। चलिए शुरू करते हैं!

रिफ्लेक्शन और इंट्रोस्पेक्शन क्या है? जानने योग्य अंतर

कोड में गोता लगाने से पहले, आइए शब्दों को समझ लें। अक्सर इन अवधारणाओं को भ्रमित किया जाता है, लेकिन इनमें एक महीन रेखा है।

\n
• इंट्रोस्पेक्शन — प्रोग्राम की "खुद को देखने" की क्षमता है। आप कक्षाओं की संरचना के बारे में जानकारी प्राप्त कर सकते हैं: उनमें कौन से गुण, विधियाँ, कंस्ट्रक्टर हैं। यह कार का हुड खोलकर देखने जैसा है कि अंदर क्या है।
\n
• रिफ्लेक्शन — यह अधिक शक्तिशाली चीज़ है। आप न केवल देखते हैं, बल्कि निष्पादन के दौरान प्रोग्राम के व्यवहार को बदलते भी हैं। आप उन विधियों को कॉल कर सकते हैं जिन्हें आप संकलन चरण पर नहीं जानते थे, क्लास के स्ट्रिंग नाम से ऑब्जेक्ट बना सकते हैं।
\n

Kotlin में, रिफ्लेक्शन JVM-रिफ्लेक्शन से निकटता से जुड़ा हुआ है, लेकिन इसके अपने Kotlin-विशिष्ट API हैं (उदाहरण के लिए, KClass, KFunction)। और हाँ, रिफ्लेक्शन के साथ काम करने के लिए आपको build.gradle.kts में एक निर्भरता जोड़नी होगी:

dependencies {\n    implementation("org.jetbrains.kotlin:kotlin-reflect:1.9.22")\n}\n

इसके बिना, आप केवल बुनियादी क्षमताओं का उपयोग कर पाएंगे, जैसे javaClass। लेकिन पूर्ण Kotlin अनुभव के लिए — लाइब्रेरी स्थापित करें।

KClass: आपका मुख्य इंट्रोस्पेक्शन टूल

Java में हम Class<?> के आदी हैं। Kotlin में इसका एनालॉग KClass है। यह रिफ्लेक्शन की दुनिया का प्रवेश द्वार है। KClass प्राप्त करने के दो तरीके हैं:

// तरीका 1: क्लास ऑब्जेक्ट के माध्यम से\nval myClass: KClass<String> = String::class\n\n// तरीका 2: इंस्टेंस के माध्यम से\nval str = "नमस्ते, दुनिया!"\nval classFromInstance: KClass<out String> = str::class\n

अब आपके पास ढेर सारी जानकारी तक पहुंच है: क्लास का नाम, पैकेज, कंस्ट्रक्टर, गुण, फ़ंक्शन। आइए एक उदाहरण देखें:

data class User(val name: String, val age: Int)\n\nfun main() {\n    val kClass = User::class\n    println("क्लास का नाम: ${kClass.simpleName}") // User\n    println("पैकेज: ${kClass.qualifiedName}") // com.example.User\n    println("गुणों की संख्या: ${kClass.memberProperties.size}") // 2 (name, age)\n    \n    kClass.memberProperties.forEach { prop ->\n        println("गुण: ${prop.name}, प्रकार: ${prop.returnType}")\n    }\n}\n

यह शुद्ध Kotlin में इंट्रोस्पेक्शन है — हम केवल संरचना देख रहे हैं। व्यवहार में कोई बदलाव नहीं।

फ़ंक्शन और कंस्ट्रक्टर के बारे में जानकारी प्राप्त करना

कभी-कभी यह जानना आवश्यक होता है कि क्लास में कौन सी विधियाँ हैं, या उन्हें कॉल करना भी। इसके लिए हम KFunction का उपयोग करते हैं।

class Calculator {\n    fun add(a: Int, b: Int): Int = a + b\n    fun multiply(a: Int, b: Int): Int = a * b\n}\n\nfun main() {\n    val calcClass = Calculator::class\n    println("Calculator क्लास के फ़ंक्शन:")\n    calcClass.memberFunctions.forEach { func ->\n        println(" - ${func.name} (पैरामीटर: ${func.parameters})")\n    }\n}\n

आउटपुट कुछ इस प्रकार होगा:

Calculator क्लास के फ़ंक्शन:\n - add (पैरामीटर: [a, b])\n - multiply (पैरामीटर: [a, b])\n

रिफ्लेक्शन क्रियान्वयन: विधियों को कॉल करना और ऑब्जेक्ट बनाना

अब सबसे दिलचस्प बात — रिफ्लेक्शन। मान लीजिए, आपके पास एक विधि के नाम वाली स्ट्रिंग है,