एक स्क्रिप्टिंग भाषा के रूप में ग्रूवी और जावा के लिए डीएसएल

क्यों?

विभिन्न प्रकार के सॉफ़्टवेयर विकसित करते समय, उदाहरण के लिए, निगरानी या रखरखाव कार्यों के लिए, मुझे उस कार्यक्रम में स्क्रिप्ट का समर्थन करने की आवश्यकता होती है जो कुछ निश्चित कार्यों का वर्णन या प्रदर्शन करते हैं। और विशिष्टता ऐसी है कि सॉफ़्टवेयर में ऐसे परिदृश्यों को जोड़ना या बदलना, सॉफ़्टवेयर के पुनर्निर्माण या पुनः आरंभ करने की आवश्यकता नहीं होनी चाहिए।

संभवतः ऐसे परिदृश्यों का सबसे सरल उदाहरण जो सभी ने एक रूप में या किसी अन्य में सामना किया हो, साधारण बैच की फाइलें हो सकती हैं - बैट या श।

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

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

कैसे?

स्क्रिप्ट

मैं आपको ग्रूवी की मूल बातें नहीं बताऊंगा, क्योंकि नेटवर्क पर पहले से ही रूसी में भी बहुत सारी सामग्रियां हैं। मैं केवल हमारे लिए कुछ प्रमुख बिंदुओं पर ध्यान केन्द्रित करूंगा।

ग्रूवी हमें जावा कोड से गैर-संकलित ग्रूवी स्रोत कोड निष्पादित करने की अनुमति देता है, जो हमें रनटाइम में जोड़ी गई या परिवर्तित लिपियों को निष्पादित करने की अनुमति देता है।

जावा में एक ग्रूवी स्क्रिप्ट निष्पादित करने के एक उदाहरण पर विचार करें। अपने जावा प्रोजेक्ट में ग्रूवी का समर्थन करने के लिए, आपको आवश्यक संस्करण के केवल एक ग्रूवी लाइब्रेरी को कनेक्ट करना होगा।

हम निम्नलिखित Groovy कोड को x: \ GroovyScript.groovy फ़ाइल में लिखेंगे:

Println "ग्रूवी स्क्रिप्ट"
बहु = {
num1, num2 -> संख्या 1 * num2
}
बहु ( 4 , 4 )

आपके जावा कोड में इस स्क्रिप्ट को निष्पादित करने के लिए कोड हो सकता है:

GroovyShell शेल = नया GroovyShell ( ) ;
वस्तु परिणाम = खोल। मूल्यांकन ( नई फ़ाइल ( "x: /GroovyScript.groovy" ) ) ;
प्रणाली। बाहर । प्रिंट्लन ( "परिणाम =" + परिणाम ) ;

निष्पादन के परिणामस्वरूप, 2 लाइनें कंसोल में प्रदर्शित होंगी, स्क्रिप्ट से पहली, दूसरी जावा से, स्क्रिप्ट के परिणाम के साथ:

Groovy script
result=16


उदाहरण स्क्रिप्ट में एक कार्यात्मक भार नहीं ले जाता है, हालांकि, यह गतिशील लोडिंग और निष्पादन की संभावना को दर्शाता है - कोड की केवल दो लाइनें और हमें स्क्रिप्ट निष्पादित करने की क्षमता मिलती है।

जावा कोड के बारे में थोड़ा सा। ग्रूवीशेल ग्रूवी लिपियों को निष्पादित करने के लिए ग्रूवी द्वारा प्रदान किया जाने वाला एक वर्ग है। ग्रूवी स्क्रिप्ट को निष्पादित करने के अन्य तरीके हैं, अधिक जानकारी के लिए यहां देखें।

डीएसएल

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

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

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

// आयात
...
// चेक स्टेट
प्रक्रिया p = getProcess ( ... )
इंट स्टेट = पी। getCompleteState ( ... )
अगर ( राज्य == 1 ) {
// doSomeLogicForArchive
ज़िप z = नया ज़िप ( ... )
जेड। मेकजिप ( ... )
} {
// doAnotherLogic
वापसी
}
// doSomeLogicForSendNotify
Smtp smtp = नया smtp ( ... )
संदेश m = नया संदेश ( ... )
smtp। भेजें ( करने के लिए, मी ... )

कोड काफी बड़ा हो गया है, और यह मुख्य रूप से केवल प्रोग्रामर द्वारा समझा जाएगा। आइए इसे सरल करें और तीन संकेतित क्रियाओं को स्टैटिक विधियों के साथ आर्काइवस्क्रिप्ट क्लास में डालें। विधियाँ बनाने के बाद स्क्रिप्ट:

आर्काइवस्क्रिप्ट आयात करें
अगर ( आर्काइवस्क्रिप्ट । checkState ( ) ) {
ArchiveScript। makeArchive ( .. )
} {
// doAnotherLogic
वापसी
}
ArchiveScript। sendNotify ( ... )

पहले से बेहतर? "बेहतर, लेकिन अभी भी कलाकृतियाँ हैं - आयात और वर्ग के नाम जो हटाने योग्य भी होंगे।" और ग्रूवी में एक समान संभावना है - स्क्रिप्ट के बाहर स्क्रिप्ट के लिए बेस क्लास सेट करने की क्षमता। आर्काइवस्क्रिप्ट क्लास को इसके लिए स्क्रिप्ट से इनहेरिट करना होगा और तरीके स्टैटिक नहीं हो सकते। स्क्रिप्ट कोड अभी भी सरलीकृत है - आयात और वर्ग उपसर्ग गायब:

अगर ( checkState ( ) ) {
makeArchive ( .. )
} {
// doAnotherLogic
वापसी
}
sendNotify ( ... )

पहले से ही काफी अच्छा है। यदि स्थिति शाखा ब्लॉक के अंदर कोड एकल-पंक्ति है, तो आप घुंघराले ब्रेस को मना कर सकते हैं। और ग्रूवी के मामले में, यह अक्सर कोष्ठक से विधि नाम के दाईं ओर आता है। स्क्रिप्ट निष्पादन कोड थोड़ा जटिल है - आपको एक CompilerConfiguration ऑब्जेक्ट बनाने की आवश्यकता है, हमारे द्वारा बनाए गए आर्काइवस्क्रिप्ट क्लास के नाम के बराबर ScriptBaseClass मान सेट करें और इस ऑब्जेक्ट को GroovyShell से पास करें:

CompilerConfiguration conf = new CompilerConfiguration ( ) ;
conf। setScriptBaseClass ( "package.ArchiveScript" ) ;
GroovyShell शेल = नया GroovyShell ( conf ) ;

अगला, आइए देखें कि स्क्रिप्ट में विधियों के मापदंडों को कैसे सेट किया जाता है। यदि पुरालेख विधि में मेकअप विधि को निम्न प्रकार से परिभाषित किया गया है:

डीईएएक्राइविव ( सोर्सपाथ, डेस्टपैथ, डिलीटसोर्स )

स्क्रिप्ट में, कॉल इस तरह दिखना चाहिए:

MakeArchive ( "x: / aaa /" , "x: /a.zip" , true )

// या तो

MakeArchive "x: / aaa /" , "x: /a.zip" , सच

और अगर हम दृश्यता और यहां तक ​​कि सुविधा के बारे में बात करते हैं, तो ग्रूवी हमें इस तरह नामित मापदंडों के माध्यम से मापदंडों के हस्तांतरण की अनुमति देता है:

MakeArchive sourcePath: 'x: / aaa /' ,
नियतिपथ: 'x: /a.zip' ,
deleteSource: सच

हालाँकि, इस मामले में, मापदंडों को हाशपैप के अंदर पास किया जाएगा और, तदनुसार, आर्काइवस्क्रिप्ट क्लास में मेकएवरिव में पैरामीटर प्राप्त करना इस तरह होना चाहिए:

डीईएकेचिव ( परम ) {
MakeArchiveIntern पारम। sourcePath , params प्रारब्ध , परम । deleteSource
}

यदि हम अन्य कॉल में परिवर्तन लागू करते हैं, तो अंत में हमारी स्क्रिप्ट इस तरह दिख सकती है:

अगर ( checkState ( 'SomeData' ) ) {
MakeArchive sourcePath: 'c: / 1 /*.*' ,
नियतिपथ: 'c: /testarch.zip' ,)
deleteSource: सच
} {
// doAnotherLogic
वापसी
}
sendNotify: 'aaa@gdsl.ru' , सामग्री: 'संदेश'

और यह बहुत जटिल और पठनीय पर्याप्त कोड नहीं है।

इस प्रकार, हमने अपने कार्य के लिए कई पूर्वनिर्धारित कार्यों के साथ अपना मिनी-डीएसएल प्राप्त किया। और हमारे पास अभी भी स्रोत भाषा की पूरी शक्ति का उपयोग करने का अवसर है।

मैंने ध्यान दिया कि मैंने डीएसएल के विकास का केवल एक छोटा सा अंश माना। ग्रूवी के पास अपने डीएसएल को विकसित करने के लिए अधिक समर्थन है , साथ ही एक्लिप्स के लिए और इंटेलीज आइडिया के लिए डीएसएल समर्थन है

परीक्षण

मैं स्क्रिप्ट के परीक्षण के बारे में कुछ शब्द कहना चाहूंगा। कोई फर्क नहीं पड़ता कि स्क्रिप्ट कितनी सरल है, इसमें त्रुटियां हो सकती हैं। यहां तक ​​कि अगर आप आईडीई में स्क्रिप्ट लिखते हैं, तो आपको एक पूर्ण वाक्यविन्यास चेक प्राप्त नहीं हो सकता है। यह केवल इसके कार्यान्वयन के साथ संभव है। स्क्रिप्ट के व्यवहार की जांच करना भी आवश्यक है।
चूँकि हम स्क्रिप्ट का परीक्षण करते समय वास्तविक क्रिया करना पसंद नहीं करेंगे, इसलिए हमें किसी तरह असली तर्क को नकल के साथ बदलने की आवश्यकता है। ग्रूवी हमें कई तरीकों से ऐसा करने की अनुमति देता है। मैं उनमें से कुछ दिखाऊंगा।

बेस स्क्रिप्ट की जगह

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

CompilerConfiguration conf = new CompilerConfiguration ( ) ;
conf। setScriptBaseClass ( "package.ArchiveScriptMock" ) ;

स्क्रिप्ट के आधार वर्ग में तरीकों को बदलना

एक अतिरिक्त नकली वर्ग बनाने के बिना एक अन्य विकल्प पुरालेख में ही नकली के साथ तरीकों को बदलने के लिए हो सकता है। Groovy में, यह किया जा सकता है, उदाहरण के लिए, इस तरह से:

ArchiveScript। मेटाक्लास । {के साथ
checkState { t -> true }
मेकअर्चिव { परम -> }
sendNotify { params -> }
}
रनस्क्रिप्ट ( )

पहली और दूसरी विधि का नुकसान, मैं प्रेषित मापदंडों की शुद्धता को सत्यापित करने के लिए डुप्लिकेट तर्क लिखने की आवश्यकता पर विचार करूंगा। अगर आर्काइवस्क्रिप्टमॉक में मेकआर्चिव विधि इस तरह होगी:

डीईएकेचिव ( परम ) {
// MakeArchiveInternal params.sourcePath, params.destPath, params.deleteSource
}

यदि हम सभी मापदंडों को पारित कर चुके हैं तो हम जाँच नहीं करेंगे। आपको ऐसा ही कुछ लिखना होगा:

डीईएकेचिव ( परम ) {
MakeArchiveInternalMock परम। sourcePath , params प्रारब्ध , परम । deleteSource
}

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

अमूर्त वर्ग पुरालेख स्क्रिप्ट का विस्तार करता है {
आर्क आर्क = नया आर्काइव ( )
डीईएकेचिव ( परम ) {
चाप। पुरालेख । sourcePath , params प्रारब्ध , परम । deleteSource
}
...

अब, आप तर्क और लिपि को अलग से परख सकते हैं। पुरालेख को इसके मॉक से बदलें और स्क्रिप्ट निष्पादित करें:

// नकली तरीकों को परिभाषित करें
mockedMethods = {
checkState { स्ट्रिंग प्रकार -> सत्य }
मेकअर्चिव { स्ट्रिंग सोर्सपाथ, स्ट्रिंग डेस्टपाथ, बूलियन डिलीटसोर्स -> }
sendNotify { स्ट्रिंग टू, स्ट्रिंग कंटेंट -> }
}

// स्क्रिप्ट को इस तरह बदलें और निष्पादित करें
पुरालेख। मेटाक्लास । के साथ ( mockedMethods )
रनस्क्रिप्ट ( )

// या तो
StubFor stub = new StubFor ( संग्रह ) ;
ठूंठ। मांग । {के साथ
mockedMethods
}
ठूंठ। उपयोग {
रनस्क्रिप्ट ( )
}

स्वाभाविक रूप से, पुरालेख के व्यवहार को जावा मॉक फ्रेमवर्क से बदला जा सकता है, हालांकि, अभी के लिए यह हमारे लिए पर्याप्त है।

परिणाम

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

परियोजना स्रोत कोड के साथ परियोजना groovydsl है । रैपर के माध्यम से संकलित ग्रेड।

कुछ विचार ग्रूवी से डोमेन-विशिष्ट लैंग्वेजेज, फर्गल डियरल, 2010 के लिए आते हैं

का आनंद लें!