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


2396

मैं वितरण के लिए एक निष्पादन योग्य जार में अपनी परियोजना को पैकेज करना चाहता हूं।

मैं अपने उत्पादन JAR में सभी निर्भरता JAR से Maven प्रोजेक्ट पैकेज कैसे बना सकता हूं?


14
कृपया बताएं कि आप निर्भरता प्लगइन के किस लक्ष्य का उल्लेख कर रहे हैं। मुझे कोई लक्ष्य नहीं पता है जो मूल प्रश्न का अनुरोध करता है: लेखकों के अंदर या तो सभी निर्भरताएं डालने के लिए) repackaging के माध्यम से जार के अंदर, या बी) एक निष्पादन योग्य जार बनाते हैं जो दूसरों को MANIFEST.MF के एक वर्गपथ में रखते हैं
मैथ्यू मैकुलॉ

2
आपको यह उपयोगी rationaljava.com/2015/02/…
Dan


जवाबों:


2358
<build>
  <plugins>
    <plugin>
      <artifactId>maven-assembly-plugin</artifactId>
      <configuration>
        <archive>
          <manifest>
            <mainClass>fully.qualified.MainClass</mainClass>
          </manifest>
        </archive>
        <descriptorRefs>
          <descriptorRef>jar-with-dependencies</descriptorRef>
        </descriptorRefs>
      </configuration>
    </plugin>
  </plugins>
</build>

और आप इसे चलाते हैं

mvn clean compile assembly:single

संकलित लक्ष्य को असेंबली से पहले जोड़ा जाना चाहिए: एकल या अन्यथा आपके स्वयं के प्रोजेक्ट पर कोड शामिल नहीं है।

टिप्पणियों में अधिक विवरण देखें।


आमतौर पर यह लक्ष्य स्वचालित रूप से निष्पादित करने के लिए एक निर्माण चरण से जुड़ा होता है। यह सुनिश्चित करता है कि JAR का निर्माण mvn installतैनाती या विमोचन करते समय किया जाता है।

<plugin>
  <artifactId>maven-assembly-plugin</artifactId>
  <configuration>
    <archive>
      <manifest>
        <mainClass>fully.qualified.MainClass</mainClass>
      </manifest>
    </archive>
    <descriptorRefs>
      <descriptorRef>jar-with-dependencies</descriptorRef>
    </descriptorRefs>
  </configuration>
  <executions>
    <execution>
      <id>make-assembly</id> <!-- this is used for inheritance merges -->
      <phase>package</phase> <!-- bind to the packaging phase -->
      <goals>
        <goal>single</goal>
      </goals>
    </execution>
  </executions>
</plugin>

22
धन्यवाद @ अनुकूलक। ध्यान दें कि आपको हमेशा हाथ से पहले एक संकलन करना चाहिए क्योंकि यह सिर्फ वही होगा जो जार में "लक्ष्य / कक्षाओं" में है। यह सुनिश्चित करेगा कि JAR में आपके द्वारा हाल ही में स्रोत कोड में किए गए परिवर्तन शामिल हैं। तो, आपको कुछ ऐसा करना चाहिए mvn clean compile assembly:single:।
माइकल

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

2
मैं देखता हूं कि यह uber जार में जार नहीं जोड़ता है, इसके बजाय यह सिर्फ क्लास के सभी फाइलों को जार में जोड़ता है।
पिचब्लैक 408

170
युक्ति: आप कष्टप्रद "-जर-साथ-निर्भरता" नाम के प्रत्यय से बचने <appendAssemblyId>false</appendAssemblyId>के configurationलिए तत्व को भी जोड़ सकते हैं
मैक्सिविस

6
भूल जाओ compileऔर तुम खराब हो।
प्रयागपाद

349

आप पैकेज चरण से पहले एक अलग निर्देशिका में सभी निर्भरता उत्पन्न करने के लिए निर्भरता-प्लगइन का उपयोग कर सकते हैं और फिर इसे प्रकट के क्लासपाथ में शामिल कर सकते हैं:

<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>
                <overWriteReleases>false</overWriteReleases>
                <overWriteSnapshots>false</overWriteSnapshots>
                <overWriteIfNewer>true</overWriteIfNewer>
            </configuration>
        </execution>
    </executions>
