🚎 🧘🏼 ⛽️ रनटाइम पर स्काला कोड का सरल संकलन ↘️ 💎 💲

तो, चलिए शुरू करते हैं। मुझे स्काला बहुत पसंद है क्योंकि यह आपको जावा के रूप में आधे कोड लिखने की अनुमति देता है। स्पष्ट और अभिव्यंजक कोड। इसके अलावा, स्काला पर, आप उन चीज़ों को कर सकते हैं जो आमतौर पर जावा डेवलपर्स के लिए दुर्गम हैं: उच्च-क्रम वाली जेनेरिक और मैनिफ़ेस्ट का उपयोग करके रनटाइम में सामान्य प्रकार को पहचानते हैं।

जिन चीजों पर चर्चा की जाएगी उनमें से एक कार्यक्रम निष्पादन के दौरान स्काला कोड का संकलन है। यह तब आवश्यक हो सकता है जब आप एक दूरस्थ स्रोत से आने वाले कोड को निष्पादित करना चाहते हैं या एक स्व-संशोधित कार्यक्रम लिखना चाहते हैं, जेएस में eval फ़ंक्शन का एक एनालॉग।

स्काला और जावा के बीच सबसे महत्वपूर्ण अंतर यह है कि इसका कंपाइलर जेवैक की तरह एक देशी प्रोग्राम नहीं है, बल्कि जार फाइल के रूप में आता है, यानी यह एक साधारण लाइब्रेरी है, जिसे सोर्स कोड से जेवीएम बायटेकोड प्राप्त करने के लिए कोई भी किसी भी समय कॉल नहीं करता है।

इस पद्धति का एकमात्र दोष यह है कि स्काला कंपाइलर एपीआई में सरल कार्यों के लिए बहुत सुविधाजनक इंटरफ़ेस नहीं है: जब आपको केवल स्रोत को लेने और उससे संकलित कक्षाओं का एक गुच्छा प्राप्त करने की आवश्यकता होती है, जिसका उपयोग करके आप जावा रिफाइनरी एपीआई के माध्यम से उदाहरण बना सकते हैं। यही कारण है कि मैंने संकलन के लिए एक साधारण आवरण बनाने के लिए एक दिन का फैसला किया, जो कहानी होगी। मैंने स्टैक ओवरफ्लो और विषयगत साइटों से बिट द्वारा इसके लिए कोड एकत्र किया।

स्काला कोड को संकलित करने के लिए इंटरफ़ेस scala.tools.nsc.Global वर्ग द्वारा प्रदान किया गया है। संकलन को कॉल करने के लिए, आपको इस वर्ग का एक उदाहरण बनाने की आवश्यकता है, फिर नेस्टेड रन क्लास की एक आवृत्ति और संकलन स्रोत को चलाने की आवश्यकता है:

val compiler = new Global ( settings, reporter ) new compiler. Run ( ) compileSources ( sources )

यहां सब कुछ काफी सरल है, लेकिन संकलन के लिए आपको सेटिंग्स (सेटिंग्स) की आवश्यकता है, एक रिपोर्टर, जो संकलन त्रुटियों और स्रोत (स्रोत) को इकट्ठा करेगा।

सेटिंग्स प्रकार scala.tools.nsc.Settings के हैं , मेरी जरूरतों के लिए सेटिंग्स में दो पैरामीटर पर्याप्त थे: usejavacp, जो निर्धारित करता है कि कंपाइलर को वर्तमान जावा क्लासपैथ का उपयोग करने की आवश्यकता है (यह उपयोगी है क्योंकि जिस स्रोत को आप संकलित करना चाहते हैं वह बाहरी कक्षाओं से लिंक हो सकता है। वातावरण), और दूसरा पैरामीटर आउटपुटडायर। तथ्य यह है कि संकलक, जो ग्लोबल क्लास में स्थित है, संकलित कक्षाओं को केवल डिस्क पर फ़ाइलों के रूप में जोड़ सकता है। मैं डिस्क से संलग्न नहीं होना चाहता था, इसलिए मुझे एक वर्कअराउंड मिला, काफी लोकप्रिय, वैसे - स्मृति में एक आभासी निर्देशिका का उपयोग करें।

