java - मैवेन का उपयोग कर निर्भरताओं के साथ मैं एक निष्पादन योग्य जेएआर कैसे बना सकता हूं?

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

<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>

आप maven-shade-plugin और maven-jar-plugin को जोड़ सकते हैं।

• maven-shade-plugin आपके वर्गों और सभी निर्भरताओं को एक जार फ़ाइल में पैक करता है।
• अपने निष्पादन योग्य जार की मुख्य श्रेणी निर्दिष्ट करने के लिए maven-jar-plugin को कॉन्फ़िगर करें ( क्लासपाथ सेट करें , अध्याय "जार निष्पादन योग्य बनाएं" देखें)।

maven-jar-plugin लिए उदाहरण पीओएम कॉन्फ़िगरेशन:

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>2.3.2</version>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <mainClass>com.example.MyMainClass</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>

अंत में invoking द्वारा निष्पादन योग्य जार बनाएँ:

mvn clean package shade:shade

आप इस प्लग-इन का भी उपयोग कर सकते हैं, यह बहुत अच्छा है और मैं इसे अपने जारों को पैकेजिंग के लिए उपयोग करता हूं http://sonatype.github.io/jarjar-maven-plugin/

आप नीचे की तरह एक uber जार बनाने के लिए मेवेन-छाया प्लगइन का उपयोग कर सकते हैं

        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>

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

<build>
    <plugins>
        <plugin>
            <artifactId>maven-jar-plugin</artifactId>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>fully.qualified.MainClass</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
        <plugin>
            <artifactId>maven-dependency-plugin</artifactId>
            <executions>
                <execution>
                    <id>unpack-dependencies</id>
                    <phase>package</phase>
                    <goals>
                        <goal>unpack-dependencies</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
    <resources>
        <resource>
            <directory>${basedir}/target/dependency</directory>
        </resource>
    </resources>
</build>

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

ऐसा होना चाहिए:

    <plugin>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                        <execution>
                                <id>unpack-dependencies</id>
                                <phase>generate-resources</phase>
                                <goals>
                                        <goal>unpack-dependencies</goal>
                                </goals>
                        </execution>
                </executions>
        </plugin>

अनपॅकिंग जेनरेट-संसाधन चरण में होना चाहिए क्योंकि, यदि पैकेज चरण में संसाधनों के रूप में शामिल नहीं किया जाएगा। स्वच्छ पैकेज आज़माएं और आप देखेंगे।

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

<project>
 ...
 <build>
  <plugins>
   <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
     <execution>
      <id>unpack-dependencies</id>
      <phase>package</phase>
      <goals>
       <goal>unpack-dependencies</goal>
      </goals>
     </execution>
    </executions>
   </plugin>
  </plugins>
  ...
  <resources>
   <resource>
    <directory>${basedir}/target/dependency</directory>
    <targetPath>/</targetPath>
   </resource>
  </resources>
 </build>
 ...
</project>

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

https://github.com/creditkarma/maven-exec-jar-plugin

और यहां प्लगइन के बारे में विवरण के साथ एक ब्लॉग पोस्ट है और हमने इसे क्यों बनाया: https://engineering.creditkarma.com/general-engineering/new-executable-jar-plugin-available-apache-maven/

मैं इन प्रतिक्रियाओं में से प्रत्येक के माध्यम से एक वसा निष्पादन योग्य जार बनाने के लिए देख रहा था जिसमें सभी निर्भरताएं थीं और उनमें से कोई भी सही काम नहीं करता था। जवाब छाया प्लगइन है, यह बहुत आसान और सीधा है।

    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-shade-plugin</artifactId>
      <version>2.3</version>
      <executions>
         <!-- Run shade goal on package phase -->
        <execution>
        <phase>package</phase>
        <goals>
            <goal>shade</goal>
        </goals>
        <configuration>
          <transformers>
             <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                <mainClass>path.to.MainClass</mainClass>
             </transformer>
          </transformers>
        </configuration>
          </execution>
      </executions>
    </plugin>

ध्यान रखें कि इसके लिए निर्भरताओं को ठीक से काम करने के लिए संकलन या रनटाइम का दायरा होना चाहिए।

यह उदाहरण mkyong.com से आया था

मैंने ऐसा करने के कुछ अलग तरीकों के बारे में ब्लॉग किया।

Apache Maven (वर्डप्रेस) के साथ निष्पादन योग्य जार देखें

या executable-jar-with-maven-example (गिटहब)

टिप्पणियाँ

उन पेशेवरों और विपक्ष Stephan द्वारा प्रदान किए जाते हैं।

मैन्युअल परिनियोजन के लिए

• पेशेवरों
• विपक्ष
  • निर्भरता अंतिम जार से बाहर हैं।

एक विशिष्ट निर्देशिका में निर्भरता की प्रतिलिपि बनाएँ

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-dependency-plugin</artifactId>
  <executions>
    <execution>
      <id>copy-dependencies</id>
      <phase>prepare-package</phase>
      <goals>
        <goal>copy-dependencies</goal>
      </goals>
      <configuration>
        <outputDirectory>${project.build.directory}/${project.build.finalName}.lib</outputDirectory>
      </configuration>
    </execution>
  </executions>
</plugin>

जार निष्पादन योग्य और क्लासपाथ जागरूक बनाओ

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-jar-plugin</artifactId>
  <configuration>
    <archive>
      <manifest>
        <addClasspath>true</addClasspath>
        <classpathPrefix>${project.build.finalName}.lib/</classpathPrefix>
        <mainClass>${fully.qualified.main.class}</mainClass>
      </manifest>
    </archive>
  </configuration>
</plugin>

इस बिंदु पर jar वास्तव में बाहरी वर्गपाथ तत्वों के साथ निष्पादन योग्य है।

$ java -jar target/${project.build.finalName}.jar

तैनाती अभिलेखागार बनाओ

jar फ़ाइल केवल भाई के साथ निष्पादन योग्य है ...lib/ निर्देशिका। हमें निर्देशिका और इसकी सामग्री के साथ तैनात करने के लिए अभिलेखागार बनाने की आवश्यकता है।

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-antrun-plugin</artifactId>
  <executions>
    <execution>
      <id>antrun-archive</id>
      <phase>package</phase>
      <goals>
        <goal>run</goal>
      </goals>
      <configuration>
        <target>
          <property name="final.name" value="${project.build.directory}/${project.build.finalName}"/>
          <property name="archive.includes" value="${project.build.finalName}.${project.packaging} ${project.build.finalName}.lib/*"/>
          <property name="tar.destfile" value="${final.name}.tar"/>
          <zip basedir="${project.build.directory}" destfile="${final.name}.zip" includes="${archive.includes}" />
          <tar basedir="${project.build.directory}" destfile="${tar.destfile}" includes="${archive.includes}" />
          <gzip src="${tar.destfile}" destfile="${tar.destfile}.gz" />
          <bzip2 src="${tar.destfile}" destfile="${tar.destfile}.bz2" />
        </target>
      </configuration>
    </execution>
  </executions>
</plugin>

अब आपके पास target/${project.build.finalName}.(zip|tar|tar.bz2|tar.gz) जिसमें प्रत्येक में jar और lib/* ।

अपाचे मेवेन असेंबली प्लगइन

• पेशेवरों
• विपक्ष
  • कोई कक्षा स्थानान्तरण समर्थन (क्लास स्थानांतरण की आवश्यकता होने पर मेवेन-शेड-प्लगइन का उपयोग करें)।

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-assembly-plugin</artifactId>
  <executions>
    <execution>
      <phase>package</phase>
      <goals>
        <goal>single</goal>
      </goals>
      <configuration>
        <archive>
          <manifest>
            <mainClass>${fully.qualified.main.class}</mainClass>
          </manifest>
        </archive>
        <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
      </configuration>
    </execution>
  </executions>
</plugin>

आपके पास target/${project.bulid.finalName}-jar-with-dependencies.jar ।

अपाचे मेवेन छाया प्लगइन

• पेशेवरों
• विपक्ष

<plugin>
  <groupId>org.apache.maven.plugins</groupId>
  <artifactId>maven-shade-plugin</artifactId>
  <executions>
    <execution>
      <goals>
        <goal>shade</goal>
      </goals>
      <configuration>
        <shadedArtifactAttached>true</shadedArtifactAttached>
        <transformers>
          <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
            <mainClass>${fully.qualified.main.class}</mainClass>
          </transformer>
        </transformers>
      </configuration>
    </execution>
  </executions>
</plugin>

आपके पास target/${project.build.finalName}-shaded.jar ।

onejar-Maven-प्लगइन

• पेशेवरों
• विपक्ष
  • 2012 से सक्रिय रूप से समर्थित नहीं है।

<plugin>
  <!--groupId>org.dstovall</groupId--> <!-- not available on the central -->
  <groupId>com.jolira</groupId>
  <artifactId>onejar-maven-plugin</artifactId>
  <executions>
    <execution>
      <configuration>
        <mainClass>${fully.qualified.main.class}</mainClass>
        <attachToBuild>true</attachToBuild>
        <!-- https://code.google.com/p/onejar-maven-plugin/issues/detail?id=8 -->
        <!--classifier>onejar</classifier-->
        <filename>${project.build.finalName}-onejar.${project.packaging}</filename>
      </configuration>
      <goals>
        <goal>one-jar</goal>
      </goals>
    </execution>
  </executions>
</plugin>

वसंत बूट मेवेन प्लगइन

• पेशेवरों
• विपक्ष
  • संभावित अनावश्यक वसंत और वसंत बूट संबंधित वर्ग जोड़ें।

<plugin>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-maven-plugin</artifactId>
  <executions>
    <execution>
      <goals>
        <goal>repackage</goal>
      </goals>
      <configuration>
        <classifier>spring-boot</classifier>
        <mainClass>${fully.qualified.main.class}</mainClass>
      </configuration>
    </execution>
  </executions>
</plugin>

आपके पास target/${project.bulid.finalName}-spring-boot.jar ।

मैंने यहां सबसे ज्यादा मतदान किए गए उत्तर की कोशिश की, और जार रननेबल पाने में सक्षम था। लेकिन कार्यक्रम सही ढंग से नहीं चला था। मुझे नहीं पता कि कारण क्या था। जब मैं Eclipse से भागने की कोशिश करता हूं, तो मुझे एक अलग परिणाम मिलता है लेकिन जब मैं कमांड लाइन से जार चलाता हूं तो मुझे एक अलग परिणाम मिलता है (यह प्रोग्राम-विशिष्ट रनटाइम त्रुटि के साथ दुर्घटनाग्रस्त हो जाता है)।

मेरे पास ओपी के समान ही आवश्यकता थी कि मेरी परियोजना के लिए मेरे पास बहुत अधिक (मेवेन) निर्भरताएं थीं। सौभाग्य से, मेरे लिए काम करने वाला एकमात्र समाधान यह था कि Eclipse का उपयोग करना। बहुत सरल और बहुत सीधा। यह ओपी का समाधान नहीं है लेकिन किसी ऐसे व्यक्ति के लिए समाधान है जिसकी समान आवश्यकता है लेकिन कई मेवेन निर्भरताओं के साथ,

1) बस अपने प्रोजेक्ट फ़ोल्डर (ग्रहण में) पर राइट-क्लिक करें और Export चयन करें

2) फिर Java -> Runnable Jar चयन करें

3) आपको जार फ़ाइल का स्थान चुनने के लिए कहा जाएगा

4) अंत में, उस वर्ग का चयन करें जिसमें मुख्य विधि है जिसे आप चलाने के लिए चाहते हैं और Package dependencies with the Jar file चयन करें और Finish क्लिक Finish

यदि आप चाहते हैं कि कमांड लाइन से ही। बस परियोजना पथ से नीचे कमांड चलाएँ

एमवीएन असेंबली: असेंबली

यह मुझे मिला सबसे अच्छा तरीका है:

  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>2.4</version>
    <configuration>
      <archive>
        <manifest>
        <addClasspath>true</addClasspath>
        <mainClass>com.myDomain.etc.MainClassName</mainClass>
        <classpathPrefix>dependency-jars/</classpathPrefix>
        </manifest>
      </archive>
    </configuration>
  </plugin>
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <version>2.5.1</version>
    <executions>
      <execution>
        <id>copy-dependencies</id>
        <phase>package</phase>
        <goals>
            <goal>copy-dependencies</goal>
        </goals>
        <configuration>
            <outputDirectory>
               ${project.build.directory}/dependency-jars/
            </outputDirectory>
        </configuration>
      </execution>
    </executions>
  </plugin>

इस कॉन्फ़िगरेशन के साथ, सभी निर्भरताएं स्थित होंगी /dependency-jars। मेरे आवेदन में कोई Mainवर्ग नहीं है , केवल संदर्भ वाले हैं, लेकिन मेरी निर्भरताओं में से एक में Mainकक्षा ( com.myDomain.etc.MainClassName) है जो जेएमएक्स सर्वर शुरू करता है, और एक startया stopपैरामीटर प्राप्त करता है । तो इसके साथ मैं इस तरह अपना आवेदन शुरू करने में सक्षम था:

java -jar ./lib/TestApp-1.0-SNAPSHOT.jar start

मैं प्रतीक्षा करता हूं कि यह आपके लिए उपयोगी हो।

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

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

नीचे उदाहरण देखें

      <plugins>
    <!-- This plugin provides the capability to package the artifact in an uber-jar, including its dependencies and to shade - i.e. rename - the packages of some of the dependencies. -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>1.4</version>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                    <configuration>
                        <artifactSet>
                        <!-- signed jars-->
                            <excludes>
                                <exclude>bouncycastle:bcprov-jdk15</exclude>
                            </excludes>
                        </artifactSet>

                         <transformers>
                            <transformer
                                implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                <!-- Main class -->
                                <mainClass>com.main.MyMainClass</mainClass>
                            </transformer>
                            <!-- Use resource transformers to prevent file overwrites -->
                            <transformer 
                                 implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                <resource>properties.properties</resource>
                            </transformer>
                            <transformer
                                implementation="org.apache.maven.plugins.shade.resource.XmlAppendingTransformer">
                                <resource>applicationContext.xml</resource>
                            </transformer>
                            <transformer
                                implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                <resource>META-INF/cxf/cxf.extension</resource>
                            </transformer>
                            <transformer
                                implementation="org.apache.maven.plugins.shade.resource.XmlAppendingTransformer">
                                <resource>META-INF/cxf/bus-extensions.xml</resource>
                            </transformer>
                     </transformers>
                    </configuration>
                </execution>
            </executions>
        </plugin>

    </plugins>

Pom.xml में जोड़ें:

  <dependency>
            <groupId>com.jolira</groupId>
            <artifactId>onejar-maven-plugin</artifactId>
            <version>1.4.4</version>
  </dependency>

तथा

<plugin>
       <groupId>com.jolira</groupId>
       <artifactId>onejar-maven-plugin</artifactId>
       <version>1.4.4</version>
       <executions>
              <execution>
                     <goals>
                         <goal>one-jar</goal>
                     </goals>
              </execution>
       </executions>
</plugin>

बस। अगला एमवीएन पैकेज सभी निर्भरता जार समेत एक वसा जार भी बना देगा।

यह एक विकल्प भी हो सकता है, आप अपनी जार फ़ाइल बनाने में सक्षम होंगे

<build>
    <plugins>
        <plugin>
            <!-- Build an executable JAR -->
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>2.4</version>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <classpathPrefix>lib/</classpathPrefix>
                        <mainClass>WordListDriver</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
    </plugins>
</build>

इस मुद्दे को हल करने के लिए हम मेवेन असेंबली प्लगइन का उपयोग करेंगे जो जेएआर को अपनी निर्भरता JARs को एक निष्पादन योग्य JAR फ़ाइल में एक साथ बनाएगा। बस अपनी pom.xml फ़ाइल में प्लगइन विन्यास नीचे जोड़ें।

<build>
   <pluginManagement>
      <plugins>
         <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <configuration>
               <archive>
                  <manifest>
                     <addClasspath>true</addClasspath>
                     <mainClass>com.your.package.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>
   </pluginManagement>
</build>

ऐसा करने के बाद इस कमांड एमवीएन स्वच्छ संकलन असेंबली के साथ MAVEN उपकरण चलाने के लिए मत भूलना: एकल

http://jkoder.com/maven-creating-a-jar-together-with-its-dependency-jars-into-a-single-executable-jar-file/

मेवेन-असेंबली-प्लगइन मेरे लिए बहुत अच्छा काम करता है। मैंने मैवेन-निर्भरता-प्लगइन के साथ घंटों बिताए और इसे काम नहीं कर सका। मुख्य कारण यह था कि मुझे कॉन्फ़िगरेशन सेक्शन में स्पष्ट रूप से आर्टिफैक्ट आइटम को परिभाषित करना था, जिसे documentation में वर्णित किया जाना चाहिए । उन मामलों के लिए एक उदाहरण है जब आप इसका उपयोग करना चाहते हैं:, mvn dependency:copyजहां कोई artifactItems शामिल नहीं हैं लेकिन यह काम नहीं करता है।

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

            <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <executions>
                <execution>
                    <id>copy-dependencies</id>
                    <phase>prepare-package</phase>
                    <goals>
                        <goal>copy-dependencies</goal>
                    </goals>
                    <configuration>
                        <outputDirectory>${project.build.directory}/lib</outputDirectory>
                        <includeScope>compile</includeScope>
                        <excludeTransitive>true</excludeTransitive>
                        <overWriteReleases>false</overWriteReleases>
                        <overWriteSnapshots>false</overWriteSnapshots>
                        <overWriteIfNewer>true</overWriteIfNewer>
                    </configuration>
                </execution>
            </executions>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.6</version>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <mainClass>com.rbccm.itf.cdd.poller.landingzone.LandingZonePoller</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>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>2.4.3</version>
            <configuration>
                <shadedArtifactAttached>false</shadedArtifactAttached>
                <keepDependenciesWithProvidedScope>false</keepDependenciesWithProvidedScope>
                <transformers>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/services/javax.ws.rs.ext.Providers</resource>
                    </transformer>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.factories</resource>
                    </transformer>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.handlers</resource>
                    </transformer>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.schemas</resource>
                    </transformer>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.tooling</resource>
                    </transformer>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer"/>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"/>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.ApacheLicenseResourceTransformer">
                    </transformer>
                </transformers>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>