</plugin>
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <configuration>
        <archive>
            <manifest>
                <addClasspath>true</addClasspath>
                <classpathPrefix>lib/</classpathPrefix>
                <mainClass>theMainClass</mainClass>
            </manifest>
        </archive>
    </configuration>
</plugin>

वैकल्पिक ${project.build.directory}/classes/libरूप से आउटपुट जार के रूप में सभी जार-फ़ाइलों को मुख्य जार में एकीकृत करने के लिए उपयोग करें , लेकिन फिर आपको जार लोड करने के लिए कस्टम क्लासलोडिंग कोड जोड़ना होगा।


3
+1 उत्कृष्ट। मैं मावेन-असेंबली-प्लगइन के बजाय मावेन-डिपेंडेंसी-प्लगइन के साथ जा रहा हूं, इसका कारण यह है कि मैं बिल्डनंबर-मावेन-प्लगइन का भी उपयोग कर रहा हूं, और इस तरह से मैं प्रत्येक जार के प्रकट रूप में संस्करण संख्या को स्टोर कर सकता हूं।
पापाफ्रायड

17
मुझे आपका समाधान पसंद है। मैं सभी मुख्य निर्भरताओं के साथ एक मुख्य .jar का उपयोग ${project.build.directory}/classes/libकरता हूं outputDirectory, लेकिन - इस जार को लोड करने के लिए कस्टम क्लास लोडिंग कोड कैसे जोड़ें? मैं की तरह काम निष्पादन करने की जरूरत है: java -jar main-jar-with-deps.jar। क्या यह संभव है ?
19

3
@ एंड्रे एरोसेन, मैंने जार के अंदर एक कार्यकारी फ़ोल्डर में निर्भरता को जोड़ने के लिए इस समाधान का उपयोग किया, लेकिन मुझे हमेशा वर्ग अपवाद नहीं मिला, क्या आप इसे ठीक करने की सलाह दे सकते हैं।
महमूद सालेह

11
आप को +1 !! ऐसा लगता है कि मावेन असेंबली प्लगइन 'जार-विद-डिपेंडेंसीज़' वास्तव में अच्छी तरह से काम नहीं करता है। मुझे उत्पन्न जार में META-INF / spring.schemas से कुछ प्रविष्टियाँ याद आ रही थीं। इसलिए मैंने जार-निर्भरताओं को खत्म कर दिया और आपके समाधान का उपयोग किया। बहुत बहुत धन्यवाद!!!
डेरेक

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

224

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

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

या अमल-जार-साथ-मावेन-उदाहरण (GitHub)

टिप्पणियाँ

उन पेशेवरों और विपक्ष स्टीफन द्वारा प्रदान की जाती हैं ।


मैनुअल तैनाती के लिए

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

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

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

जार निष्पादन योग्य और Classpath अवेयर करें

<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


2
@caiohamamura आप GitHub रिपॉजिटरी को क्लोन कर सकते हैं और देख सकते हैं कि सभी प्रोफाइल कैसे काम करती हैं।
जिन क्वॉन

समस्या मेरे द्वारा
caiohamamura

1
मुझे लगता है कि यह शायद इस विषय का सबसे पूर्ण उत्तर है।
पेट्र बोडनार

139

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

<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अपने pom.xml में इसे डालते समय लक्ष्य को कॉल करने की आवश्यकता है , जबकि आप इसे कमांड असेंबली से मैन्युअल रूप से निष्पादित करते समय 'असेंबली: असेंबली' कहेंगे।

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

10
इस उत्तर में एप्रोच का उपयोग करने से निम्नलिखित त्रुटि संदेश आता है: '' jar file> 'से मेन-क्लास मेनिफ़ेस्ट एट्रिब्यूट लोड करने में विफल, जब' java-jar <jar file> '
Elmo

3
Maven-जार-प्लगइन का आर्काइव भाग की जरूरत है <संग्रह> <प्रकट> <addClasspath> सच </ addClasspath> <mainClass> fully.qualified.MainClass </ mainClass> </ प्रकट> </ संग्रह>
Rade_303

4
क्षमा करें, यह उत्तर स्पष्ट गलत है, मेनक्लास टैग को मावेन-असेंबली-प्लगइन प्रविष्टि पर होना चाहिए क्योंकि आप पैकेज लक्ष्य के दौरान कॉल कर रहे हैं
एलेक्स लेहमैन

मुझे आश्चर्य है, क्यों नहीं mom.xml पहले से ही यह शामिल हो सकता है mvan archetype के बाद: कमांड उत्पन्न करें? यह हर बार मैन्युअल रूप से कॉपी-पेस्ट करने पर मुझे गुस्सा आता है, जब मैं एक नया मैवेन प्रोजेक्ट बनाता हूं ...
विंटरम्यूट

मैं एक मुख्य विधि या वर्ग नहीं है, मैं सिर्फ समारोह के साथ वर्ग है। मैं कैसे जार बनाने के लिए और यह प्रयोग किया जा सकता है
parlad

97

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

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

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

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

तो bcprov-jdk15.jar रनटाइम पर क्लासपाथ पर कैसे आता है, यह देखते हुए कि इसे छायांकन प्रक्रिया से बाहर रखा गया है?
एंड्रयू स्वान

इसे cxf-rt-ws-security द्वारा खींचा जा रहा था जो कि मेरी निर्भरता का हिस्सा है
विजय कटम

इस प्लगइन के बारे में पहले कभी नहीं सुना, लेकिन इसने जार के अंदर स्प्रिंग.हैंडलर के साथ मेरी समस्या को हल किया। धन्यवाद!
अलेक्जेंड्रे एल

11
जिन्हें सुरक्षा अपवाद मिला, उन्होंने डीएसए को मैनिफेस्ट से बाहर कर दिया। Maven.apache.org/plugins/maven-shade-plugin/examples/…
ruhsuzbaykus

+1 मैंने भूतकाल में मिंजार: ueberjar का उपयोग किया है, लेकिन अब मिंजर प्लगइन को हटा दिया गया है और इसे शेड द्वारा बदल दिया गया है
rds

19

लंबे समय से मावेन असेंबली प्लगइन का उपयोग किया गया था , लेकिन मुझे समस्या का हल नहीं मिला "already added, skipping"। अब, मैं एक और प्लगइन का उपयोग कर रहा हूं - वनजर-मावेन-प्लगइन । नीचे उदाहरण ( mvn packageबिल्ड जार):

<plugin>
    <groupId>org.dstovall</groupId>
    <artifactId>onejar-maven-plugin</artifactId>
    <version>1.3.0</version>
    <executions>
        <execution>
            <configuration>
                <mainClass>com.company.MainClass</mainClass>
            </configuration>
            <goals>
                <goal>one-jar</goal>
            </goals>
        </execution>
    </executions>
</plugin>

आपको उस प्लगइन के लिए भंडार जोड़ना होगा:

<pluginRepositories>
    <pluginRepository>
        <id>onejar-maven-plugin.googlecode.com</id>
        <url>http://onejar-maven-plugin.googlecode.com/svn/mavenrepo</url>
    </pluginRepository>
</pluginRepositories>

आउटपुट में अतिरिक्त संदेशों से कैसे छुटकारा पाएं?
एलेक्जेंड्रा

17

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

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

16

आप नीचे की तरह uber जार बनाने के लिए maven-shade plugin का उपयोग कर सकते हैं

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

लेकिन फिर इस रेपो को कैसे तैनात किया जाएगा?
फ्रांसेस्को Gualazzi

15

एक अन्य विकल्प यदि आप वास्तव में अपने एकल परिणामक JAR के अंदर अन्य JAR की सामग्री को वापस करना चाहते हैं तो Maven असेंबली प्लगइन है । यह अनपैक करता है और फिर एक डायरेक्टरी के माध्यम से सब कुछ रिपीट करता है <unpack>true</unpack>। फिर आपके पास एक दूसरा पास होगा जिसने इसे एक बड़े पैमाने पर जार में बनाया।

एक अन्य विकल्प OneJar प्लगइन है । यह सभी एक कदम में उपरोक्त रीपैकेजिंग क्रिया करता है।


14

आप अपने pom.xml में निम्न जोड़ सकते हैं :