परिणामस्वरूप, मेरा सेटिंग कोड इस तरह दिखता है:

val settings = new Settings settings. usejavacp . value = true val directory = new VirtualDirectory ( "(memory)" , None ) settings. outputDirs . setSingleOutput ( directory )

अगला, आपको रिपोर्टर को कॉन्फ़िगर करने की आवश्यकता है। मैंने scala.tools.nsc.reporters.StoreReporter का उपयोग किया:

val reporter = new StoreReporter ( )

यह संकलन के साथ सभी समस्याओं को अपने भीतर सहेजता है, और संकलन पूरा होते ही त्रुटियों का विश्लेषण किया जा सकता है।

और आखिरी चीज स्रोत कोड तैयार करना है। यह इतना सरल नहीं है और संकलक scala.tools.nsc.util.SourceFile उदाहरणों से एक सूची को स्वीकार करता है, जबकि, जैसा कि आप याद करते हैं, हमारे पास केवल स्रोत कोड के साथ एक पंक्ति है। लघु स्काला वाक्यविन्यास के लिए धन्यवाद, रूपांतरण सरल है:

val sources = List ( new BatchSourceFile ( "<source>" , source ) )

हम एक फाइल बनाते हैं जहाँ हम सोर्स कोड डालते हैं।

अब सब कुछ तैयार है, हम कंपाइलर को कॉल कर सकते हैं और पहली बात यह है कि चेक करें: हमारे स्रोत कोड का संकलन कैसे किया गया:

if ( reporter. hasErrors ) { throw new CompilationFailedException ( source, reporter. infos . map ( info = > ( info. pos . line , info. msg ) ) ) }

सरलता के लिए, त्रुटियों के मामले में (और चेतावनियाँ नहीं), मैं एक अपवाद फेंक देता हूं कि संकलन असफल है, यह अपवाद है:

class CompilationFailedException ( val programme: String , val messages: Iterable [ ( Int, String ) ] ) extends Exception ( messages. map ( message = > message._1 + ". " + message._2 ) . mkString ( "n" ) )

यदि सब कुछ ठीक रहा, तो हमारे पास पहले से ही इकठ्ठा होने वाली कक्षाएं हैं, यह किसी भी तरह एक ही आभासी फ़ोल्डर से लोड करने के लिए बनी हुई है। हम अंतर्निहित वर्ग scala.tools.nsc.interpreter.AbstractFileClassLoader का उपयोग करते हैं:

val classLoader = new AbstractFileClassLoader ( directory, this . getClass . getClassLoader ( ) )

AbstractFileClassLoader को प्रत्येक नए संकलन पर एक नया बनाया जाएगा, ताकि यदि हम कुछ वर्ग को फिर से जोड़ना चाहते हैं, तो यह अपने पिछले अवतार के साथ संघर्ष के बिना, दूसरी बार सफलतापूर्वक लोड होता है।

क्लास लोडर बनाने के बाद, आपको वर्चुअल फ़ोल्डर की फ़ाइलों के माध्यम से जाने और उसके अंदर की फ़ाइलों से कक्षाओं को लोड करने की आवश्यकता है। स्काला में, एक स्रोत फ़ाइल में कई वर्ग हो सकते हैं जो जरूरी नहीं कि एक-दूसरे के अंदर हों; जब जेवीएम बायोटेक में संकलित किया जाता है, तो ऐसी कई कक्षाएं कई फ़ाइलों में विघटित हो जाएंगी, और नेस्टेड कक्षाएं अलग-अलग वर्गों में होंगी जिनका नाम ClassName $ InnerClassName.class है। मैंने एक एकल इंटरफ़ेस के कार्यान्वयन को संकलित करने के लिए इस कोड का उपयोग किया, ताकि मुझे हमेशा पता चले कि परिणामी कक्षाओं से क्या उम्मीद है। इस प्रकार, इसलिए, नेस्टेड वर्ग जो मुख्य के साथ एक सममूल्य पर खड़े होने के लिए कड़े होते हैं, मेरे साथ दृढ़ता से हस्तक्षेप करते हैं, जब लोड करते हैं, तो मैं उन्हें छोड़ देता हूं अगर नाम में $ साइन है:

for ( classFile < - directory ; if ( ! classFile. name . contains ( '$' ) ) ) yield { val path = classFile. path val fullQualifiedName = path. substring ( path. indexOf ( '/' ) + 1 , path. lastIndexOf ( '.' ) ) . replace ( "/" , "." ) classLoader. loadClass ( fullQualifiedName ) }

कक्षाओं को लोड करने के लिए, आपको पैकेज संरचना सहित उनके पूरी तरह से योग्य नाम प्राप्त करने की आवश्यकता है। इस नाम को फिर से बनाने के लिए, मैंने एक फ़ोल्डर में पथ हेरफेर का उपयोग किया।

खैर, अब हमारी कक्षाएं भरी हुई हैं और ऊपर का निर्माण इन वर्गों की सूची लौटा देगा।

वह सब है। यह ऐसा प्रतीत होता है कि एक साधारण, यद्यपि गैर-तुच्छ कार्य, केवल कोड का एक पृष्ठ लिखकर पूरा किया जा सकता है।

परिणामी कक्षा का पूरा पाठ:

/*!# Compiler This class is a wrapper over Scala Compiler API which has simple interface just accepting the source code string. Compiles the source code assuming that it is a .scala source file content. It used a classpath of the environment that called the `Compiler` class. */ import tools. nsc . { Global, Settings } import tools.nsc.io._ import tools.nsc.reporters.StoreReporter import tools.nsc.interpreter.AbstractFileClassLoader import tools.nsc.util._ class Compiler { def compile ( source: String ) : Iterable [ Class [ _ ] ] = { // prepare the code you want to compile val sources = List ( new BatchSourceFile ( "<source>" , source ) ) // Setting the compiler settings val settings = new Settings /*! Take classpath from currently running scala environment. */ settings. usejavacp . value = true /*! Save class files for compiled classes into a virtual directory in memory. */ val directory = new VirtualDirectory ( "(memory)" , None ) settings. outputDirs . setSingleOutput ( directory ) val reporter = new StoreReporter ( ) val compiler = new Global ( settings, reporter ) new compiler. Run ( ) compileSources ( sources ) /*! After the compilation if errors occured, `CompilationFailedException` is being thrown with a detailed message. */ if ( reporter. hasErrors ) { throw new CompilationFailedException ( source, reporter. infos . map ( info = > ( info. pos . line , info. msg ) ) ) } /*! Each time new `AbstractFileClassLoader` is created for loading classes it gives an opportunity to treat same name classes loading well. */ // Loading new compiled classes val classLoader = new AbstractFileClassLoader ( directory, this . getClass . getClassLoader ( ) ) /*! When classes are loading inner classes are being skipped. */ for ( classFile < - directory ; if ( ! classFile. name . contains ( '$' ) ) ) yield { /*! Each file name is being constructed from a path in the virtual directory. */ val path = classFile. path val fullQualifiedName = path. substring ( path. indexOf ( '/' ) + 1 ,path. lastIndexOf ( '.' ) ) . replace ( "/" , "." ) Console. println ( fullQualifiedName ) /*! Loaded classes are collecting into a returning collection with `yield`. */ classLoader. loadClass ( fullQualifiedName ) } } } /*!### Compilation exception Compilation exception is defined this way. It contains program was compiling and error positions with messages of what went wrong during compilation. */ class CompilationFailedException ( val programme: String , val messages: Iterable [ ( Int, String ) ] ) extends Exception ( messages. map ( message = > message._1 + ". " + message._2 ) . mkString ( "n" ) )

वैसे, यदि आप टिप्पणियों के प्रारूप में रुचि रखते हैं - यह सर्क्युम्फ्लेक्स डोको है , जो दृश्य प्रलेखन के लिए एक बहुत अच्छी बात है।

अंत में, यह गलत है, यह कहा जाना चाहिए कि स्काला तेजी से विकसित हो रहा है और कभी-कभी डेवलपर्स एपीआई को बदलते हैं। यह कोड सफलतापूर्वक 2.9.0.1 संस्करण पर परीक्षण किया गया है, सभी 2.8.x और 2.9.x पर काम करना चाहिए।

रनटाइम पर स्काला कोड का सरल संकलन

More articles: