ग्रैडल के साथ एक मल्टी-मॉड्यूल जावा प्रोजेक्ट। कदम से कदम

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



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

पहले हम लक्ष्य पर निर्णय लेते हैं, हम निकास पर क्या प्राप्त करना चाहते हैं? और लक्ष्य को लेख के शीर्षक में दर्शाया गया है। हम कई मॉड्यूल के साथ एक परियोजना प्राप्त करना चाहते हैं, जिसे ग्रैडल का उपयोग करके बनाया गया है। और इसलिए, चलो शुरू करें।

चरण 1. स्थापित करें

नोट: यदि आप लेख के लिए फ़ाइलों को डाउनलोड करके केवल "प्ले" करना चाहते हैं, या आपको प्रोजेक्ट के रूट में मैजिक फाइल gradlew (gradlew.bat) के साथ किसी और के स्रोत मिल गए हैं, तो gradle इंस्टॉल करना आवश्यक नहीं है।



ग्रेडेल डाउनलोड पेज से नवीनतम संस्करण को डाउनलोड करने या अपने पसंदीदा ओएस में पैकेज मैनेजर का उपयोग करके ग्रेड स्थापित किया जा सकता है (ध्यान दें: मैंने इसे मैक ओएस पर ब्रू के माध्यम से और डेबियन पर उपयुक्त स्रोतों से प्राप्त किया)



पहले चरण का परिणाम:

$ gradle -version ------------------------------------------------------------ Gradle 1.11 ------------------------------------------------------------ Build time: 2014-02-11 11:34:39 UTC Build number: none Revision: a831fa866d46cbee94e61a09af15f9dd95987421 Groovy: 1.8.6 Ant: Apache Ant(TM) version 1.9.2 compiled on July 8 2013 Ivy: 2.2.0 JVM: 1.8.0_05 (Oracle Corporation 25.5-b02) OS: Mac OS X 10.9.3 x86_64
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

चरण 2. खाली परियोजना, प्लगइन्स, आवरण

एक प्रोजेक्ट फ़ोल्डर बनाएँ और इसके मूल में निम्न सामग्री के साथ build.gradle



फ़ाइल बनाएँ:



{project_path} /build.gralde

 apply plugin: “java” apply plugin: “application” task wrapper(type: Wrapper) { gradleVersion = '1.12' }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

इस फ़ाइल में हम java



और application



प्लग इन शामिल हैं। java



प्लगइन में जार जैसे उपयोगी कार्य शामिल हैं - जार आर्काइव संकलित करने के लिए, संकलन कोड - आदि को संकलित करने के लिए, आप प्लगइन के बारे में अधिक पढ़ सकते हैं। application



प्लगइन में कार्य शामिल हैं: रन - एप्लिकेशन लॉन्च करें; installApp - कंप्यूटर पर एप्लिकेशन इंस्टॉल करें, यह कार्य * निक्स और विंडोज़ (बैट फ़ाइल) के लिए निष्पादन योग्य फाइलें बनाता है; distZip - एक जिप आर्काइव में एप्लिकेशन को इकट्ठा करता है, सभी जार फाइलों को वहां रखता है, साथ ही साथ ऑपरेटिंग सिस्टम-विशिष्ट स्क्रिप्ट भी। प्रलेखन में प्लगइन के बारे में और पढ़ें।

अब हम wrapper



टास्क पर अधिक विस्तार से ध्यान दें। यह बहुत उपयोगी कार्य संभवतः प्रोग्रामर्स के लिए जीवन को आसान बनाने के लिए डिज़ाइन किया गया सबसे सरल समाधान है। $ gradle wrapper



, हमें निम्न परिणाम मिलते हैं:

 $ gradle wrapper :wrapper BUILD SUCCESSFUL Total time: 7.991 secs
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

 $ ls -a . .. .gradle build.gradle gradle gradlew gradlew.bat
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

हम देखते हैं कि स्क्रिप्ट ने विंडोज के लिए * nix, gradlew.bat और साथ ही gradle और .gradle फ़ोल्डरों के लिए gradlew निष्पादक बनाए हैं। छिपे हुए। Regle फ़ोल्डर को रिपॉजिटरी से छोड़ा जा सकता है, इसमें निर्भरता लाइब्रेरी है। सभी बेसिक ग्रेडिएंट में और gradlew फाइल में ही है। अब हम सुरक्षित रूप से किसी भी व्यक्ति को अपनी परियोजना दे सकते हैं, जिसके पास सही संस्करण की jdk है, और वह परियोजना का उपयोग करके संकलन, इकट्ठा, स्थापित कर सकता है ./gradlew



। ध्यान दें कि मेरे ढाल का संस्करण (ऊपर $ gradle -version



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

 $ ./gradlew -version ------------------------------------------------------------ Gradle 1.12 ------------------------------------------------------------ Build time: 2014-04-29 09:24:31 UTC Build number: none Revision: a831fa866d46cbee94e61a09af15f9dd95987421 Groovy: 1.8.6 Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013 Ivy: 2.2.0 JVM: 1.8.0_05 (Oracle Corporation 25.5-b02) OS: Mac OS X 10.9.3 x86_64
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अब, gradlew



बजाय gradle



आप सुरक्षित रूप से gradlew



उपयोग कर सकते हैं। वैसे, मापदंडों के बिना $ ./gradlew



निष्पादित करने से .gralde



फ़ोल्डर .gralde



जाएगा और वहां सभी आश्रित पुस्तकालयों को डाउनलोड करें (नीचे निर्भरता के बारे में)। लेकिन इस कमांड का निष्पादन आवश्यक नहीं है, क्योंकि किसी भी ग्रेडेल (gradlew) के शुरू होने पर, निर्भरता की जाँच की जाएगी और लापता फ़ाइलों को डाउनलोड किया जाएगा। इसलिए, प्रोजेक्ट को प्राप्त करना जिसमें gradlew फाइलें स्थित हैं, आप तुरंत वांछित कार्य लॉन्च कर सकते हैं, जिसकी एक सूची कमांड द्वारा प्राप्त की जा सकती है ./gradlew tasks







दूसरे चरण के परिणाम (निष्कर्ष कम हो गया है):

 $ ./gradlew tasks :tasks ------------------------------------------------------------ All tasks runnable from root project ------------------------------------------------------------ Application tasks ----------------- distTar - Bundles the project as a JVM application with libs and OS specific scripts. distZip - Bundles the project as a JVM application with libs and OS specific scripts. installApp - Installs the project as a JVM application along with libs and OS specific scripts. run - Runs this project as a JVM application ... Other tasks ----------- wrapper ... To see all tasks and more detail, run with --all. BUILD SUCCESSFUL Total time: 7.808 secs
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

चरण 3. रिक्त स्थान भरें

इस स्तर पर, हम पहले से ही कई gradle



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

 src -main -java -resources -test -java -resources
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

main/java



हमारे प्रोग्राम की java फाइल्स हैं, main/resources



बाकी फाइलें (* .properties, * .xml, * .img और अन्य) हैं। test



में परीक्षण के लिए आवश्यक फाइलें हैं।

चूंकि इस लेख में परीक्षण पर विचार नहीं किया जाएगा, इसलिए हम सभी सबफ़ोल्डर्स के साथ src/main



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



फ़ाइल में परिवर्तन करें, src/main/java



फ़ोल्डर में मुख्य एप्लिकेशन वर्ग के साथ फ़ाइल com/example/Main.java



बनाएँ, साथ ही सेटिंग्स फ़ाइल Log4j src/main/resources/log4j.xml



log4j.xml फ़ाइल बनाएँ। और gradle.properties



फ़ाइल (वैकल्पिक, नीचे विवरण)



{project_path} /build.gradle

 apply plugin: "java" apply plugin: "application" mainClassName = "com.example.Main" sourceCompatibility = JavaVersion.VERSION_1_7 targetCompatibility = JavaVersion.VERSION_1_7 repositories { mavenCentral() } dependencies { compile "log4j:log4j:1.2.17" } jar { manifest.attributes("Main-Class": mainClassName); } task wrapper(type: Wrapper) { gradleVersion = "1.12" }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

{project_path} /gradle.properties

 org.gradle.java.home=/Library/Java/JavaVirtualMachines/jdk1.7.0_55.jdk/Contents/Home/
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

{project_path} /src/main/java/com/example/Main.java

 package com.example; import org.apache.log4j.Logger; public class Main { private static final Logger LOG = Logger.getLogger(Main.class); public static void main(String[] args) { LOG.info("Application started"); System.out.println("I'm the main project"); LOG.info("Application finished"); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

{project_path} /src/main/resources/log4j.xml

 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd"> <log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/"> <appender name="console" class="org.apache.log4j.ConsoleAppender"> <param name="Target" value="System.out"/> <layout class="org.apache.log4j.PatternLayout"> <param name="ConversionPattern" value="%p %c: %m%n"/> </layout> </appender> <root> <priority value ="debug" /> <appender-ref ref="console" /> </root> </log4j:configuration>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

build.gradle



फ़ाइल में परिवर्तनों पर विचार करें। हमने चर mainClassName



जोड़ा। यह हमारे एप्लिकेशन के मुख्य वर्ग को इंगित करता है और run



टास्क में application



प्लगइन द्वारा उपयोग किया जाता है। यह यह वर्ग है जिसे लॉन्च किया जाएगा। हमने उन्हें JavaVersion.VERSION_1_7



का मान JavaVersion.VERSION_1_7



करते हुए targetCompatibility



और targetCompatibility



को भी जोड़ा है। ये java



plugin के वैरिएबल हैं; ये दिखाते हैं कि हमें jdk के कौन से वर्जन को बिल्डिंग करते समय चाहिए। अगला ब्लॉक repositories



। इस ब्लॉक में हम मावेन भंडार से जुड़ते हैं। ग्रैडल उसके साथ बहुत "दोस्ताना" है। dependencies



ब्लॉक में हमारे आवेदन की निर्भरताएं शामिल हैं। हम प्रलेखन में सेटिंग्स की सूक्ष्मताओं को देखते हैं। यहाँ हम संकेत करते हैं कि compile



कार्य के लिए log4j की आवश्यकता है। उदाहरण में एक शॉर्टहैंड सिंटैक्स है। आप एक विस्तृत संस्करण लिख सकते हैं और यह इस तरह दिखेगा:

 complie group: 'log4j', name: 'log4j', version: '1.2.17'
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

तुलना के लिए, मावेन में एक समान ब्लॉक:

 <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency>
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आप compile files('libs/a.jar', 'libs/b.jar')



और compile project(':library_project')



compile files('libs/a.jar', 'libs/b.jar')



compile project(':library_project')



compile files('libs/a.jar', 'libs/b.jar')



पर भी निर्भरताएँ कॉन्फ़िगर कर सकते हैं।

build.gradle



का अंतिम जोड़ jar



ब्लॉक है। यह java



प्लगइन को भी संदर्भित करता है। इसमें जार फ़ाइल बनाने के लिए अतिरिक्त जानकारी होती है। इस मामले में, हम मुख्य वर्ग को ऊपर घोषित mainClassName



वैरिएबल का उपयोग करते हुए प्रकट करते हैं।

निम्नलिखित एक वैकल्पिक gradle.properties



फ़ाइल है। इस फ़ाइल का विवरण पूरे प्रलेखन में बिखरा हुआ है, थोड़ा यहां और यहां है । इस मामले में, हम वास्तव में JAVA_HOME



चर को ओवरराइड कर रहे हैं। यह सच है जब आपके पास jdk के कई संस्करण हैं, जैसा कि मेरे मामले में, आप लेख की शुरुआत में ध्यान दे सकते हैं, $ gradle -version



पता चलता है कि JVM: 1.8.0_05 (Oracle Corporation 25.5-b02)



मेरा संस्करण JVM: 1.8.0_05 (Oracle Corporation 25.5-b02)



।

मुझे लगता है कि यह src/main/java/Main.java



और src/main/resources/log4j.xml



पर बसना व्यर्थ है, क्योंकि सब कुछ बेहद सरल है। हम लकड़हारे को दो संदेश भेजते हैं, संदेश "मैं मुख्य परियोजना हूं" कंसोल में प्रदर्शित होता है। Log4j सेटिंग्स फ़ाइल का कहना है कि हमारा लकड़हारा भी कंसोल को संदेश आउटपुट करेगा।



तीसरे चरण के परिणाम:

 $ ./gradlew run :compileJava Download http://repo1.maven.org/maven2/log4j/log4j/1.2.17/log4j-1.2.17.jar :processResources :classes :run INFO com.example.Main: Application started I'm the main project INFO com.example.Main: Application finished BUILD SUCCESSFUL Total time: 14.627 secs
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह देखा जा सकता है कि लापता पुस्तकालय को डाउनलोड किया जा रहा है और इसके उपयोग का प्रदर्शन किया गया है।

चरण 4. लक्ष्य तक पहुँचना

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



और main_project



। अब src



फ़ोल्डर और build.gradle



फ़ाइल को बस बनाए गए main_project



डायरेक्टरी में ले जाएँ, और रूट में निम्न सामग्री के साथ एक नई settings.gradle



बनाएँ। फ़ाइल ( यहाँ इस फ़ाइल के बारे में अधिक):



{project_path} /settings.gradle

 rootProject.name = 'Gradle_Multiproject' include 'main_project'
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस फ़ाइल में हम कहते हैं कि हमारी परियोजना क्या कहलाती है और किन फ़ोल्डरों को कनेक्ट करना है (वास्तव में स्वतंत्र ग्रेडेल प्रोजेक्ट्स)। इस स्तर पर, हमें एक main_project



फ़ोल्डर की आवश्यकता है। इस तरह के बदलावों के बाद, हम $ ./gradlew run



या एक विशिष्ट $ ./gradlew main_project:run



साथ निष्पादित कर सकते $ ./gradlew main_project:run



, और चरण 3 के अंत में भी वैसा ही परिणाम प्राप्त कर सकते हैं। अर्थात, एक कार्यशील परियोजना। हम अन्य सभी jar, build, installApp कमांड आदि को भी निष्पादित कर सकते हैं। ग्रेड, यदि आप एक विशिष्ट उपप्रोजेक्ट निर्दिष्ट नहीं करते हैं, तो सभी जुड़े हुए उपप्रोजेक्टों में कार्य शुरू कर देगा, जिनके पास यह कार्य है (उदाहरण के लिए, यदि एप्लिकेशन प्लगइन केवल एक उपप्रोजेक्ट से जुड़ा है, तो हमारे पास main_project होगा, कमांड $ ./gradlew run



रन केवल इस $ ./gradlew run



)

अब हमारे library_project



में कोड बनाएं। build.gradle



और src/main/java/com/example/library/Simple.java







{project_path} /library_project/build.gradle

 apply plugin: "java" sourceCompatibility = JavaVersion.VERSION_1_7 targetCompatibility = JavaVersion.VERSION_1_7
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

{project_path} /library_project/src/main/java/com/example/library/Simple.java

 package com.example.library; public class Simple { private int value; public int getValue() { return value; } public void setValue(int value) { this.value = value; } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

इस build.gradle



लिए build.gradle



ज्यादा सरल है। हम जावा प्लगइन का उपयोग करते हैं और जेडडीके संस्करण के साथ चर सेट करते हैं। यह इस लेख के लिए पर्याप्त है। अब हम लाइब्रेरी_प्रोजेक्ट सबप्रोजेक्ट के बारे में जानना चाहते हैं, हम सेटिंग.ग्रेड फाइल में इसका वर्णन करेंगे:



{project_path} /settings.gradle

 rootProject.name = 'Gradle_Multiproject' include 'main_project', 'library_project'
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

अब हम अपनी लाइब्रेरी युक्त जार फ़ाइल को $ ./gradlew library_project:jar



कमांड के साथ संकलित कर सकते हैं $ ./gradlew library_project:jar



।

 $ ./gradlew library_project:jar :library_project:compileJava :library_project:processResources UP-TO-DATE :library_project:classes :library_project:jar BUILD SUCCESSFUL Total time: 10.061 secs
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

परिणामी फ़ाइल {project_path}/library_project/build/libs/library_project.jar



पर {project_path}/library_project/build/libs/library_project.jar



जा सकती है।

अब Simple



वर्ग के उपयोग को main_project



। ऐसा करने के लिए, {project_path}/main_project/build.gradle



फ़ाइल में dependencies



ब्लॉक में लाइन compile project(":library_project")



{project_path}/main_project/build.gradle



, जो कहता है कि इस मॉड्यूल में संकलित कार्य करने के लिए {project_path}/main_project/build.gradle



प्रोजेक्ट की आवश्यकता है।



MiniM से परिवर्धन : प्रवणता में, प्रतीक ":" का उपयोग "/" के बजाय किया जाता है और अधिक शाखाओं वाली संरचना के लिए, प्रोजेक्ट लिंक इस तरह दिख सकते हैं :: लोडर: xml-loader



{project_path} /main_project/build.gradle ( dependencies



ब्लॉक)

 dependencies { compile "log4j:log4j:1.2.17" compile project(":library_project") }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

{project_path} /main_project/src/main/java/com/example/Main.ava

 package com.example; import org.apache.log4j.Logger; import com.example.library.Simple; public class Main { private static final Logger LOG = Logger.getLogger(Main.class); public static void main(String[] args) { LOG.info("Application started"); System.out.println("I'm the main project"); Simple simple = new Simple(); simple.setValue(10); System.out.println("Value from Simple: " + simple.getValue()); LOG.info("Application finished"); } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आप जांच कर सकते हैं।



चौथे चरण का परिणाम:

 $ ./gradlew run :library_project:compileJava UP-TO-DATE :library_project:processResources UP-TO-DATE :library_project:classes UP-TO-DATE :library_project:jar UP-TO-DATE :main_project:compileJava :main_project:processResources UP-TO-DATE :main_project:classes :main_project:run INFO com.example.Main: Application started I'm the main project Value from Simple: 10 INFO com.example.Main: Application finished BUILD SUCCESSFUL Total time: 11.022 secs
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

चरण 5 (अंतिम)। हम कचरा हटाते हैं

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



के रूट में build.gradle



और बाकी बिल्ड फ़ाइलों की सामग्री को बदल दें



{project_path} /build.gradle

 apply plugin: "idea" apply plugin: "eclipse" subprojects { apply plugin: "java" tasks.withType(JavaCompile) { sourceCompatibility = JavaVersion.VERSION_1_7 targetCompatibility = JavaVersion.VERSION_1_7 } repositories { mavenCentral() } } task wrapper(type: Wrapper) { gradleVersion = "1.12" }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

{project_path} /main_project/build.gradle

 apply plugin: "application" version = '1.0' mainClassName = "com.example.Main" dependencies { compile "log4j:log4j:1.2.17" compile project(":library_project") } jar { manifest.attributes("Main-Class": mainClassName); }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

{project_path} /build.gradle

 version = "1.1_beta"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

रूट build.gradle



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

subprojects



ब्लॉक में हम subprojects



की सेटिंग्स को डालते हैं, अर्थात्: हम जावा प्लगइन को कनेक्ट करते हैं - सभी को इसकी आवश्यकता होती है; jdk संस्करण सेट करें; हम मावेन भंडार से जुड़ते हैं। इस फ़ाइल में भी हम विचार और ग्रहण प्लगइन्स कनेक्ट करते हैं। इन प्लगइन्स में संबंधित IDE के लिए प्रोजेक्ट फ़ाइल जनरेट करने के लिए कार्य होते हैं। और यहां हम रैपर कार्य को स्थानांतरित करते हैं। सभी के लिए सामान्य फ़ाइलों को वर्गीकृत करने के लिए केवल रूट पर इसकी आवश्यकता होती है।

उपप्रोजेक्ट में, हमने सभी अनावश्यक को हटा दिया और version



चर जोड़ा। इस चर का मान जार फ़ाइलों में जोड़ा जाएगा, उदाहरण के लिए, Library_project.jar के बजाय अब Library_project-1.1.beta.jar होगा।

allprojects



ब्लॉक के अलावा, आप allprojects



या project(':project_name')



उपयोग कर सकते हैं। अधिक जानकारी यहाँ ।



इस पर मैं समाप्त कर दूंगा। मुझे उम्मीद है कि यह लेख ग्रैडल से परिचित नहीं लोगों के बीच रुचि जगाता है, और इस परियोजना में एक अधिक विस्तृत अध्ययन और इस उपकरण के बाद के उपयोग को प्रेरित करता है।



आपका ध्यान देने के लिए धन्यवाद।



अतिरिक्त:

MiniM : ग्रेडेल में, प्रतीक ":" का उपयोग "/" के बजाय किया जाता है और अधिक शाखा संरचना के लिए, प्रोजेक्ट लिंक इस तरह दिख सकते हैं :: लोडर: xml-loader

leventov : idea



प्लगइन के साथ idea



। issues.gradle.org/browse/GRADLE-1041 , अंतिम टिप्पणी में एक समाधान है।

उपयोगी लिंक

बिटबकेट पर लेख में बनाई गई परियोजना के स्रोत ( ज़िप संग्रह )

Gradle

उपयोगकर्ता गाइड ग्रेड करें

अपाचे लॉगिंग सेवाएं

अपाचे मावेन

ग्रूवी भाषा