java - मैं एक ग्रैडल स्क्रिप्ट को दूसरे में कैसे आयात कर सकता हूं?




ant groovy build gradle (4)

मेरे पास एक जटिल ग्रेडल स्क्रिप्ट है जो कई वातावरणों में कई नेटबीन परियोजनाओं के निर्माण और तैनाती के आसपास कार्यक्षमता के भार को लपेटती है।

लिपि बहुत अच्छी तरह से काम करती है, लेकिन संक्षेप में यह सब आधे दर्जन मानचित्रों के माध्यम से परियोजना और पर्यावरण की जानकारी रखने के माध्यम से कॉन्फ़िगर किया गया है।

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

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

अतिरिक्त जानकारी

नीचे टॉम की प्रतिक्रिया के बाद, मैंने सोचा कि मैं वास्तव में कोशिश करूँगा और स्पष्ट करता हूं कि मेरा क्या मतलब है।

असल में मेरे पास एक ग्रेबल स्क्रिप्ट है जो कई उपप्रोजेक्ट चलाती है। हालांकि, सबप्रोजेक्ट्स सभी नेटबीन प्रोजेक्ट्स हैं, और अपनी खुद की चींटी बिल्ड स्क्रिप्ट के साथ आते हैं, इसलिए मेरे पास इनमें से प्रत्येक को कॉल करने के लिए धीरे-धीरे कार्य हैं।

मेरी समस्या यह है कि मेरे पास फ़ाइल के शीर्ष पर कुछ कॉन्फ़िगरेशन है, जैसे कि:

projects = [
    [name:"MySubproject1", shortname: "sub1", env:"mainEnv", cvs_module="mod1"],
    [name:"MySubproject2", shortname: "sub2", env:"altEnv", cvs_module="mod2"]
]

मैं फिर कार्यों को उत्पन्न करता हूं जैसे कि:

projects.each({
    task "checkout_$it.shortname" << {
         // Code to for example check module out from cvs using config from 'it'.
    }
})

मेरे पास इनमें से कई प्रकार की कार्य जनरेशन स्निपेट हैं, और वे सभी सामान्य हैं - वे पूरी तरह से परियोजना सूची में कॉन्फ़िगरेशन पर निर्भर करते हैं।

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

projects = [
    [name:"MySubproject1", shortname: "sub1", env:"mainEnv", cvs_module="mod1"],
    [name:"MySubproject2", shortname: "sub2", env:"altEnv", cvs_module="mod2"]
]

import("tasks.gradle") // This will import and run the script so that all tasks are generated for the projects given above.

तो इस उदाहरण में, tasks.gradle में सभी जेनेरिक कार्य जनरेशन कोड होंगे, और मुख्य build.gradle फ़ाइल में परिभाषित परियोजनाओं के लिए चलाए जाएंगे। इस तरह, tasks.gradle एक ऐसी फाइल है जिसका उपयोग सभी बड़ी परियोजनाओं द्वारा किया जा सकता है जिसमें नेटबीन्स चींटी बिल्ड फाइलों के साथ कई उप-परियोजनाएं शामिल हैं।


Answers

प्रश्न का उत्तर प्लगइन्स सिस्टम में सामने आया, जहां आप प्लगइन के एक सेट में वांछित कार्यक्षमता जोड़ सकते हैं जो निर्देशिका buildSrc/src/main/groovy में स्थित groovy फ़ाइलों को हो सकता है। प्लगइन को जार के रूप में भी बंडल किया जा सकता है हालांकि मैंने यह कोशिश नहीं की है।

विवरण यहां: कस्टम प्लगइन्स


खैर, यह कहना मुश्किल है कि वास्तव में आपकी बिल्ड फ़ाइल को देखे बिना आपको सबसे अच्छा क्या प्रदान करता है।

मैं मान सकता हूं कि बहु-परियोजना निर्माण के रूप में आपके पर्यावरण को व्यवस्थित करना आपको उस अमूर्तता प्रदान करना चाहिए जो आप खोज रहे हैं।

अपनी प्रोजेक्ट रूट build.gradle आप अपने सभी डोमेन विशिष्ट सामानों के साथ-साथ उन सभी चीजों को परिभाषित करते हैं जो आपके सभी build.gradle लागू होते हैं:

repositories {
    add(new org.apache.ivy.plugins.resolver.FileSystemResolver()) {
        name = 'destRepo'
        addIvyPattern( file( project.properties['repo.dest.dir']).absolutePath + '/[organisation]/[module]/ivys/ivy(-[revision]).xml')
        addArtifactPattern( file( project.properties['repo.dest.dir']).absolutePath + '/[organisation]/[module]/[type]s/[artifact](-[revision]).[ext]')
        descriptor = 'optional'
        checkmodified = true
    }
    ...
}
...
subprojects {
    sourceCompatibility = 1.5
    targetCompatibility = 1.5
    group = 'my.group'
    version = '1.0'
    uploadArchives {
        uploadDescriptor = true
        repositories {
            add rootProject.repositories.destRepo
        }
    }
    apply{ type my.group.gradle.api.plugins.MyPlugin }
    ...
}

dependsOnChildren()

प्रोजेक्ट रूट निर्देशिका में एक gradle.properties फ़ाइल भी हो सकती है जहां आप अपनी परियोजनाओं द्वारा उपयोग की जाने वाली गुणों को परिभाषित करते हैं:

buildDirName=staging
repo.dest.dir=/var/repo
...

फिर अपनी प्रोजेक्ट रूट से एक अतिरिक्त फ़ाइल में settings.gradle .gradle नामक आप वास्तव में अपने उपप्रोजेक्ट को इंगित करते हैं:

include 'my-first-component',
        'my-second-component'
...
project(':my-first-component').projectDir = new File(rootDir, 'path/to/first/component')
project(':my-second-component').projectDir = new File(rootDir, 'path/to/second/component')
...

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

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

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



अनुत्तरित उत्तर देने और इसे सुधारने के लिए, हमारे पास है:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <mainClass>fully.qualified.MainClass</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
        </plugin>
    </plugins>
</build>

इसके बाद, मैं स्पष्ट रूप से कॉल करने के बजाए इसे अपने निर्माण का एक प्राकृतिक हिस्सा बनाने की सलाह दूंगा। इसे अपने निर्माण का एक अभिन्न हिस्सा बनाने के लिए, इस प्लगइन को अपने pom.xml जोड़ें और इसे package लाइफसाइक्ल ईवेंट में बाध्य करें। हालांकि, एक गॉचा यह है कि आपको assembly:single को कॉल करने की आवश्यकता है assembly:single यदि आप इसे अपने pom.xml में डालते हैं तो assembly:single लक्ष्य, जबकि आप 'असेंबली: असेंबली' को कमांड लाइन से मैन्युअल रूप से निष्पादित करते हैं तो कॉल करेंगे।

<project>
  [...]
  <build>
      <plugins>
          <plugin>
              <artifactId>maven-assembly-plugin</artifactId>
              <configuration>
                  <archive>
                      <manifest>
                          <addClasspath>true</addClasspath>
                          <mainClass>fully.qualified.MainClass</mainClass>
                      </manifest>
                  </archive>
                  <descriptorRefs>
                      <descriptorRef>jar-with-dependencies</descriptorRef>
                  </descriptorRefs>
              </configuration>
              <executions>
                  <execution>
                      <id>make-my-jar-with-dependencies</id>
                      <phase>package</phase>
                      <goals>
                          <goal>single</goal>
                      </goals>
                  </execution>
              </executions>
          </plugin>
      [...]
      </plugins>
    [...]
  </build>
</project>






java ant groovy build gradle