<build>
<defaultGoal>install</defaultGoal>
<plugins>
  <plugin>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.3.2</version>
    <configuration>
      <source>1.6</source>
      <target>1.6</target>
    </configuration>
  </plugin>
  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <version>2.3.1</version>
    <configuration>
      <archive>
        <manifest>
          <addClasspath>true</addClasspath>
          <mainClass>com.mycompany.package.MainClass</mainClass>
        </manifest>
      </archive>
    </configuration>
  </plugin>
  <plugin>
    <artifactId>maven-assembly-plugin</artifactId>
    <configuration>
      <descriptorRefs>
        <descriptorRef>jar-with-dependencies</descriptorRef>
      </descriptorRefs>
      <archive>
        <manifest>
          <mainClass>com.mycompany.package.MainClass</mainClass>
        </manifest>
      </archive>
    </configuration>
    <executions>
      <execution>
        <id>make-my-jar-with-dependencies</id>
        <phase>package</phase>
        <goals>
          <goal>single</goal>
        </goals>
      </execution>
    </executions>
  </plugin>
</plugins>
</build>

बाद में आपको कंसोल के माध्यम से निर्देशिका में स्विच करना होगा, जहां pom.xml स्थित है। फिर आपको mvan असेंबली को निष्पादित करना होगा : सिंगल और उसके बाद आश्रितों के साथ आपकी निष्पादन योग्य JAR फ़ाइल उम्मीद के साथ बनाई जाएगी। सीडी / आउटपुट के साथ आउटपुट (टारगेट) डायरेक्टरी पर स्विच करने पर आप इसे चेक कर सकते हैं और अपने जार को java -jar mavenproject1-1.0-SNAPSHOT-जार-साथ-निर्भरता के साथ कमांड के साथ शुरू कर सकते हैं ।

मैंने अपाचे मावेन 3.0.3 के साथ यह परीक्षण किया ।


13

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

    <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 से आया है


जैसा कि मैंने यह तय किया है, क्या आप अपनी समीक्षा को अपडेट करना चाहेंगे। मैंने आपके विचारों को पोस्ट करने से पहले विचार में नहीं लिया था और आपकी टिप्पणी को देखने के लिए जल्दी से एक
निर्णय लिया

2
pluginतत्व में चला जाता है pom.xmlके तहत build/plugins
isapir

12

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

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

mvn clean package shade:shade

3
शेड प्लगइन में अब प्रकट में मुख्य-वर्ग प्रविष्टि को निर्दिष्ट करने का साधन है: maven.apache.org/plugins/maven-shade-plugin/examples/…
Chadwick

9

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

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

1
बहुत अच्छे! हालांकि, अनपैकिंग के लिए उत्पन्न-संसाधन चरण का उपयोग करना बेहतर नहीं होगा?
नवग्रोथ

9

यह इस तरह होना चाहिए:

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

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


7

मवन-असेंबली-प्लगइन-2.2.1 के साथ साझा असेंबली फ़ाइल का पता लगाने में समस्या?

डिस्क्रिप्टर / डिस्क्रिप्टर या डिस्क्रिप्टर रीफ्स / डिस्क्रिप्टर रीफ मापदंडों के बजाय डिस्क्रिप्टर कॉन्फ़िगरेशन पैरामीटर का उपयोग करने का प्रयास करें।

उनमें से किसी को भी आपकी ज़रूरत नहीं है: क्लासपाथ पर फ़ाइल देखें। बेशक आपको पैकेज को जोड़ने की आवश्यकता है जहां साझा विधानसभा मावेन-असेंबली-प्लगइन के क्लासपाथ पर रहती है (नीचे देखें)। यदि आप Maven 2.x (Maven 3.x नहीं) का उपयोग कर रहे हैं, तो आपको pluginManagement अनुभाग में शीर्ष-अधिकांश पैरेंट pom.xml में इस निर्भरता को जोड़ने की आवश्यकता हो सकती है।

अधिक जानकारी के लिए इसे देखें ।

कक्षा: org.apache.maven.plugin.assembly.io.DefaultAssemblyReader

उदाहरण:

        <!-- Use the assembly plugin to create a zip file of all our dependencies. -->
        <plugin>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.2.1</version>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                    <configuration>
                        <descriptorId>assembly-zip-for-wid</descriptorId>
                    </configuration>
                </execution>
            </executions>
            <dependencies>
                <dependency>
                    <groupId>cz.ness.ct.ip.assemblies</groupId>
                    <artifactId>TEST_SharedAssemblyDescriptor</artifactId>
                    <version>1.0.0-SNAPSHOT</version>
                </dependency>
            </dependencies>
        </plugin>

7

इस समस्या को हल करने के लिए हम मावेन असेंबली प्लगिन का उपयोग करेंगे जो कि JAR को एक एकल निष्पादन योग्य JAR फ़ाइल में उसकी निर्भरता 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>

ऐसा करने के बाद इस कमांड mvan क्लीन कंपाइल असेंबली के साथ MAVEN टूल चलाना न भूलें: सिंगल

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


5

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

मैं बिंदु (तैनाती / उपयोग में आसानी) देखता हूं, लेकिन यह आपके मार्मिक के उपयोग के मामले पर निर्भर करता है (और विकल्प हो सकते हैं (नीचे देखें))।

यदि आप इसे पूरी तरह से स्टैंडअलोन का उपयोग करते हैं, तो क्यों नहीं।

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

एक अच्छा विकल्प:

  • अपने आवेदन को .zip / .war के रूप में तैनात करें: संग्रह में आपकी परियोजना के जार और सभी आश्रित जार शामिल हैं;
  • डायनेमिक क्लास लोडर मैकेनिज्म का उपयोग करें (स्प्रिंग देखें, या आप इसे आसानी से खुद कर सकते हैं) अपनी परियोजना का एक ही एंट्री पॉइंट (शुरुआत के लिए एक सिंगल क्लास - एक अन्य उत्तर पर मेनिफेस्ट मैकेनिज्म देखें), जो कि (डायनेमिक रूप से) जोड़ देगा वर्तमान classpath अन्य सभी आवश्यक जार।

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

java -jar ProjectMainJar.jar com.stackoverflow.projectName.MainDynamicClassLoaderClass

1
फिर एक संग्रह में परियोजना के जार और सभी आश्रित जार को कैसे रखा जाए?

4

कमांड लाइन से एक निष्पादन योग्य JAR बनाने के लिए, केवल प्रोजेक्ट पथ से नीचे कमांड चलाएं:

mvn assembly:assembly

3
मुझे लगता है कि आपको अभी भी कुछ सामान करने की ज़रूरत है pom.xmlअन्यथा आप प्राप्त करें Error reading assemblies: No assembly descriptors found.। वैसे भी मेरे लिए यही होता है।
श्रीधर सरनोबत

3

यह सबसे अच्छा तरीका है जो मैंने पाया:

  <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

मुझे इंतजार है कि यह आप सभी के लिए उपयोगी होगा।


3

मैंने इस पोस्ट में उल्लिखित ट्री प्लगर्स की तुलना की है। मैंने सभी जार के साथ 2 जार और एक निर्देशिका तैयार की। मैंने परिणामों की तुलना की और निश्चित रूप से मावेन-शेड-प्लगइन सबसे अच्छा है। मेरी चुनौती यह थी कि मेरे पास कई वसंत संसाधन हैं जिन्हें मर्ज करने की आवश्यकता है, साथ ही जैक्स-आरएस, और जेडीबीसी सेवाएं भी। मावेन-असेंबली-प्लगइन की तुलना में उन्हें शेड प्लगइन द्वारा ठीक से मर्ज किया गया था। जब तक आप उन्हें अपने स्वयं के संसाधन फ़ोल्डर में कॉपी नहीं करते हैं और उन्हें एक बार मैन्युअल रूप से मर्ज नहीं करते हैं, तब तक वसंत विफल हो जाएगा। दोनों प्लगइन्स सही डिपेंडेंसी ट्री को आउटपुट करते हैं। मेरे पास परीक्षण, प्रदान, संकलन, आदि जैसे कई स्कोप थे और दोनों प्लगइन्स द्वारा प्रदान किए गए थे। वे दोनों एक ही रूप-रंग का उत्पादन करते थे लेकिन मैं अपने ट्रांसफॉर्मर का उपयोग करके छाया प्लगइन के साथ लाइसेंस को मजबूत करने में सक्षम था। मावेन-निर्भरता-प्लगइन के साथ बेशक आप डॉन ' t उन समस्याएँ हैं क्योंकि जार निकाले नहीं जाते हैं। लेकिन जैसे कुछ अन्य ने बताया है कि आपको ठीक से काम करने के लिए एक अतिरिक्त फ़ाइल (ओं) को ले जाने की आवश्यकता है। यहाँ 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>

2

मेरे लिए कुछ काम किया है:

  <plugin>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
      <execution>
        <id>unpack-dependencies</id>
        <phase>prepare-package</phase>
        <goals>
          <goal>unpack-dependencies</goal>
        </goals>
        <configuration>
          <outputDirectory>${project.build.directory}/classes</outputDirectory>
        </configuration>
      </execution>

    </executions>
  </plugin>


  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <executions>
      <execution>
        <id>unpack-dependencies</id>
        <phase>package</phase>
      </execution>
    </executions>
    <configuration>
      <archive>
        <manifest>
          <addClasspath>true</addClasspath>
          <classpathPrefix>lib/</classpathPrefix>
          <mainClass>SimpleKeyLogger</mainClass>
        </manifest>
      </archive>
    </configuration>
  </plugin>

मेरे पास असाधारण मामला था क्योंकि मेरी निर्भरता प्रणाली एक थी:

<dependency>
  ..
  <scope>system</scope>
  <systemPath>${project.basedir}/lib/myjar.jar</systemPath>
</dependency>

मैंने परिवर्तन के साथ @ user189057 द्वारा प्रदान किए गए कोड को बदल दिया है: 1) "तैयारी-पैकेज" चरण 2 में मावेन-निर्भरता-प्लगइन निष्पादित किया जाता है) मैं सीधे "लक्ष्य / कक्षाओं" के लिए अनपैक्ड क्लासस निकाल रहा हूं


2

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

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

1) अपने प्रोजेक्ट फोल्डर (एक्लिप्स में) पर राइट-क्लिक करें और चुनें Export

2) फिर सेलेक्ट करें Java->Runnable Jar

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

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


2

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

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

2

उबेर-जार से विशिष्ट निर्भरता को बाहर करने के विकल्पों की तलाश करने वाले किसी भी व्यक्ति के लिए, यह एक समाधान है जो मेरे लिए काम करता है:

<project...>
<dependencies>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_2.11</artifactId>
            <version>1.6.1</version>
            <scope>provided</scope> <=============
        </dependency>
</dependencies>
<build>
        <plugins>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>...</mainClass>
                        </manifest>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

तो यह मवन-असेंबली-प्लगइन का कॉन्फ़िगरेशन नहीं बल्कि निर्भरता की संपत्ति है।


2

लाखों उत्तर पहले से ही हैं, मैं आपको जोड़ना चाहता था <mainClass>यदि आपको अपने आवेदन में एंट्रीपॉइंट जोड़ने की आवश्यकता नहीं है। उदाहरण के लिए एपीआई में आवश्यक रूप से mainविधि नहीं हो सकती है ।

प्लगइन प्लगइन

  <build>
    <finalName>log-enrichment</finalName>
    <plugins>
      <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <configuration>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
        </configuration>
      </plugin>
    </plugins>
  </build>

निर्माण

mvn clean compile assembly:single

सत्यापित करें

ll target/
total 35100
drwxrwx--- 1 root vboxsf     4096 Sep 29 16:25 ./
drwxrwx--- 1 root vboxsf     4096 Sep 29 16:25 ../
drwxrwx--- 1 root vboxsf        0 Sep 29 16:08 archive-tmp/
drwxrwx--- 1 root vboxsf        0 Sep 29 16:25 classes/
drwxrwx--- 1 root vboxsf        0 Sep 29 16:25 generated-sources/
drwxrwx--- 1 root vboxsf        0 Sep 29 16:25 generated-test-sources/
-rwxrwx--- 1 root vboxsf 35929841 Sep 29 16:10 log-enrichment-jar-with-dependencies.jar*
drwxrwx--- 1 root vboxsf        0 Sep 29 16:08 maven-status/

2

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>

बस। अगला mvan पैकेज अतिरिक्त रूप से एक फैट जार भी बनाएगा, जिसमें सभी निर्भरता जार शामिल हैं।


1

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


1

यह ब्लॉग पोस्ट मावेन-जार और मावेन-असेंबली प्लगइन्स के संयोजन के साथ एक और दृष्टिकोण दिखाता है। ब्लॉग पोस्ट से असेंबली कॉन्फ़िगरेशन xml के साथ यह भी नियंत्रित किया जा सकता है अगर निर्भरता का विस्तार किया जाएगा या बस एक फ़ोल्डर में एकत्र किया जाएगा और प्रकट में क्लासपैथ प्रविष्टि द्वारा संदर्भित किया जाएगा:

आदर्श समाधान यह है कि जार को एक कामचलाऊ फ़ोल्डर में शामिल किया जाए और मुख्य जार की मेनिफेस्ट.एफएफ फाइल को कक्षा के सभी जार में शामिल किया जाए।

और ठीक ऐसा ही यहाँ वर्णित है: https://caffebig.wordpress.com/2013/04/05/executable-jar-file-with-dependent-jars-use-maven/


0
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>2.4.1</version>
            <configuration>
                <!-- get all project dependencies -->
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
            <executions>
                <execution>
                    <id>make-assembly</id>
                    <!-- bind to the packaging phase -->
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

1
इसके बारे में थोड़ा और स्पष्टीकरण चाहिए; क्या वे टिप्पणियां सिर्फ प्रलेखन हैं, या क्या उन टिप्पणियों के स्थानों पर अतिरिक्त विकल्पों को रखने की आवश्यकता है?
मार्क स्टीवर्ट

-2

ठीक है, तो यह मेरा समाधान है। मुझे पता है कि यह pom.xml फ़ाइल का उपयोग नहीं कर रहा है। लेकिन मुझे समस्या थी कि मेरे प्रोग्राममे को नेटबीन्स पर संकलित करने और चलाने की समस्या है, लेकिन जब मैंने जावा -जर MyJarFile.jar की कोशिश की तो यह असफल रहा। अब, मैं मावेन को पूरी तरह से समझ नहीं पा रहा हूं और मुझे लगता है कि मुझे नेटबर्न 8.0.2 पाने में परेशानी क्यों हो रही थी कि एक जार फाइल में उन्हें डालने के लिए मेरी जार फाइल को एक लाइब्रेरी में शामिल करें। मैं इस बारे में सोच रहा था कि मैं ग्रहण में बिना मावेन वाली जार फ़ाइलों का उपयोग कैसे करूं।

यह मावेन है जो सभी आश्रितों और प्लगइन्स को संकलित कर सकता है। नेटबीन्स नहीं। (यदि आप नेटबीन्स प्राप्त कर सकते हैं और जावा का उपयोग करने में सक्षम हैं। ऐसा करने के लिए कृपया मुझे बताएं कि कैसे (^ ^ ^) v)

[Solved - Linux के लिए] टर्मिनल खोलकर।

फिर

cd /MyRootDirectoryForMyProject

आगे

mvn org.apache.maven.plugins:maven-compiler-plugin:compile

आगे

mvn install

यह लक्ष्य निर्देशिका में जार फ़ाइल बनाएगा।

MyJarFile-1.0-jar-with-dependencies.jar

अभी

cd target

(आपको चलाने की आवश्यकता हो सकती है: chmod +x MyJarFile-1.0-jar-with-dependencies.jar )

और अंत में

java -jar MyJarFile-1.0-jar-with-dependencies.jar

कृपया देखें

https://cwiki.apache.org/confluence/display/MAVEN/LifecyclePhaseNotFoundException

मैं इस पृष्ठ को इसी तरह की समस्या वाले कुछ अन्य पृष्ठों पर पोस्ट करूँगा। उम्मीद है कि मैं किसी को निराशा के एक सप्ताह से बचा सकता हूं।


2
नेटवेन्स के साथ आपके द्वारा बनाई गई मावेन परियोजना को खोलने का प्रयास करें। नेटबीन्स का मूल नियम हमेशा मावेन प्रोजेक्ट बनाता है और कभी भी 'जावा एप्लिकेशन' नहीं होता है। उत्तरों में से एक की तरह मावेन-शेड-प्लगइन जोड़ें। एक जादू की तरह काम करता है।
rjdkolb
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.