ग्रेडल - त्वरित गाइड

"Gradle is an open source build automation system"

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

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

अंत में ग्रैडल 2012 में तस्वीर में आया। ग्रैडल ने दोनों टूल से कुछ कुशल विशेषताओं का वहन किया।

ग्रेडल की विशेषताएं

निम्नलिखित उन सुविधाओं की सूची है जो ग्रैडल प्रदान करता है।

  • Declarative builds and build-by-convention- ग्रैड ग्रोवी भाषा के आधार पर अलग डोमेन विशिष्ट भाषा (डीएसएल) के साथ उपलब्ध है। ग्रैडल एक घोषित भाषा तत्व प्रदान करता है। वे तत्व जावा, ग्रूवी, ओएसजीआई, वेब और स्काला के लिए बिल्ड-बाय-कन्वेंशन सपोर्ट भी प्रदान करते हैं।

  • Language for dependency based programming - घोषणात्मक भाषा एक सामान्य प्रयोजन कार्य ग्राफ के शीर्ष पर है, जिसे आप अपने निर्माण में पूरी तरह से लाभ उठा सकते हैं।

  • Structure your build- ग्रैडल अंत में आपको अपने निर्माण के लिए सामान्य डिजाइन सिद्धांतों को लागू करने की अनुमति देता है। यह आपको बिल्ड, एसओ के लिए एक आदर्श संरचना प्रदान करेगा, जिसे आप अच्छी तरह से संरचित और आसानी से बनाए रखा जा सकता है, समझदार निर्माण कर सकते हैं।

  • Deep API - इस एपीआई का उपयोग करने से यह आपको इसके विन्यास और निष्पादन व्यवहार को इसके मूल पर नजर रखने और अनुकूलित करने की अनुमति देता है।

  • Gradle scales - ग्रैडल आसानी से अपनी उत्पादकता बढ़ा सकता है, सरल और एकल परियोजना से विशाल उद्यम मल्टी-प्रोजेक्ट बिल्ड बनाता है।

  • Multi-project builds- ग्रैडल मल्टी-प्रोजेक्ट बिल्ड का समर्थन करता है और यह आंशिक बिल्ड का समर्थन करता है। यदि आप एक सबप्रोजेक्ट बनाते हैं तो ग्रैडल उन सभी उपप्रोजेकों के निर्माण का ध्यान रखता है जो इस पर निर्भर करते हैं।

  • Different ways to manage your builds - ग्रैडल आपकी निर्भरता के प्रबंधन के लिए विभिन्न रणनीतियों का समर्थन करता है।

  • Gradle is the first build integration tool- ग्रैडल आपके एएनटी कार्यों के लिए पूरी तरह से समर्थित है, प्रकाशनों और प्रकाशन निर्भरता के लिए मावेन और लेवी रिपॉजिटरी इन्फ्रास्ट्रक्चर। ग्रैड लिपि को Maven pom.xml मोड़ने के लिए एक कनवर्टर भी प्रदान करता है।

  • Ease of migration- ग्रैडल आपके पास किसी भी संरचना को आसानी से अनुकूलित कर सकता है। इसलिए आप हमेशा अपने ग्रेडेल बिल्ड को उसी शाखा में विकसित कर सकते हैं जहां आप लाइव स्क्रिप्ट का निर्माण कर सकते हैं।

  • Gradle Wrapper- ग्रैडल रैपर आपको ग्रैडल मशीनों को निष्पादित करने की अनुमति देता है जहां ग्रैडल स्थापित नहीं है। यह सर्वरों के निरंतर एकीकरण के लिए उपयोगी है।

  • Free open source - ग्रेडल एक ओपन सोर्स प्रोजेक्ट है, और अपाचे सॉफ्टवेयर लाइसेंस (एएसएल) के तहत लाइसेंस प्राप्त है।

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

क्यों Groovy?

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

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

ग्रेडल एक बिल्ड टूल है जो जावा पर आधारित है। कुछ आवश्यक शर्तें हैं जो ग्रैड फ्रेम कार्य को स्थापित करने से पहले स्थापित की जानी हैं।

आवश्यक शर्तें

जेडीके और ग्रूवी ग्रैड स्थापना के लिए आवश्यक शर्तें हैं।

  • ग्रैडल को आपके सिस्टम में JDK संस्करण 6 या बाद में स्थापित करने की आवश्यकता है। यह JDK पुस्तकालयों का उपयोग करता है जो स्थापित है और JAVA_HOME पर्यावरण चर पर सेट है।

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

आपके सिस्टम में ग्रैडल को स्थापित करने के चरण निम्नलिखित हैं।

चरण 1 - जावा स्थापना की पुष्टि करें

सबसे पहले, आपको अपने सिस्टम पर जावा सॉफ्टवेयर डेवलपमेंट किट (एसडीके) इंस्टॉल करना होगा। इसे सत्यापित करने के लिए, निष्पादित करेंJava –version आपके द्वारा काम किए जा रहे किसी भी प्लेटफॉर्म में कमांड।

विंडोज में -

जावा इंस्टॉलेशन को सत्यापित करने के लिए निम्न कमांड निष्पादित करें। मैंने अपने सिस्टम में JDK 1.8 स्थापित किया है।

C:\> java -version

आउटपुट -

java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b18, mixed mode)

लिनक्स में -

जावा इंस्टॉलेशन को सत्यापित करने के लिए निम्न कमांड निष्पादित करें। मैंने अपने सिस्टम में JDK 1.8 स्थापित किया है।

$ java - version

आउटपुट -

java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b18, mixed mode)

हम मानते हैं कि इस ट्यूटोरियल के पाठकों के पास अपने सिस्टम पर जावा एसडीके संस्करण 1.8.0_66 है।

चरण 2 - डाउनलोड ग्रेड बिल्ड फ़ाइल

डाउनलोड ग्रेड के लिंक से ग्रेडेल का नवीनतम संस्करण डाउनलोड करें। संदर्भ पृष्ठ में, पर क्लिक करेंComplete Distributionसंपर्क। यह कदम किसी भी प्लेटफॉर्म के लिए सामान्य है। इसके लिए आपको संपूर्ण वितरण फ़ाइल अपने डाउनलोड फ़ोल्डर में मिलेगी।

चरण 3 - ग्रेड के लिए पर्यावरण तैयार करें

पर्यावरण स्थापित करने का मतलब है कि हमें वितरण फ़ाइल को निकालना होगा, लाइब्रेरी फ़ाइलों को उचित स्थान पर कॉपी करना होगा। की स्थापनाGRADLE_HOME तथा PATH पर्यावरण चर।

यह कदम प्लेटफॉर्म पर निर्भर है।

विंडोज में -

डाउनलोड की गई ज़िप फ़ाइल को नाम दें gradle-2.11-all.zip और से वितरण फ़ाइलों की प्रतिलिपि बनाएँ Downloads\gradle-2.11\ सेवा C:\gradle\ स्थान।

इसके बाद जोड़ें C:\gradle तथा C:\gradle\bin निर्देशिका के लिए GRADLE_HOME तथा PATHसिस्टम चर। दिए गए निर्देश का पालन करेंright click on my computers -> click on properties -> advanced system settings -> click on environmental variables। वहां आपको सिस्टम वैरिएबल बनाने और संपादित करने के लिए एक डायलॉग बॉक्स मिलेगा। GRADLE_HOME वैरिएबल बनाने के लिए नए बटन पर क्लिक करें (बाईं ओर स्क्रीनशॉट का पालन करें)। मौजूदा पथ सिस्टम चर के संपादन के लिए संपादन पर क्लिक करें (दाईं ओर स्क्रीनशॉट का पालन करें)। नीचे दिए गए स्क्रीनशॉट का पालन करें।

लिनक्स में -

डाउनलोड की गई ज़िप फ़ाइल को नाम दें gradle-2.11-all.zip फिर आपको एक एक्सट्रेक्ट फाइल मिलेगी जिसका नाम है gradle-2.11।

वितरण फ़ाइलों को स्थानांतरित करने के लिए आप निम्न का उपयोग कर सकते हैं Downloads/gradle-2.11/ सेवा /opt/gradle/स्थान। डाउनलोड निर्देशिका से इस ऑपरेशन को निष्पादित करें।

$ sudo mv gradle-2.11 /opt/gradle

~ / .Bashrc फ़ाइल को संपादित करें और उसमें निम्न सामग्री चिपकाएँ और इसे सहेजें।

export ORIENT_HOME = /opt/gradle
export PATH = $PATH:

निष्पादित करने के लिए निम्न आदेश निष्पादित करें ~/.bashrc फ़ाइल।

$ source ~/.bashrc

चरण 4: ग्रेड स्थापना को सत्यापित करें

खिड़कियों में:

आप कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित कर सकते हैं।

C:\> gradle –v

आउटपुट: वहां आपको ग्रेडल संस्करण मिलेगा।

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------

Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978
Groovy: 2.4.4

Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Windows 8.1 6.3 amd64

लिनक्स में:

आप टर्मिनल में निम्न कमांड निष्पादित कर सकते हैं।

$ gradle –v

आउटपुट: वहां आपको ग्रेडल संस्करण मिलेगा।

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------

Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978

Groovy: 2.4.4
Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Linux 3.13.0-74-generic amd64

ग्रैडल दो चीजों को संभालने के लिए एक स्क्रिप्ट फ़ाइल बनाता है; एक हैprojects और एक अन्य है tasks। प्रत्येक ग्रैड बिल्ड एक या अधिक परियोजनाओं का प्रतिनिधित्व करता है। एक परियोजना एक पुस्तकालय JAR या एक वेब अनुप्रयोग का प्रतिनिधित्व करती है या यह अन्य परियोजनाओं द्वारा उत्पादित JAR से इकट्ठा किए गए एक ज़िप का प्रतिनिधित्व कर सकती है। सरल शब्दों में, एक परियोजना विभिन्न कार्यों से बनी होती है। एक कार्य का अर्थ है एक काम जो एक निर्माण करता है। एक कार्य कुछ वर्गों को संकलित कर सकता है, एक JAR का निर्माण कर सकता है, Javadoc का निर्माण कर सकता है या कुछ अभिलेखों को एक रिपॉजिटरी में प्रकाशित कर सकता है।

ग्रेडेल का उपयोग करता है Groovy language स्क्रिप्ट लिखने के लिए।

राइटिंग बिल्ड स्क्रिप्ट

बिल्डल्स का वर्णन करने के लिए ग्रेडल एक डोमेन विशिष्ट भाषा (डीएसएल) प्रदान करता है। यह एक निर्माण का वर्णन करने के लिए आसान बनाने के लिए Groovy भाषा का उपयोग करता है। ग्रेडल की प्रत्येक बिल्ड स्क्रिप्ट को UTF-8 का उपयोग करके एन्कोड किया गया है, जिसे ऑफ़लाइन सहेजा गया और बिल्ड.ग्रेड नाम दिया गया है।

build.gradle

हम ग्रूवी स्क्रिप्ट का उपयोग करके कार्यों और परियोजनाओं के बारे में बता रहे हैं। आप ग्रैडल कमांड का उपयोग करके ग्रैड बिल्ड बना सकते हैं। यह कमांड एक फाइल कहलाती हैbuild.gradle। निम्नलिखित उदाहरण पर एक नज़र डालें जो एक छोटी स्क्रिप्ट का प्रतिनिधित्व करता है जो प्रिंट करता हैtutorialspoint। निम्नलिखित स्क्रिप्ट को नाम की फ़ाइल में कॉपी करें और सहेजेंbuild.gradle। यह बिल्ड स्क्रिप्ट एक कार्य नाम हैलो को परिभाषित करता है, जिसका उपयोग ट्यूटोरियलस्पर्श स्ट्रिंग को प्रिंट करने के लिए किया जाता है।

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित करें। यह उपरोक्त स्क्रिप्ट को निष्पादित करता है। आपको इसे निष्पादित करना चाहिए, जहां build.gradle फ़ाइल संग्रहीत है।

C:\> gradle –q hello

आउटपुट:

tutorialspoint

यदि आपको लगता है कि कार्य ANT के लक्ष्य के समान है, तो यह सही है - Gradle कार्य ANT लक्ष्य के बराबर है।

आप एक शॉर्टकट निर्दिष्ट करके इस हैलो कार्य को सरल कर सकते हैं (एक प्रतीक का प्रतिनिधित्व करता है <<) को doLastबयान। यदि आप इस शॉर्टकट को उपरोक्त कार्य में जोड़ते हैंhello यह निम्नलिखित स्क्रिप्ट की तरह दिखेगा।

task hello << {
   println 'tutorialspoint'
}

जैसा कि ऊपर आप का उपयोग कर उपरोक्त स्क्रिप्ट निष्पादित कर सकते हैं gradle –q hello आदेश।

ग्रेड स्क्रिप्ट में मुख्य रूप से दो वास्तविक वस्तुओं का उपयोग किया जाता है, एक प्रोजेक्ट ऑब्जेक्ट है और दूसरा स्क्रिप्ट स्क्रिप्ट ऑब्जेक्ट है।

Project Object- प्रत्येक स्क्रिप्ट एक या कई परियोजनाओं के बारे में बताती है। निष्पादन में यह स्क्रिप्ट प्रोजेक्ट ऑब्जेक्ट को कॉन्फ़िगर करता है। आप कुछ तरीकों को कॉल कर सकते हैं और अपनी बिल्ड स्क्रिप्ट में प्रॉपर्टी का उपयोग कर सकते हैं, जो प्रोजेक्ट ऑब्जेक्ट में प्रत्यायोजित हैं।

Script Object- ग्रैडल ने स्क्रिप्ट कोड को उन वर्गों में लिया जो स्क्रिप्ट इंटरफ़ेस को लागू करते हैं और फिर निष्पादित करते हैं। इसका मतलब यह है कि स्क्रिप्ट इंटरफ़ेस द्वारा घोषित सभी गुण और तरीके आपकी स्क्रिप्ट में उपलब्ध हैं।

निम्न तालिका की सूची को परिभाषित करता है standard project properties। ये सभी गुण आपकी बिल्ड स्क्रिप्ट में उपलब्ध हैं।

अनु क्रमांक। नाम प्रकार डिफ़ॉल्ट मान
1 परियोजना परियोजना परियोजना का उदाहरण
2 नाम तार प्रोजेक्ट डायरेक्टरी का नाम।
3 पथ तार परियोजना का पूर्ण पथ।
4 विवरण तार परियोजना के लिए एक विवरण।
5 ProjectDir फ़ाइल निर्देशिका जिसमें बिल्ड स्क्रिप्ट होती है।
6 buildDir फ़ाइल ProjectDir / निर्माण
7 समूह वस्तु अनिर्दिष्ट
8 संस्करण वस्तु अनिर्दिष्ट
9 चींटी AntBuilder एक AntBuilder उदाहरण

Groovy मूल बातें

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

निम्नलिखित उदाहरण एक स्ट्रिंग को ऊपरी मामले में परिवर्तित करने के बारे में बताते हैं।

नीचे दिए गए कोड को कॉपी करें और सहेजें build.gradle फ़ाइल।

task upper << {
   String expString = 'TUTORIALS point'
   println "Original: " + expString
   println "Upper case: " + expString.toUpperCase()
}

कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित करें। यह ऊपर दी गई स्क्रिप्ट को निष्पादित करता है। आपको इसे निष्पादित करना चाहिए, जहां build.gradle फ़ाइल संग्रहीत है।

C:\> gradle –q upper

आउटपुट:

Original: TUTORIALS point
Upper case: TUTORIALS POINT

निम्न उदाहरण 4 बार के लिए एक अंतर्निहित पैरामीटर ($ इसे) के मूल्य को प्रिंट करने के बारे में बताता है।

निम्नलिखित कोड को कॉपी करें और सहेजें build.gradle फ़ाइल।

task count << {
   4.times { 
      print "$it " 
   }
}

कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित करें। यह ऊपर दी गई स्क्रिप्ट को निष्पादित करता है। आपको इसे निष्पादित करना चाहिए, जहां build.gradle फ़ाइल संग्रहीत है।

$ gradle –q count

आउटपुट:

0 1 2 3

Groovy भाषा उन विशेषताओं में बहुत कुछ प्रदान करती है जिनमें कुछ महत्वपूर्ण विशेषताओं के बारे में नीचे चर्चा की गई है।

Groovy JDK के तरीके

ग्रूवी मानक जावा कक्षाओं में बहुत सारे उपयोगी तरीके जोड़ता है। उदाहरण के लिए, JDK से Iterable API एक को लागू करता हैeach() वह विधि जो Iterable Interface के तत्वों पर निर्भर करती है।

निम्नलिखित कोड को कॉपी करें और सहेजें build.gradle फ़ाइल।

task groovyJDK << {
   String myName = "Marc";
   myName.each() { 
      println "${it}" 
   };
}

कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित करें। यह ऊपर दी गई स्क्रिप्ट को निष्पादित करता है। आपको इसे निष्पादित करना चाहिए, जहां build.gradle फ़ाइल स्टोर होती है।

C:\> gradle –q groovyJDK

आउटपुट:

M
a
r
c

प्रॉपर्टी ऐक्सेसर्स

आप अपने संदर्भ को निर्दिष्ट करके किसी विशेष संपत्ति के उपयुक्त गेट्टर और सेटर विधियों को स्वचालित रूप से एक्सेस कर सकते हैं।

निम्नलिखित स्निपेट एक संपत्ति के गेट्टर और सेटर विधियों के सिंटैक्स को परिभाषित करता है buildDir।

// Using a getter method
println project.buildDir
println getProject().getBuildDir()

// Using a setter method
project.buildDir = 'target'
getProject().setBuildDir('target')

विधि कॉल पर वैकल्पिक कोष्ठक

ग्रूवी में विधियों को कॉल करने की एक विशेष सुविधा होती है, जो कि कोष्ठक विधि विधि के लिए वैकल्पिक है। यह सुविधा ग्रैड स्क्रिप्टिंग पर भी लागू होती है।

निम्नलिखित सिंटैक्स पर एक नज़र डालें। यह एक विधि कॉलिंग को परिभाषित करता हैsystemProperty का test वस्तु।

test.systemProperty 'some.prop', 'value'
test.systemProperty('some.prop', 'value')

विधि के अंतिम पैरामीटर के रूप में बंद करना

ग्रैड डीएसएल कई जगहों पर क्लोजर का उपयोग करता है। जहां विधि का अंतिम पैरामीटर एक बंद होता है, आप विधि को कॉल करने के बाद बंद कर सकते हैं।

निम्नलिखित स्निपेट सिंटैक्सिस क्लोज़र को रिपॉजिटरी () विधि मापदंडों के रूप में उपयोग करता है।

repositories {
   println "in a closure"
}
repositories() { 
   println "in a closure" 
}
repositories({ println "in a closure" })

डिफ़ॉल्ट आयात

ग्रैडल स्वचालित रूप से ग्रैडल स्क्रिप्ट में आयात विवरणों का एक सेट जोड़ता है। निम्न सूची आपको ग्रैडल स्क्रिप्ट में डिफ़ॉल्ट आयात पैकेज दिखाती है।

import org.gradle.*
import org.gradle.api.*
import org.gradle.api.artifacts.*
import org.gradle.api.artifacts.cache.*
import org.gradle.api.artifacts.component.*
import org.gradle.api.artifacts.dsl.*
import org.gradle.api.artifacts.ivy.*
import org.gradle.api.artifacts.maven.*
import org.gradle.api.artifacts.query.*
import org.gradle.api.artifacts.repositories.*
import org.gradle.api.artifacts.result.*
import org.gradle.api.component.*
import org.gradle.api.credentials.*
import org.gradle.api.distribution.*
import org.gradle.api.distribution.plugins.*
import org.gradle.api.dsl.*
import org.gradle.api.execution.*
import org.gradle.api.file.*
import org.gradle.api.initialization.*
import org.gradle.api.initialization.dsl.*
import org.gradle.api.invocation.*
import org.gradle.api.java.archives.*
import org.gradle.api.logging.*
import org.gradle.api.plugins.*
import org.gradle.api.plugins.announce.*
import org.gradle.api.plugins.antlr.*
import org.gradle.api.plugins.buildcomparison.gradle.*
import org.gradle.api.plugins.jetty.*
import org.gradle.api.plugins.osgi.*
import org.gradle.api.plugins.quality.*
import org.gradle.api.plugins.scala.*
import org.gradle.api.plugins.sonar.*
import org.gradle.api.plugins.sonar.model.*
import org.gradle.api.publish.*
import org.gradle.api.publish.ivy.*
import org.gradle.api.publish.ivy.plugins.*
import org.gradle.api.publish.ivy.tasks.*
import org.gradle.api.publish.maven.*
import org.gradle.api.publish.maven.plugins.*
import org.gradle.api.publish.maven.tasks.*
import org.gradle.api.publish.plugins.*
import org.gradle.api.reporting.*
import org.gradle.api.reporting.components.*
import org.gradle.api.reporting.dependencies.*
import org.gradle.api.reporting.model.*
import org.gradle.api.reporting.plugins.*
import org.gradle.api.resources.*
import org.gradle.api.specs.*
import org.gradle.api.tasks.*
import org.gradle.api.tasks.ant.*
import org.gradle.api.tasks.application.*
import org.gradle.api.tasks.bundling.*
import org.gradle.api.tasks.compile.*
import org.gradle.api.tasks.diagnostics.*
import org.gradle.api.tasks.incremental.*
import org.gradle.api.tasks.javadoc.*
import org.gradle.api.tasks.scala.*
import org.gradle.api.tasks.testing.*
import org.gradle.api.tasks.testing.junit.*
import org.gradle.api.tasks.testing.testng.*
import org.gradle.api.tasks.util.*
import org.gradle.api.tasks.wrapper.*
import org.gradle.authentication.*
import org.gradle.authentication.http.*
import org.gradle.buildinit.plugins.*
import org.gradle.buildinit.tasks.*
import org.gradle.external.javadoc.*
import org.gradle.ide.cdt.*
import org.gradle.ide.cdt.tasks.*
import org.gradle.ide.visualstudio.*
import org.gradle.ide.visualstudio.plugins.*
import org.gradle.ide.visualstudio.tasks.*
import org.gradle.ivy.*
import org.gradle.jvm.*
import org.gradle.jvm.application.scripts.*
import org.gradle.jvm.application.tasks.*
import org.gradle.jvm.platform.*
import org.gradle.jvm.plugins.*
import org.gradle.jvm.tasks.*
import org.gradle.jvm.tasks.api.*
import org.gradle.jvm.test.*
import org.gradle.jvm.toolchain.*
import org.gradle.language.assembler.*
import org.gradle.language.assembler.plugins.*
import org.gradle.language.assembler.tasks.*
import org.gradle.language.base.*
import org.gradle.language.base.artifact.*
import org.gradle.language.base.plugins.*
import org.gradle.language.base.sources.*
import org.gradle.language.c.*
import org.gradle.language.c.plugins.*
import org.gradle.language.c.tasks.*
import org.gradle.language.coffeescript.*
import org.gradle.language.cpp.*
import org.gradle.language.cpp.plugins.*
import org.gradle.language.cpp.tasks.*
import org.gradle.language.java.*
import org.gradle.language.java.artifact.*
import org.gradle.language.java.plugins.*
import org.gradle.language.java.tasks.*
import org.gradle.language.javascript.*
import org.gradle.language.jvm.*
import org.gradle.language.jvm.plugins.*
import org.gradle.language.jvm.tasks.*
import org.gradle.language.nativeplatform.*
import org.gradle.language.nativeplatform.tasks.*
import org.gradle.language.objectivec.*
import org.gradle.language.objectivec.plugins.*
import org.gradle.language.objectivec.tasks.*
import org.gradle.language.objectivecpp.*
import org.gradle.language.objectivecpp.plugins.*
import org.gradle.language.objectivecpp.tasks.*
import org.gradle.language.rc.*
import org.gradle.language.rc.plugins.*
import org.gradle.language.rc.tasks.*
import org.gradle.language.routes.*
import org.gradle.language.scala.*
import org.gradle.language.scala.plugins.*
import org.gradle.language.scala.tasks.*
import org.gradle.language.scala.toolchain.*
import org.gradle.language.twirl.*
import org.gradle.maven.*
import org.gradle.model.*
import org.gradle.nativeplatform.*
import org.gradle.nativeplatform.platform.*
import org.gradle.nativeplatform.plugins.*
import org.gradle.nativeplatform.tasks.*
import org.gradle.nativeplatform.test.*
import org.gradle.nativeplatform.test.cunit.*
import org.gradle.nativeplatform.test.cunit.plugins.*
import org.gradle.nativeplatform.test.cunit.tasks.*
import org.gradle.nativeplatform.test.googletest.*
import org.gradle.nativeplatform.test.googletest.plugins.*
import org.gradle.nativeplatform.test.plugins.*
import org.gradle.nativeplatform.test.tasks.*
import org.gradle.nativeplatform.toolchain.*
import org.gradle.nativeplatform.toolchain.plugins.*
import org.gradle.platform.base.*
import org.gradle.platform.base.binary
import org.gradle.platform.base.component.*
import org.gradle.platform.base.plugins.*
import org.gradle.platform.base.test.*
import org.gradle.play.*
import org.gradle.play.distribution.*
import org.gradle.play.platform.*
import org.gradle.play.plugins.*
import org.gradle.play.tasks.*
import org.gradle.play.toolchain.*
import org.gradle.plugin.use.*
import org.gradle.plugins.ear.*
import org.gradle.plugins.ear.descriptor.*
import org.gradle.plugins.ide.api.*
import org.gradle.plugins.ide.eclipse.*
import org.gradle.plugins.ide.idea.*
import org.gradle.plugins.javascript.base.*
import org.gradle.plugins.javascript.coffeescript.*
import org.gradle.plugins.javascript.envjs.*
import org.gradle.plugins.javascript.envjs.browser.*
import org.gradle.plugins.javascript.envjs.http.*
import org.gradle.plugins.javascript.envjs.http.simple.*
import org.gradle.plugins.javascript.jshint.*
import org.gradle.plugins.javascript.rhino.*
import org.gradle.plugins.javascript.rhino.worker.*
import org.gradle.plugins.signing.*
import org.gradle.plugins.signing.signatory.*
import org.gradle.plugins.signing.signatory.pgp.*
import org.gradle.plugins.signing.type.*
import org.gradle.plugins.signing.type.pgp.*
import org.gradle.process.*
import org.gradle.sonar.runner.*
import org.gradle.sonar.runner.plugins.*
import org.gradle.sonar.runner.tasks.*
import org.gradle.testing.jacoco.plugins.*
import org.gradle.testing.jacoco.tasks.*
import org.gradle.testkit.runner.*
import org.gradle.util.*

ग्रैड बिल्ड स्क्रिप्ट एक या अधिक प्रोजेक्ट्स के बारे में वर्णन करती है। प्रत्येक परियोजना विभिन्न कार्यों से बनी होती है। एक कार्य एक टुकड़ा है जो एक निर्माण कार्य करता है। कार्य कुछ कक्षाओं को संकलित कर सकता है, वर्ग फ़ाइलों को अलग लक्ष्य फ़ोल्डर में जमा कर सकता है, JAR का निर्माण कर सकता है, Javadoc उत्पन्न कर सकता है, या एक रिपॉजिटरी में कुछ प्राप्तियां प्रकाशित कर सकता है।

यह अध्याय इस बारे में बताता है कि कार्य क्या है और किसी कार्य को कैसे और कैसे किया जाता है।

परिभाषित करने वाले कार्य

टास्क एक कीवर्ड होता है जिसका उपयोग किसी कार्य को स्क्रिप्ट बनाने में परिभाषित करने के लिए किया जाता है। निम्नलिखित उदाहरण पर एक नज़र डालें जो नाम के कार्य का प्रतिनिधित्व करता हैhello वह प्रिंट करता है tutorialspoint। निम्नलिखित स्क्रिप्ट को नाम की फ़ाइल में कॉपी करें और सहेजेंbuild.gradle। यह बिल्ड स्क्रिप्ट एक कार्य नाम हैलो को परिभाषित करता है जिसका उपयोग ट्यूटोरियलस्पर्श स्ट्रिंग को प्रिंट करने के लिए किया जाता है।

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित करें। यह उपरोक्त स्क्रिप्ट को निष्पादित करता है। आपको इसे निष्पादित करना चाहिए जहां build.gradle फ़ाइल संग्रहीत है।

C:\> gradle –q hello

आउटपुट:

tutorialspoint

आप एक शॉर्टकट निर्दिष्ट करके इस हैलो कार्य को सरल कर सकते हैं (एक प्रतीक का प्रतिनिधित्व करता है <<) को doLastबयान। यदि आप इस शॉर्टकट को उपरोक्त कार्य में जोड़ते हैंhello यह निम्नलिखित स्क्रिप्ट की तरह दिखेगा।

task hello << {
   println 'tutorialspoint'
}

आप उपरोक्त स्क्रिप्ट का उपयोग करके निष्पादित कर सकते हैं gradle –q hello आदेश।

किसी कार्य को परिभाषित करने में यहां कुछ विविधताएं हैं, इस पर एक नज़र डालें। निम्न उदाहरण एक कार्य को परिभाषित करता हैhello।

निम्नलिखित कोड को कॉपी करें और सहेजें build.gradle फ़ाइल।

task (hello) << {
   println "tutorialspoint"
}

कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित करें। यह ऊपर दी गई स्क्रिप्ट को निष्पादित करता है। आपको इसे निष्पादित करना चाहिए, जहां build.gradle फ़ाइल स्टोर होती है।

C:\> gradle –q hello

आउटपुट:

tutorialspoint

आप कार्य नामों के लिए स्ट्रिंग्स का उपयोग भी कर सकते हैं। एक ही हैलो उदाहरण पर एक नज़र डालें। यहां हम स्ट्रिंग का उपयोग कार्य के रूप में करेंगे।

निम्नलिखित कोड को कॉपी करें और सहेजें build.gradle फ़ाइल।

task('hello') << {
   println "tutorialspoint"
}

कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित करें। यह ऊपर दी गई स्क्रिप्ट को निष्पादित करता है। आपको इसे निष्पादित करना चाहिए, जहां build.gradle फ़ाइल स्टोर होती है।

C:\> gradle –q hello

आउटपुट:

tutorialspoint

आप किसी कार्य को परिभाषित करने के लिए वैकल्पिक वाक्यविन्यास का उपयोग भी कर सकते हैं। जो किसी कार्य को परिभाषित करने के लिए create () विधि का उपयोग कर रहा है। नीचे दिए गए समान हैलो उदाहरण में एक नज़र डालें।

नीचे दिए गए कोड को कॉपी करें और सहेजें build.gradle फ़ाइल।

tasks.create(name: 'hello') << {
   println "tutorialspoint"
}

कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित करें। यह ऊपर दी गई स्क्रिप्ट को निष्पादित करता है। आपको इसे निष्पादित करना चाहिए, जहां build.gradle फ़ाइल स्टोर होती है।

C:\> gradle –q hello

आउटपुट:

tutorialspoint

टास्क का पता लगाना

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

निम्नलिखित कोड पर एक नज़र डालें जो कार्यों को गुणों के रूप में एक्सेस कर रहे हैं।

नीचे दिए गए कोड को कॉपी करें और सहेजें build.gradle फ़ाइल।

task hello

println hello.name
println project.hello.name

कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित करें। यह ऊपर दी गई स्क्रिप्ट को निष्पादित करता है। आपको इसे निष्पादित करना चाहिए, जहां build.gradle फ़ाइल स्टोर होती है।

C:\> gradle –q hello

आउटपुट:

hello
hello

आप कार्य संग्रह के माध्यम से सभी गुणों का उपयोग भी कर सकते हैं।

निम्नलिखित कोड को कॉपी करें और सहेजें build.gradle फ़ाइल।

task hello

println tasks.hello.name
println tasks['hello'].name

कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित करें। यह ऊपर दी गई स्क्रिप्ट को निष्पादित करता है। आपको इसे निष्पादित करना चाहिए, जहां build.gradle फ़ाइल स्टोर होती है।

C:\> gradle –q hello

आउटपुट:

hello
hello

आप कार्यों का उपयोग करके कार्य के पथ तक भी पहुंच सकते हैं। इसके लिए आप getByPath () विधि को किसी कार्य नाम, या किसी संबंधित पथ, या किसी पूर्ण पथ के साथ कॉल कर सकते हैं।

नीचे दिए गए कोड को कॉपी करें और सहेजें build.gradle फ़ाइल।

project(':projectA') {
   task hello
}
task hello

println tasks.getByPath('hello').path
println tasks.getByPath(':hello').path
println tasks.getByPath('projectA:hello').path
println tasks.getByPath(':projectA:hello').path

कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित करें। यह ऊपर दी गई स्क्रिप्ट को निष्पादित करता है। आपको इसे निष्पादित करना चाहिए, जहां build.gradle फ़ाइल स्टोर होती है।

C:\> gradle –q hello

आउटपुट:

:hello
:hello
:projectA:hello
:projectA:hello

कार्य में निर्भरता जोड़ना

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

निम्नलिखित उदाहरण जो टास्क से टास्कय पर निर्भरता जोड़ता है।

नीचे दिए गए कोड को कॉपी करें और सहेजें build.gradleफ़ाइल। निम्नलिखित कोड पर एक नज़र डालें।

task taskX << {
   println 'taskX'
}
task taskY(dependsOn: 'taskX') << {
   println "taskY"
}

कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित करें। यह ऊपर दी गई स्क्रिप्ट को निष्पादित करता है। आपको इसे निष्पादित करना चाहिए, जहांbuild.gradle फ़ाइल स्टोर।

C:\> gradle –q taskY

आउटपुट:

taskX
taskY

उपरोक्त उदाहरण अपने नामों का उपयोग करके कार्य पर निर्भरता को जोड़ रहा है। कार्य निर्भरता को प्राप्त करने का एक और तरीका है जो टास्क ऑब्जेक्ट का उपयोग करके निर्भरता को परिभाषित करता है।

आइए हम टास्क का एक ही उदाहरण लेते हैं टास्क एक्स पर निर्भर होने के बावजूद हम टास्क रेफरेंस नामों के बजाय टास्क ऑब्जेक्ट का उपयोग कर रहे हैं।

निम्नलिखित कोड को कॉपी करें और सहेजें build.gradle फ़ाइल।

task taskY << {
   println 'taskY'
}
task taskX << {
   println 'taskX'
}
taskY.dependsOn taskX

कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित करें। आपको इसे निष्पादित करना चाहिए जहां build.gradle फ़ाइल संग्रहीत है।

C:\> gradle –q taskY

आउटपुट:

taskX
taskY

उपरोक्त उदाहरण अपने नामों का उपयोग करके कार्य पर निर्भरता को जोड़ रहा है। कार्य निर्भरता को प्राप्त करने का एक और तरीका है जो टास्क ऑब्जेक्ट का उपयोग करके निर्भरता को परिभाषित करता है।

यहां हम एक ही उदाहरण लेते हैं कि टास्क टास्क पर निर्भर है लेकिन हम टास्क रेफरेंस नामों के बजाय टास्क ऑब्जेक्ट का उपयोग कर रहे हैं। इस पर एक नज़र डालें।

नीचे दिए गए कोड को कॉपी करें और सहेजें build.gradleफ़ाइल। निम्नलिखित कोड पर एक नज़र डालें।

task taskX << {
   println 'taskX'
}
taskX.dependsOn {
   tasks.findAll { 
      task → task.name.startsWith('lib') 
   }
}
task lib1 << {
   println 'lib1'
}
task lib2 << {
   println 'lib2'
}
task notALib << {
   println 'notALib'
}

कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित करें। यह ऊपर दी गई स्क्रिप्ट को निष्पादित करता है। आपको इसे निष्पादित करना चाहिए, जहांbuild.gradle फ़ाइल स्टोर।

C:\> gradle –q taskX

आउटपुट:

lib1
lib2
taskX

किसी कार्य का विवरण जोड़ना

आप अपने कार्य के लिए एक विवरण जोड़ सकते हैं। यह विवरण निष्पादित करते समय प्रदर्शित होता हैGradle tasks। यह विवरण कीवर्ड का उपयोग करके संभव है।

निम्नलिखित कोड को कॉपी करें और सहेजें build.gradleफ़ाइल। निम्नलिखित कोड पर एक नज़र डालें।

task copy(type: Copy) {
   description 'Copies the resource directory to the target directory.'
   from 'resources'
   into 'target'
   include('**/*.txt', '**/*.xml', '**/*.properties')
   println("description applied")
}

कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित करें। आपको इसे निष्पादित करना चाहिए जहां build.gradle फ़ाइल संग्रहीत है।

C:\> gradle –q copy

यदि कमांड को सफलतापूर्वक निष्पादित किया जाता है, तो आपको निम्न आउटपुट मिलेगा।

description applied

स्किपिंग टास्क

स्किपिंग कार्यों को एक विधेय बंद करके पारित किया जा सकता है। यह तभी संभव है जब किसी कार्य का तरीका या एक फेंकने का तरीकाStopExecutionException किसी कार्य के वास्तविक कार्य को निष्पादित करने से पहले।

निम्नलिखित कोड को कॉपी करें और सहेजें build.gradle फ़ाइल।

task eclipse << {
   println 'Hello Eclipse'
}

// #1st approach - closure returning true, if the task should be executed, false if not.
eclipse.onlyIf {
   project.hasProperty('usingEclipse')
}

// #2nd approach - alternatively throw an StopExecutionException() like this
eclipse.doFirst {
   if(!usingEclipse) {
      throw new StopExecutionException()
   }
}

कमांड प्रॉम्प्ट में निम्न कमांड निष्पादित करें। आपको इसे निष्पादित करना चाहिए जहां build.gradle फ़ाइल संग्रहीत है।

C:\> gradle –q eclipse

कार्य संरचना

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

कॉन्फ़िगरेशन चरण के बाद, निष्पादन चरण कोड के अंदर कोड चलाता है doFirst या doLast उन कार्यों को बंद करना, जिन्हें वास्तव में निष्पादित किया जाता है।

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

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

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

अपनी निर्भरता की घोषणा

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

apply plugin: 'java'

repositories {
   mavenCentral()
}

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
   testCompile group: 'junit', name: 'junit', version: '4.+'
}

निर्भरता विन्यास

निर्भरता कॉन्फ़िगरेशन कुछ भी नहीं है लेकिन निर्भरता के एक सेट को परिभाषित करता है। आप इस सुविधा का उपयोग बाहरी निर्भरता को घोषित करने के लिए कर सकते हैं, जिसे आप वेब से डाउनलोड करना चाहते हैं। यह निम्नलिखित विभिन्न मानक विन्यासों को परिभाषित करता है।

  • Compile - परियोजना के उत्पादन स्रोत को संकलित करने के लिए आवश्यक निर्भरताएँ।

  • Runtime- रनटाइम के दौरान उत्पादन वर्गों द्वारा आवश्यक निर्भरताएं। डिफ़ॉल्ट रूप से, संकलन समय निर्भरता भी शामिल है।

  • Test Compile- परियोजना के परीक्षण स्रोत को संकलित करने के लिए आवश्यक निर्भरताएँ। डिफ़ॉल्ट रूप से, इसमें संकलित उत्पादन कक्षाएं और संकलन समय निर्भरताएं शामिल हैं।

  • Test Runtime- परीक्षण चलाने के लिए आवश्यक निर्भरताएँ। डिफ़ॉल्ट रूप से, इसमें रनटाइम और परीक्षण संकलन निर्भरताएं शामिल हैं।

बाहरी निर्भरता

बाहरी निर्भरताएं निर्भरता के प्रकार में से एक हैं। यह वर्तमान बिल्ड पर निर्मित कुछ फ़ाइलों पर निर्भरता है, और कुछ प्रकार के भंडार में संग्रहीत किया जाता है, जैसे कि मावेन सेंट्रल, या एक कॉर्पोरेट मावेन या लेवी रिपॉजिटरी, या एक निर्देशिका मैं स्थानीय फ़ाइल सिस्टम।

निम्नलिखित कोड स्निपेट बाहरी निर्भरता को परिभाषित करने के लिए है। इस कोड का उपयोग करेंbuild.gradle फ़ाइल।

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
}

एक बाहरी निर्भरता बाहरी निर्भरता घोषित कर रही है और शॉर्टकट रूप "समूह: नाम: संस्करण" जैसा दिखता है।

डेटा संग्रह स्थान

बाहरी निर्भरता जोड़ते समय। ग्रेडल एक रिपॉजिटरी में उनकी तलाश करता है। एक रिपॉजिटरी केवल फाइलों का एक संग्रह है, जो समूह, नाम और संस्करण द्वारा आयोजित किया जाता है। डिफ़ॉल्ट रूप से, ग्रैडल किसी भी रिपोजिटरी को परिभाषित नहीं करता है। हमें कम से कम एक रिपॉजिटरी को स्पष्ट रूप से परिभाषित करना होगा। निम्नलिखित कोड स्निपेट मावेन रिपॉजिटरी को परिभाषित करने के तरीके को परिभाषित करता है। इस कोड का उपयोग करेंbuild.gradle फ़ाइल।

repositories {
   mavenCentral()
}

निम्नलिखित कोड दूरस्थ मावेन को परिभाषित करना है। इस कोड का उपयोग करेंbuild.gradle फ़ाइल।

repositories {
   maven {
      url "http://repo.mycompany.com/maven2"
   }
}

प्रकाशन कलाकृतियों

फ़ाइलों को प्रकाशित करने के लिए निर्भरता कॉन्फ़िगरेशन का भी उपयोग किया जाता है। इन प्रकाशित फाइलों को कलाकृतियां कहा जाता है। आमतौर पर, हम कलाकृतियों को परिभाषित करने के लिए प्लग-इन का उपयोग करते हैं। हालाँकि, आपको कलाकृतियों को प्रकाशित करने के लिए ग्रैडल को बताने की आवश्यकता है। आप अपलोड अभिलेखागार कार्य में रिपॉजिटरी संलग्न करके इसे प्राप्त कर सकते हैं। मावेन भंडार को प्रकाशित करने के लिए निम्नलिखित वाक्यविन्यास पर एक नज़र डालें। निष्पादित करते समय, ग्रैडल प्रोजेक्ट आवश्यकताओं के अनुसार एक पोम.एक्सएमएल उत्पन्न और अपलोड करेगा। इस कोड का उपयोग करेंbuild.gradle फ़ाइल।

apply plugin: 'maven'

uploadArchives {
   repositories {
      mavenDeployer {
         repository(url: "file://localhost/tmp/myRepo/")
      }
   }
}

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

  • बुनियादी ग्रैडल मॉडल का विस्तार करें (उदाहरण के लिए कॉन्फ़िगर किए जा सकने वाले नए डीएसएल तत्व जोड़ें)।
  • रूपांतरण के अनुसार परियोजना को कॉन्फ़िगर करें (जैसे नए कार्य जोड़ें या समझदार चूक को कॉन्फ़िगर करें)।
  • विशिष्ट कॉन्फ़िगरेशन लागू करें (जैसे संगठनात्मक रिपॉजिटरी जोड़ें या मानकों को लागू करें)।

प्लगइन्स के प्रकार

ग्रैडल, स्क्रिप्ट प्लगइन्स और बाइनरी प्लगइन्स में दो प्रकार के प्लगइन्स हैं। स्क्रिप्ट प्लगइन्स एक अतिरिक्त बिल्ड स्क्रिप्ट है जो बिल्ड में हेरफेर करने के लिए एक घोषणात्मक दृष्टिकोण देता है। यह आमतौर पर एक बिल्ड के भीतर उपयोग किया जाता है। बाइनरी प्लगइन्स कक्षाएं हैं जो प्लगइन इंटरफ़ेस को लागू करती हैं और बिल्ड में हेरफेर करने के लिए प्रोग्रामेटिक दृष्टिकोण अपनाती हैं। बाइनरी प्लगइन्स बिल्ड स्क्रिप्ट के साथ प्रोजेक्ट पदानुक्रम के साथ या बाह्य रूप से प्लग इन JAR में रह सकते हैं।

प्लगइन्स को लागू करना

Project.apply()एपीआई विधि का उपयोग विशेष प्लगइन को लागू करने के लिए किया जाता है। आप कई बार एक ही प्लगइन का उपयोग कर सकते हैं। दो प्रकार के प्लगइन्स हैं एक स्क्रिप्ट स्क्रिप्ट है और दूसरा बाइनरी प्लगइन है।

स्क्रिप्ट प्लगइन्स

स्क्रिप्ट प्लगिन को स्थानीय फाइल सिस्टम पर या दूरस्थ स्थान पर स्क्रिप्ट से लागू किया जा सकता है। फ़ाइलसिस्टम स्थान प्रोजेक्ट निर्देशिका के सापेक्ष होते हैं, जबकि दूरस्थ स्क्रिप्ट स्थान HTTP URL निर्दिष्ट करते हैं। निम्नलिखित कोड स्निपेट पर एक नज़र डालें। इसका उपयोग करने के लिए किया जाता हैother.gradleनिर्माण स्क्रिप्ट के लिए प्लगइन। इस कोड का उपयोग करेंbuild.gradle फ़ाइल।

apply from: 'other.gradle'

बाइनरी प्लगइन्स

प्रत्येक प्लगइन को प्लगइन आईडी द्वारा पहचाना जाता है कुछ कोर प्लगइन्स इसे लागू करने के लिए छोटे नामों का उपयोग कर रहे हैं और कुछ सामुदायिक प्लग इन प्लगइन आईडी के लिए पूरी तरह से योग्य नाम का उपयोग कर रहे हैं। कुछ समय यह प्लगइन की कक्षा को निर्दिष्ट करने की अनुमति देता है।

निम्नलिखित कोड स्निपेट पर एक नज़र डालें। यह दिखाता है कि अपने प्रकार का उपयोग करके जावा प्लगइन कैसे लागू किया जाए। इस कोड का उपयोग करेंbuild.gradle फ़ाइल।

apply plugin: JavaPlugin

संक्षिप्त नाम का उपयोग करके कोर प्लगइन को लागू करने के लिए निम्नलिखित कोड पर एक नज़र डालें। इस कोड का उपयोग करेंbuild.gradle फ़ाइल।

plugins {
   id 'java'
}

संक्षिप्त नाम का उपयोग करके सामुदायिक प्लगइन को लागू करने के लिए निम्नलिखित कोड पर एक नज़र डालें। इस कोड का उपयोग करेंbuild.gradle फ़ाइल।

plugins {
   id "com.jfrog.bintray" version "0.4.1"
}

कस्टम प्लगइन्स लिखना

कस्टम प्लगइन बनाते समय, आपको प्लगइन का कार्यान्वयन लिखना होगा। ग्रैडल प्लगइन को इंस्टैंट करता है और प्लग इन का उपयोग प्लगिन.प्ली () विधि से करता है। निम्नलिखित नमूने में एक ग्रीटिंग प्लगइन है, जो परियोजना में एक हैलो कार्य जोड़ता है। निम्नलिखित कोड पर एक नज़र डालें। इस कोड का उपयोग करेंbuild.gradle फ़ाइल।

apply plugin: GreetingPlugin

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.task('hello') << {
         println "Hello from the GreetingPlugin"
      }
   }
}

उपरोक्त स्क्रिप्ट को निष्पादित करने के लिए निम्न कोड का उपयोग करें।

C:\> gradle -q hello

आउटपुट:

Hello from the GreetingPlugin

बिल्ड से इनपुट प्राप्त करना

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

आइए प्रोजेक्ट में एक साधारण एक्सटेंशन ऑब्जेक्ट जोड़ें। यहां हम परियोजना के लिए एक ग्रीटिंग एक्सटेंशन ऑब्जेक्ट जोड़ते हैं, जो आपको ग्रीटिंग को कॉन्फ़िगर करने की अनुमति देता है। इस कोड का उपयोग करेंbuild.gradle फ़ाइल।

apply plugin: GreetingPlugin

greeting.message = 'Hi from Gradle'

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      // Add the 'greeting' extension object
      project.extensions.create("greeting", GreetingPluginExtension)
		
      // Add a task that uses the configuration
      project.task('hello') << {
         println project.greeting.message
      }
   }
}

class GreetingPluginExtension {
   def String message = 'Hello from GreetingPlugin'
}

उपरोक्त स्क्रिप्ट को निष्पादित करने के लिए निम्न कोड का उपयोग करें।

C:\> gradle -q hello

आउटपुट:

Hi from Gradle

इस उदाहरण में, GreetingPlugin एक मैदानी पुरानी ग्रूवी वस्तु है जिसमें संदेश नामक क्षेत्र है। विस्तार वस्तु को प्लगइन सूची में नाम अभिवादन के साथ जोड़ा जाता है। यह ऑब्जेक्ट तब प्रोजेक्ट प्रॉपर्टी के रूप में उपलब्ध होता है, जो एक्सटेंशन ऑब्जेक्ट के समान नाम के साथ होता है।

ग्रैडल प्रत्येक एक्सटेंशन ऑब्जेक्ट के लिए कॉन्फ़िगरेशन क्लोजर जोड़ता है, जिससे आप सेटिंग्स को एक साथ समूहित कर सकते हैं। निम्नलिखित कोड पर एक नज़र डालें। इस कोड का उपयोग करेंbuild.gradle फ़ाइल।

apply plugin: GreetingPlugin

greeting {
   message = 'Hi'
   greeter = 'Gradle'
}

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.extensions.create("greeting", GreetingPluginExtension)
		
      project.task('hello') << {
         println "${project.greeting.message} from ${project.greeting.greeter}"
      }
   }
}

class GreetingPluginExtension {
   String message
   String greeter
}

उपरोक्त स्क्रिप्ट को निष्पादित करने के लिए निम्न कोड का उपयोग करें।

C:\> gradle -q hello

आउटपुट:

Hello from Gradle

मानक ग्रेडल प्लगइन्स

अलग-अलग प्लगइन्स हैं जो ग्रैडल वितरण में शामिल हैं।

भाषा प्लगइन्स

ये प्लगइन्स विभिन्न भाषाओं के लिए समर्थन जोड़ते हैं जिन्हें JVM में संकलित और निष्पादित किया जा सकता है।

प्लगइन आईडी स्वचालित रूप से लागू होता है विवरण
जावा जावा आधार एक परियोजना के लिए जावा संकलन, परीक्षण और बंडल क्षमताओं को जोड़ता है। यह अन्य ग्रेडल प्लगइन्स में से कई के लिए आधार के रूप में कार्य करता है।
ग्रूवी जावा, ग्रूवी आधार ग्रूवी परियोजनाओं के निर्माण के लिए समर्थन जोड़ता है।
स्केला जावा, स्केला आधार स्काला परियोजनाओं के निर्माण के लिए समर्थन जोड़ता है।
antlr जावा Antlr का उपयोग करके पार्सर उत्पन्न करने के लिए समर्थन जोड़ता है।

भाषा प्लगइन्स सेते हुए

ये प्लगइन्स विभिन्न भाषाओं के लिए समर्थन जोड़ते हैं।

प्लगइन आईडी स्वचालित रूप से लागू होता है विवरण
कोडांतरक - एक परियोजना के लिए मूल विधानसभा भाषा क्षमताओं को जोड़ता है।
सी - एक परियोजना के लिए सी स्रोत संकलन क्षमताओं को जोड़ता है।
सीपीपी - एक परियोजना के लिए C ++ स्रोत संकलन क्षमताओं को जोड़ता है।
उद्देश्य सी - एक परियोजना के लिए उद्देश्य-सी स्रोत संकलन क्षमताओं को जोड़ता है।
उद्देश्य-सीपीपी - एक परियोजना के लिए उद्देश्य-सी ++ स्रोत संकलन क्षमताओं को जोड़ता है।
windows-संसाधन - देशी बायनेरिज़ में विंडोज संसाधनों को शामिल करने के लिए समर्थन जोड़ता है।

ग्रैड लिपि का निर्माण करने के लिए कमांड लाइन प्रदान करता है। यह एक बार में एक से अधिक कार्य निष्पादित कर सकता है। यह अध्याय बताता है कि विभिन्न विकल्पों का उपयोग करके कई कार्यों को कैसे निष्पादित किया जाए।

एकाधिक कार्य निष्पादित करना

आप एक निर्माण फ़ाइल से कई कार्यों को निष्पादित कर सकते हैं। ग्रैडल हैंडल का उपयोग करके फाइल का निर्माण कर सकता हैgradle command। यह आदेश प्रत्येक कार्य को इस क्रम में संकलित करेगा कि वे सूचीबद्ध हैं और प्रत्येक कार्य को विभिन्न विकल्पों का उपयोग कर निर्भरता के साथ निष्पादित करते हैं।

Example- चार कार्य हैं - task1, task2, task3 और task4। टास्क 3 और टास्क 4 कार्य 1and टास्क 2 पर निर्भर करता है। निम्नलिखित आरेख पर एक नज़र डालें।

उपर्युक्त 4 कार्यों में एक दूसरे पर निर्भर एक तीर के प्रतीक के साथ प्रतिनिधित्व किया गया है। निम्नलिखित कोड पर एक नज़र डालें। कॉपी में पेस्ट कर सकते हैंbuild.gradle फ़ाइल।

task task1 << {
   println 'compiling source'
}

task task2(dependsOn: task1) << {
   println 'compiling unit tests'
}

task task3(dependsOn: [task1, task2]) << {
   println 'running unit tests'
}

task task4(dependsOn: [task1, task3]) << {
   println 'building the distribution'
}

आप उपरोक्त कोड को कार्य के संकलन और क्रियान्वयन के लिए उपयोग कर सकते हैं।

C:\> gradle task4 test

आउटपुट:

:task1
compiling source
:task2
compiling unit tests
:task3
running unit tests
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

टास्क को छोड़कर

कार्य को निष्पादन से बाहर करते समय आप ग्रेड कमांड के साथ -x विकल्प का उपयोग कर सकते हैं और कार्य के नाम का उल्लेख कर सकते हैं, जिसे आप बाहर करना चाहते हैं।

उपरोक्त स्क्रिप्ट से टास्क 4 को बाहर करने के लिए निम्न कमांड का उपयोग करें।

C:\> gradle task4 -x test

आउटपुट:

:task1
compiling source
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

जब एक विफलता का निर्माण जारी है

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

कौन से बिल्ड टू एक्ज़ेक्यूट का चयन करना

जब आप वर्गीकृत कमांड चलाते हैं, तो यह वर्तमान निर्देशिका में एक बिल्ड फ़ाइल की तलाश करता है। पूर्ण पथ के साथ-साथ किसी विशेष बिल्ड फ़ाइल का चयन करने के लिए -b विकल्प का उपयोग कर सकते हैं। निम्नलिखित उदाहरण से एक परियोजना हैलो का चयन करनाmyproject.gradle फ़ाइल जो में स्थित है subdir/ इस पर एक नज़र डालें।

task hello << {
   println "using build file '$buildFile.name' in '$buildFile.parentFile.name'."
}

उपरोक्त स्क्रिप्ट को निष्पादित करने के लिए आप निम्न कमांड का उपयोग कर सकते हैं।

C:\> gradle -q -b subdir/myproject.gradle hello

आउटपुट:

using build file 'myproject.gradle' in 'subdir'.

निर्माण जानकारी प्राप्त करना

ग्रैड कार्य और परियोजना के बारे में जानकारी के विवरण को पुनः प्राप्त करने के लिए कई अंतर्निहित कार्य प्रदान करता है। यह संरचना और आपके निर्माण की निर्भरता और डीबगिंग समस्याओं के लिए समझने के लिए उपयोगी हो सकता है। आप अपने प्रोजेक्ट में कार्यों को जोड़ने के लिए प्रोजेक्ट रिपोर्ट प्लगइन का उपयोग कर सकते हैं, जो इन रिपोर्टों को उत्पन्न करेगा।

लिस्टिंग परियोजनाओं

आप चयनित परियोजना के प्रोजेक्ट पदानुक्रम और उनके उपयोग से उप परियोजनाओं को सूचीबद्ध कर सकते हैं gradle –q projectsआदेश। यहां उदाहरण है, बिल्ड फ़ाइल में सभी प्रोजेक्ट को सूचीबद्ध करने के लिए निम्न कमांड का उपयोग करें।

C:\> gradle -q projects

आउटपुट:

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'projectReports'
+--- Project ':api' - The shared API for the application
\--- Project ':webapp' - The Web application implementation

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :api:tasks

यदि निर्दिष्ट हो तो रिपोर्ट प्रत्येक परियोजना का विवरण दिखाती है। आप विवरण निर्दिष्ट करने के लिए निम्न आदेश का उपयोग कर सकते हैं। इसमें पेस्ट करेंbuild.gradle फ़ाइल।

description = 'The shared API for the application'

लिस्टिंग के कार्य

आप निम्न कमांड का उपयोग करके उन सभी कार्यों को सूचीबद्ध कर सकते हैं जो कई परियोजनाओं से संबंधित हैं।

C:\> gradle -q tasks

आउटपुट:

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Default tasks: dists

Build tasks
-----------
clean - Deletes the build directory (build)
dists - Builds the distribution
libs - Builds the JAR

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'projectReports'.
components - Displays the components produced by root project 'projectReports'. [incubating]
dependencies - Displays all dependencies declared in root project 'projectReports'.
dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'.
help - Displays a help message.
model - Displays the configuration model of root project 'projectReports'. [incubating]
projects - Displays the sub-projects of root project 'projectReports'.
properties - Displays the properties of root project 'projectReports'.
tasks - Displays the tasks runnable from root project 'projectReports' 
   (some of the displayed tasks may belong to subprojects).

To see all tasks and more detail, run gradle tasks --all

To see more detail about a task, run gradle help --task <task>

सभी कार्यों की जानकारी प्रदर्शित करने के लिए आप निम्न कमांड का उपयोग कर सकते हैं।

C:\> gradle -q tasks --all

आउटपुट:

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Default tasks: dists

Build tasks
-----------
clean - Deletes the build directory (build)
api:clean - Deletes the build directory (build)
webapp:clean - Deletes the build directory (build)
dists - Builds the distribution [api:libs, webapp:libs]
   docs - Builds the documentation
api:libs - Builds the JAR
   api:compile - Compiles the source files
webapp:libs - Builds the JAR [api:libs]
   webapp:compile - Compiles the source files

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'projectReports'.
api:buildEnvironment - Displays all buildscript dependencies declared in project ':api'.
webapp:buildEnvironment - Displays all buildscript dependencies declared in project ':webapp'.
components - Displays the components produced by root project 'projectReports'. [incubating]
api:components - Displays the components produced by project ':api'. [incubating]
webapp:components - Displays the components produced by project ':webapp'. [incubating]
dependencies - Displays all dependencies declared in root project 'projectReports'.
api:dependencies - Displays all dependencies declared in project ':api'.
webapp:dependencies - Displays all dependencies declared in project ':webapp'.
dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'.
api:dependencyInsight - Displays the insight into a specific dependency in project ':api'.
webapp:dependencyInsight - Displays the insight into a specific dependency in project ':webapp'.
help - Displays a help message.
api:help - Displays a help message.
webapp:help - Displays a help message.
model - Displays the configuration model of root project 'projectReports'. [incubating]
api:model - Displays the configuration model of project ':api'. [incubating]
webapp:model - Displays the configuration model of project ':webapp'. [incubating]
projects - Displays the sub-projects of root project 'projectReports'.
api:projects - Displays the sub-projects of project ':api'.
webapp:projects - Displays the sub-projects of project ':webapp'.
properties - Displays the properties of root project 'projectReports'.
api:properties - Displays the properties of project ':api'.
webapp:properties - Displays the properties of project ':webapp'.
tasks - Displays the tasks runnable from root project 'projectReports' 
   (some of the displayed tasks may belong to subprojects).
api:tasks - Displays the tasks runnable from project ':api'.
webapp:tasks - Displays the tasks runnable from project ':webapp'.

यहाँ तालिका के विभिन्न विकल्पों में कुछ आदेशों की सूची दी गई है।

अनु क्रमांक। आदेश विवरण
1 gradle –q help –task <कार्य नाम> किसी विशिष्ट कार्य या कई कार्यों के बारे में उपयोग की जानकारी (जैसे पथ, प्रकार, विवरण, समूह) प्रदान करता है।
2 gradle –q निर्भरताएँ चयनित परियोजना की निर्भरता की एक सूची प्रदान करता है।
3 gradle -q api: निर्भरताएँ --configuration <कार्य नाम> कॉन्फ़िगरेशन से संबंधित सीमित निर्भरता की सूची प्रदान करता है।
4 gradle –q buildEnvironment स्क्रिप्ट की निर्भरता के निर्माण की सूची प्रदान करता है।
5 gradle –q dependencyInsight एक विशेष निर्भरता में एक अंतर्दृष्टि प्रदान करता है।
6 ग्रेड-गुण चयनित परियोजना के गुणों की सूची प्रदान करता है।

यह अध्याय ग्रैड बिल्ड फ़ाइल का उपयोग करके जावा प्रोजेक्ट बनाने के तरीके के बारे में बताता है।

सबसे पहले हमें java plugin को build script में जोड़ना होगा क्योंकि यह Java source code को compile करने, Unit test चलाने, Javadoc बनाने और JAR file बनाने के लिए कार्य प्रदान करता है। में निम्नलिखित लाइन का उपयोग करेंbuild.gradle फ़ाइल।

apply plugin: 'java'

जावा डिफ़ॉल्ट परियोजना लेआउट

जब आप अपने निर्माण में एक प्लगइन जोड़ते हैं तो यह आपके जावा प्रोजेक्ट (मावेन के समान) का एक निश्चित सेटअप मान लेता है। निम्नलिखित निर्देशिका संरचना पर एक नज़र डालें।

  • src / main / java में Java सोर्स कोड होता है
  • src / test / java में जावा परीक्षण शामिल हैं

यदि आप इस सेटअप का पालन करते हैं, तो निम्न बिल्ड फ़ाइल जावा प्रोजेक्ट को संकलित करने, परीक्षण करने और बंडल करने के लिए पर्याप्त है।

बिल्ड शुरू करने के लिए, कमांड लाइन पर निम्न कमांड टाइप करें।

C:\> gradle build

SourceSetsएक अलग परियोजना संरचना निर्दिष्ट करने के लिए इस्तेमाल किया जा सकता है। उदाहरण के लिए, स्रोतों में संग्रहित किया जाता हैsrc के बजाय फ़ोल्डर src/main/java। निम्नलिखित निर्देशिका संरचना पर एक नज़र डालें।

apply plugin: 'java'
sourceSets {
   main {
      java {
         srcDir 'src'
      }
   }
	
   test {
      java {
         srcDir 'test'
      }
   }
}

init टास्क निष्पादन

ग्रेडल अभी तक कई प्रोजेक्ट टेम्प्लेट का समर्थन नहीं करता है। लेकिन यह एक प्रदान करता हैinitएक नए ग्रेडल प्रोजेक्ट की संरचना तैयार करने का कार्य। अतिरिक्त मापदंडों के बिना, यह कार्य ग्रैडल प्रोजेक्ट बनाता है, जिसमें ग्रेडल रैपर फाइलें होती हैं, एbuild.gradle तथा settings.gradle फ़ाइल।

जोड़ते समय --type के साथ पैरामीटर java-library मूल्य के रूप में, एक जावा परियोजना संरचना बनाई गई है और build.gradleफ़ाइल में जूनिट के साथ एक निश्चित जावा टेम्प्लेट है। निम्नलिखित कोड के लिए एक नज़र रखनाbuild.gradle फ़ाइल।

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

रिपॉजिटरी सेक्शन में, यह परिभाषित करता है कि कहाँ पर निर्भरताएँ ढूंढनी हैं। Jcenterअपनी निर्भरता को हल करने के लिए है। निर्भरता अनुभाग बाहरी निर्भरता के बारे में जानकारी प्रदान करने के लिए है।

जावा संस्करण निर्दिष्ट करना

आमतौर पर, एक जावा प्रोजेक्ट का एक संस्करण और एक लक्ष्य JRE होता है, जिस पर इसे संकलित किया जाता है। version तथा sourceCompatibility प्रॉपर्टी में सेट किया जा सकता है build.gradle फ़ाइल।

version = 0.1.0
sourceCompatibility = 1.8

यदि कलाकृति एक निष्पादन योग्य जावा अनुप्रयोग है, MANIFEST.MF फ़ाइल को मुख्य विधि के साथ वर्ग के बारे में पता होना चाहिए।

apply plugin: 'java'

jar {
   manifest {
      attributes 'Main-Class': 'com.example.main.Application'
   }
}

Example:

एक निर्देशिका संरचना बनाएँ जैसा कि नीचे स्क्रीनशॉट में दिखाया गया है।

नीचे दिए गए java code को App.java फ़ाइल में कॉपी करें और स्टोर करें consumerbanking\src\main\java\com\bank directory।

package com.bank;

/**
* Hello world!
*
*/

public class App {
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

नीचे दिए गए जावा कोड को AppTset.java फाइल में कॉपी करें और स्टोर करें consumerbanking\src\test\java\com\bank directory।

package com.bank;

/**
* Hello world!
*
*/

public class App{
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

नीचे दिए गए कोड को build.gradle फ़ाइल में कॉपी करें और में रखा गया consumerbanking\ निर्देशिका।

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

jar {
   manifest {
      attributes 'Main-Class': 'com.example.main.Application'
   }
}

उपरोक्त स्क्रिप्ट को संकलित करने और निष्पादित करने के लिए नीचे दिए गए आदेशों का उपयोग करें।

consumerbanking\> gradle tasks
consumerbanking\> gradle assemble
consumerbanking\> gradle build

संबंधित निर्देशिकाओं में सभी वर्ग फ़ाइलों की जाँच करें और जाँच करें consumerbanking\build\lib के लिए फ़ोल्डर consumerbanking.jar फ़ाइल।

यह अध्याय बताता है कि ग्रूवी परियोजना का उपयोग करके कैसे संकलित और निष्पादित किया जाए build.gradle फ़ाइल।

ग्रूवी प्लग-इन

ग्रूवी प्लग-इन ग्रैडल जावा प्लग-इन का विस्तार करता है और ग्रूवी कार्यक्रमों के लिए कार्य प्रदान करता है। आप groovy प्लगइन लगाने के लिए निम्न लाइन का उपयोग कर सकते हैं।

apply plugin: 'groovy'

पूर्ण बिल्ड स्क्रिप्ट फ़ाइल निम्नानुसार है। निम्नलिखित कोड को कॉपी करेंbuild.gradle फ़ाइल।

apply plugin: 'groovy'

repositories {
   mavenCentral()
}

dependencies {
   compile 'org.codehaus.groovy:groovy-all:2.4.5'
   testCompile 'junit:junit:4.12'
}

बिल्ड स्क्रिप्ट निष्पादित करने के लिए आप निम्न कमांड का उपयोग कर सकते हैं।

gradle build

ग्रूवी प्रोजेक्ट्स का डिफ़ॉल्ट प्रोजेक्ट लेआउट

Groovy प्लगइन आपके Groovy प्रोजेक्ट का एक निश्चित सेटअप मानता है।

  • src / main / groovy में Groovy source कोड होता है
  • src / test / groovy में ग्रूवी परीक्षण शामिल हैं
  • src / main / java में Java सोर्स कोड होता है
  • src / test / java में जावा परीक्षण शामिल हैं

जहां संबंधित निर्देशिका की जाँच करें build.gradle बिल्ड फ़ोल्डर के लिए फ़ाइल स्थान।

परीक्षण कार्य स्वचालित रूप से परीक्षण स्रोत सेट में सभी इकाई परीक्षणों का पता लगाता है और निष्पादित करता है। परीक्षण निष्पादन पूर्ण होने के बाद यह एक रिपोर्ट भी तैयार करता है। JUnit और TestNG समर्थित API हैं।

परीक्षण कार्य एक प्रदान करता है Test.getDebug()विधि है कि JVM डिबगर के लिए प्रतीक्षा करने के लिए लॉन्च करने के लिए सेट किया जा सकता है। निष्पादन से पहले, यह डिबगर पोस्ट को सेट करता है5005।

टेस्ट डिटेक्शन

Test Taskसंकलित परीक्षण कक्षाओं का निरीक्षण करके पता लगाता है कि कौन सी कक्षाएं परीक्षण कक्षाएं हैं। डिफ़ॉल्ट रूप से यह सभी .class फ़ाइलों को स्कैन करता है। आप कस्टम को शामिल / बहिष्कृत कर सकते हैं, केवल उन वर्गों को स्कैन किया जाएगा। उपयोग किए गए परीक्षण ढांचे (JUnit / TestNG) के आधार पर, परीक्षण वर्ग का पता लगाने में विभिन्न मानदंडों का उपयोग होता है।

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

  • क्लास या एक सुपर क्लास TestCase या GroovyTestCase का विस्तार करती है
  • क्लास या सुपर क्लास को @RunWith के साथ एनोटेट किया जाता है
  • क्लास या सुपर क्लास में @Test के साथ एनोटेट किया गया तरीका होता है
  • TestNG का उपयोग करते समय, हम @Test के साथ एनोटेट किए गए तरीकों के लिए स्कैन करते हैं

Note- अमूर्त वर्गों को निष्पादित नहीं किया जाता है। ग्रैडल टेस्ट क्लासपाथ पर इनहेरिटेंस ट्री को जार फाइलों में भी स्कैन करता है।

यदि आप टेस्ट क्लास डिटेक्शन का उपयोग नहीं करना चाहते हैं, तो आप इसे सेटिंग द्वारा अक्षम कर सकते हैं scanForTestClasses असत्य को।

टेस्ट ग्रुपिंग

JUnit और TestNG परीक्षण विधियों के परिष्कृत समूहों की अनुमति देता है। समूहीकरण के लिए, JUnit परीक्षण कक्षाएं और विधियाँ JUnit 4.8 श्रेणियों की अवधारणा का परिचय देती हैं। परीक्षण कार्य उन JUnit श्रेणियों के विनिर्देशन की अनुमति देता है जिन्हें आप शामिल करना और बाहर करना चाहते हैं।

आप समूह परीक्षण विधियों में build.gradle फ़ाइल में निम्न कोड स्निपेट का उपयोग कर सकते हैं।

test {
   useJUnit {
      includeCategories 'org.gradle.junit.CategoryA'
      excludeCategories 'org.gradle.junit.CategoryB'
   }
}

शामिल करें और विशेष रूप से टेस्ट छोड़ें

Test क्लास ए है include तथा excludeतरीका। इन विधियों का उपयोग यह निर्दिष्ट करने के लिए किया जा सकता है कि कौन से परीक्षण वास्तव में चलने चाहिए।

केवल सम्मिलित परीक्षण चलाएं -

test {
   include '**my.package.name/*'
}

बहिष्कृत परीक्षण छोड़ें -

test {
   exclude '**my.package.name/*'
}

नमूना build.gradle फ़ाइल के रूप में नीचे दिखाया गया है यह विभिन्न विन्यास विकल्प दिखाता है।

apply plugin: 'java' // adds 'test' task

test {
   // enable TestNG support (default is JUnit)
   useTestNG()

   // set a system property for the test JVM(s)
   systemProperty 'some.prop', 'value'

   // explicitly include or exclude tests
   include 'org/foo/**'
   exclude 'org/boo/**'

   // show standard out and standard error of the test JVM(s) on the console
   testLogging.showStandardStreams = true

   // set heap size for the test JVM(s)
   minHeapSize = "128m"
   maxHeapSize = "512m"

   // set JVM arguments for the test JVM(s)
   jvmArgs '-XX:MaxPermSize=256m'
   
   // listen to events in the test execution lifecycle
   beforeTest { 
      descriptor → logger.lifecycle("Running test: " + descriptor)
   }

   // listen to standard out and standard error of the test JVM(s)
   onOutput { 
      descriptor, event → logger.lifecycle
         ("Test: " + descriptor + " produced standard out/err: " 
         + event.message )
   }
}

कुछ परीक्षण कार्य को निष्पादित करने के लिए आप निम्न कमांड सिंटैक्स का उपयोग कर सकते हैं।

gradle <someTestTask> --debug-jvm

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

मल्टी-प्रोजेक्ट बिल्ड के लिए संरचना

इस तरह के बिल्ड सभी आकार और आकारों में आते हैं, लेकिन उनकी कुछ सामान्य विशेषताएं हैं -

  • ए settings.gradle परियोजना के रूट या मास्टर निर्देशिका में फ़ाइल।

  • ए build.gradle रूट या मास्टर निर्देशिका में फ़ाइल।

  • बाल निर्देशिकाएँ जिनका अपना है *.gradle फ़ाइलों का निर्माण (कुछ मल्टी-प्रोजेक्ट बिल्ड चाइल्ड प्रोजेक्ट बिल्ड स्क्रिप्ट्स को छोड़ सकते हैं)।

बिल्ड फ़ाइल में सभी प्रोजेक्ट्स को सूचीबद्ध करने के लिए, आप निम्न कमांड का उपयोग कर सकते हैं।

C:\> gradle -q projects

आउटपुट:

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'projectReports'
+--- Project ':api' - The shared API for the application
\--- Project ':webapp' - The Web application implementation

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :api:tasks

यदि निर्दिष्ट किया गया है, तो रिपोर्ट प्रत्येक परियोजना का विवरण दिखाती है। आप विवरण निर्दिष्ट करने के लिए निम्न आदेश का उपयोग कर सकते हैं। इसमें पेस्ट करेंbuild.gradle फ़ाइल।

description = 'The shared API for the application'

सामान्य बिल्ड कॉन्फ़िगरेशन निर्दिष्ट करना

में build.gradle रूट_प्रोजेक्ट में फ़ाइल, सामान्य कॉन्फ़िगरेशन सभी परियोजनाओं या सिर्फ उप परियोजनाओं के लिए लागू किया जा सकता है।

allprojects {
   group = 'com.example.gradle'
   version = '0.1.0'
}

subprojects {
   apply plugin: 'java'
   apply plugin: 'eclipse'
}

यह एक सामान्य निर्दिष्ट करता है com.example.gradle समूह और 0.1.0सभी परियोजनाओं के लिए संस्करण। subprojects क्लोजर सभी उप परियोजनाओं के लिए सामान्य कॉन्फ़िगरेशन लागू करता है, लेकिन रूट प्रोजेक्ट की तरह नहीं allprojects बंद करता है

परियोजना विशिष्ट विन्यास और निर्भरताएँ

कोर ui तथा util उपप्रोजेक्ट भी अपने स्वयं के हो सकते हैं build.gradle फ़ाइल, यदि उनकी विशिष्ट आवश्यकताएं हैं, जो रूट प्रोजेक्ट के सामान्य कॉन्फ़िगरेशन द्वारा पहले से लागू नहीं हैं।

उदाहरण के लिए, यूआई परियोजना में आमतौर पर कोर परियोजना पर निर्भरता होती है। इसलिए यूआई परियोजना को अपनी जरूरत हैbuild.gradle इस निर्भरता को निर्दिष्ट करने के लिए फ़ाइल।

dependencies {
   compile project(':core')
   compile 'log4j:log4j:1.2.17'
}

परियोजना की निर्भरता परियोजना पद्धति के साथ निर्दिष्ट की जाती है।

ग्रैड कलाकृतियों के रिपॉजिटरी बनाने के लिए कई तरीके पेश करता है। जब आप अपनी कलाकृतियों के लिए Maven रिपॉजिटरी में हस्ताक्षर तैनात करते हैं, तो आप प्रकाशित POM फ़ाइल पर भी हस्ताक्षर करना चाहेंगे।

मावेन-प्रकाशित प्लगइन का उपयोग करना

maven-publishप्लगइन, जो डिफ़ॉल्ट रूप से ग्रेडल द्वारा प्रदान किया जाता है। प्रवण लिपि को प्रकाशित करने के लिए उपयोग किया जाता है। निम्नलिखित कोड पर एक नज़र डालें।

apply plugin: 'java'
apply plugin: 'maven-publish'

publishing {
   publications {
      mavenJava(MavenPublication) {
         from components.java
      }
   }

   repositories {
      maven {
         url "$buildDir/repo"
      }
   }
}

कई प्रकाशित विकल्प हैं, जब Java और यह maven-publishप्लगइन लगाया जाता है। निम्नलिखित कोड पर एक नज़र डालें, यह परियोजना को एक दूरस्थ भंडार में तैनात करेगा।

apply plugin: 'groovy'
apply plugin: 'maven-publish'

group 'workshop'
version = '1.0.0'

publishing {
   publications {
      mavenJava(MavenPublication) { 
         from components.java 
      }
   }
	
   repositories {
      maven {
          default credentials for a nexus repository manager
         credentials {
            username 'admin'
            password 'admin123'
         }
         // url to the releases maven repository
            url "http://localhost:8081/nexus/content/repositories/releases/"
      }
   }
}

मावेन से ग्रैडल के लिए एक परियोजना परिवर्तित करना

अपाचे मावेन को परिवर्तित करने के लिए एक विशेष कमांड है pom.xml फ़ाइलों का निर्माण करने के लिए फ़ाइलों का निर्माण, अगर सभी मावेन प्लग-इन का उपयोग इस कार्य के लिए जाना जाता है।

इस खंड में निम्नलिखित हैं pom.xmlmaven कॉन्फ़िगरेशन को ग्रैडल प्रोजेक्ट में परिवर्तित किया जाएगा। इस पर एक नज़र डालें।

<project xmlns = "http://maven.apache.org/POM/4.0.0" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
	
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.example.app</groupId>
   <artifactId>example-app</artifactId>
   <packaging>jar</packaging>
   
   <version>1.0.0-SNAPSHOT</version>
	
   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>

         <version>4.11</version>
         <scope>test</scope>
      </dependency>
   </dependencies>
	
</project>

आप कमांड लाइन पर निम्न कमांड का उपयोग कर सकते हैं, जिसके परिणामस्वरूप निम्न ग्रेड कॉन्फ़िगरेशन होता है।

C:\> gradle init --type pom

init टास्क रैपर टास्क पर निर्भर करता है ताकि ग्रैडल रैपर बनाया जाए।

जिसके परिणामस्वरूप build.gradle फ़ाइल इस तरह दिखाई देती है -

apply plugin: 'java'
apply plugin: 'maven'

group = 'com.example.app'
version = '1.0.0-SNAPSHOT'

description = """"""

sourceCompatibility = 1.5
targetCompatibility = 1.5

repositories {
   maven { url "http://repo.maven.apache.org/maven2" }
}

dependencies {
   testCompile group: 'junit', name: 'junit', version:'4.11'
}

यह अध्याय ग्रहण और ग्रैडल के एकीकरण के बारे में बताता है। ग्रहण करने के लिए ग्रेड प्लगइन जोड़ने के लिए नीचे दिए गए चरणों का पालन करें।

चरण 1 - ग्रहण मार्केटप्लेस खोलें

सबसे पहले ग्रहण खोलें जो आपके सिस्टम में स्थापित है। मदद पर जाएं -> EclipseMarketplace पर क्लिक करें। निम्नलिखित स्क्रीनशॉट में एक नज़र डालें।

चरण 2 - स्थापित प्लगइन्स प्लगिन

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

उसके बाद आपको निम्न स्क्रीनशॉट मिलेगा जिसमें आपको पुष्टि बटन पर क्लिक करके सॉफ़्टवेयर इंस्टॉलेशन की पुष्टि करनी होगी। निम्नलिखित स्क्रीनशॉट में एक नज़र डालें।

उसके बाद आपको निम्न स्क्रीन में स्वीकार लाइसेंस समझौते पर क्लिक करने और फिनिश पर क्लिक करने की आवश्यकता है। निम्नलिखित स्क्रीनशॉट में एक नज़र डालें।

इसे स्थापित करने में कुछ समय लगेगा। निम्नलिखित स्क्रीनशॉट पर एक नज़र डालें।

उसके बाद, यह ग्रहण को फिर से शुरू करने के लिए कहेगा। वहां आप सेलेक्ट करेंगेYes।

चरण 3 - ग्रेडिंग प्लगइन को सत्यापित करना

सत्यापित करते समय हम दिए गए प्रक्रिया का पालन करके एक नई परियोजना बनाएंगे। ग्रहण में फ़ाइल पर जाएँ -> नए पर क्लिक करें-> अन्य परियोजनाओं पर क्लिक करें। वहां आपको निम्न स्क्रीन मिलेगी। ग्रैडल प्रोजेक्ट चुनें और अगले पर क्लिक करें। निम्नलिखित स्क्रीन शॉट पर एक नज़र डालें।

अगले बटन पर क्लिक करने के बाद आपको निम्न स्क्रीन मिलेगी। वहां आप स्थानीय फ़ाइल सिस्टम के ग्रेड होम निर्देशिका पथ प्रदान करेंगे और अगले बटन पर क्लिक करेंगे। निम्नलिखित स्क्रीनशॉट में एक नज़र डालें।

निम्नलिखित स्क्रीनशॉट में एक नज़र डालें यहां आप ग्रेडल प्रोजेक्ट के लिए नाम प्रदान करेंगे। इस ट्यूटोरियल में हम उपयोग कर रहे हैंdemoproject और फिनिश बटन पर क्लिक करें।

निम्नलिखित स्क्रीनशॉट में देखें कि हमें परियोजना की पुष्टि करने की आवश्यकता है। उसके लिए हमारे पास निम्न स्क्रीन में क्लिक बटन है।

चरण 4 - निर्देशिका संरचना का सत्यापन

ग्रेडल प्लगइन की सफल स्थापना के बाद, कृपया निम्न स्क्रीनशॉट में दिखाए गए अनुसार डिफ़ॉल्ट फ़ाइलों और फ़ोल्डरों के लिए डेमो प्रोजेक्ट निर्देशिका संरचना की जांच करें।

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved