मैं वितरण के लिए एक निष्पादन योग्य जार में अपनी परियोजना को पैकेज करना चाहता हूं।
मैं अपने उत्पादन JAR में सभी निर्भरता JAR से Maven प्रोजेक्ट पैकेज कैसे बना सकता हूं?
मैं वितरण के लिए एक निष्पादन योग्य जार में अपनी परियोजना को पैकेज करना चाहता हूं।
मैं अपने उत्पादन JAR में सभी निर्भरता JAR से Maven प्रोजेक्ट पैकेज कैसे बना सकता हूं?
जवाबों:
<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>
mvn clean compile assembly:single
:।
<appendAssemblyId>false</appendAssemblyId>
के configuration
लिए तत्व को भी जोड़ सकते हैं
compile
और तुम खराब हो।
आप पैकेज चरण से पहले एक अलग निर्देशिका में सभी निर्भरता उत्पन्न करने के लिए निर्भरता-प्लगइन का उपयोग कर सकते हैं और फिर इसे प्रकट के क्लासपाथ में शामिल कर सकते हैं:
<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
रूप से आउटपुट जार के रूप में सभी जार-फ़ाइलों को मुख्य जार में एकीकृत करने के लिए उपयोग करें , लेकिन फिर आपको जार लोड करने के लिए कस्टम क्लासलोडिंग कोड जोड़ना होगा।
${project.build.directory}/classes/lib
करता हूं outputDirectory
, लेकिन - इस जार को लोड करने के लिए कस्टम क्लास लोडिंग कोड कैसे जोड़ें? मैं की तरह काम निष्पादन करने की जरूरत है: java -jar main-jar-with-deps.jar
। क्या यह संभव है ?
मैंने ऐसा करने के लिए कुछ अलग तरीकों के बारे में ब्लॉग किया।
अपाचे मावेन (वर्डप्रेस) के साथ निष्पादन योग्य जार देखें
या अमल-जार-साथ-मावेन-उदाहरण (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>
<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
।
<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
।
अनुत्तरित का उत्तर लेना और उसे सुधारना, हमारे पास है:
<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>
सभी निर्भरता को एक 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>
लंबे समय से मावेन असेंबली प्लगइन का उपयोग किया गया था , लेकिन मुझे समस्या का हल नहीं मिला "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>
आप मावेन-निर्भरता-प्लगइन का उपयोग कर सकते हैं, लेकिन सवाल यह था कि एक निष्पादन योग्य जार कैसे बनाया जाए। मैथ्यू फ्रेंगलन की प्रतिक्रिया (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>
आप नीचे की तरह 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>
एक अन्य विकल्प यदि आप वास्तव में अपने एकल परिणामक JAR के अंदर अन्य JAR की सामग्री को वापस करना चाहते हैं तो Maven असेंबली प्लगइन है । यह अनपैक करता है और फिर एक डायरेक्टरी के माध्यम से सब कुछ रिपीट करता है <unpack>true</unpack>
। फिर आपके पास एक दूसरा पास होगा जिसने इसे एक बड़े पैमाने पर जार में बनाया।
एक अन्य विकल्प OneJar प्लगइन है । यह सभी एक कदम में उपरोक्त रीपैकेजिंग क्रिया करता है।
आप अपने 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 के साथ यह परीक्षण किया ।
मैं इन प्रतिक्रियाओं में से हर एक के माध्यम से चला गया, जो सभी निर्भरता वाले वसा निष्पादन योग्य जार बनाने के लिए देख रहा था और उनमें से किसी ने भी सही काम नहीं किया। उत्तर छाया प्लगइन है, इसका बहुत आसान और सीधा है।
<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>
इस बात से अवगत रहें कि आपकी निर्भरता को ठीक से काम करने के लिए संकलन या रनटाइम की गुंजाइश होनी चाहिए।
plugin
तत्व में चला जाता है pom.xml
के तहत build/plugins
।
आप 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
केन लियू का मेरी राय में यह सही है। मावेन निर्भरता प्लगइन आपको सभी निर्भरता का विस्तार करने की अनुमति देता है, जिसे आप फिर संसाधनों के रूप में मान सकते हैं। यह आपको उन्हें मुख्य कलाकृति में शामिल करने की अनुमति देता है। असेंबली प्लगइन का उपयोग एक माध्यमिक कलाकृति बनाता है जिसे संशोधित करना मुश्किल हो सकता है - मेरे मामले में मैं कस्टम मैनिफ़ेस्ट प्रविष्टियों को जोड़ना चाहता था। मेरा पोम इस प्रकार समाप्त हुआ:
<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>
यह इस तरह होना चाहिए:
<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>
अनपैकिंग को जनरेट-रिसोर्सेज के चरण में होना चाहिए क्योंकि यदि पैकेज फेज में है, तो रिसोर्स के रूप में शामिल नहीं किया जाएगा। साफ पैकेज का प्रयास करें और आप देखेंगे।
मवन-असेंबली-प्लगइन-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>
इस समस्या को हल करने के लिए हम मावेन असेंबली प्लगिन का उपयोग करेंगे जो कि 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 टूल चलाना न भूलें: सिंगल
मैं सीधे इस सवाल का जवाब नहीं दूंगा क्योंकि अन्य पहले भी कर चुके हैं, लेकिन मुझे वास्तव में आश्चर्य है कि क्या यह परियोजना के जार में सभी निर्भरता को एम्बेड करने के लिए एक अच्छा विचार है।
मैं बिंदु (तैनाती / उपयोग में आसानी) देखता हूं, लेकिन यह आपके मार्मिक के उपयोग के मामले पर निर्भर करता है (और विकल्प हो सकते हैं (नीचे देखें))।
यदि आप इसे पूरी तरह से स्टैंडअलोन का उपयोग करते हैं, तो क्यों नहीं।
लेकिन अगर आप अपने प्रोजेक्ट का उपयोग अन्य संदर्भों में करते हैं (जैसे वेबैप में, या उस फ़ोल्डर में गिरा जहां अन्य जार बैठे हैं), तो आप अपने क्लासपैथ में जार डुप्लिकेट हो सकते हैं (फ़ोल्डर में लोग, जार में एक)। शायद कोई बोली का सौदा नहीं लेकिन मैं आमतौर पर इससे बचता हूं।
एक अच्छा विकल्प:
इस तरह, अंत में केवल एक प्रकट और "विशेष गतिशील क्लास लोडर मुख्य" के साथ, आप अपनी परियोजना को इसके साथ शुरू कर सकते हैं:
java -jar ProjectMainJar.jar com.stackoverflow.projectName.MainDynamicClassLoaderClass
कमांड लाइन से एक निष्पादन योग्य JAR बनाने के लिए, केवल प्रोजेक्ट पथ से नीचे कमांड चलाएं:
mvn assembly:assembly
pom.xml
अन्यथा आप प्राप्त करें Error reading assemblies: No assembly descriptors found.
। वैसे भी मेरे लिए यही होता है।
यह सबसे अच्छा तरीका है जो मैंने पाया:
<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
मुझे इंतजार है कि यह आप सभी के लिए उपयोगी होगा।
मैंने इस पोस्ट में उल्लिखित ट्री प्लगर्स की तुलना की है। मैंने सभी जार के साथ 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>
मेरे लिए कुछ काम किया है:
<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 में मावेन-निर्भरता-प्लगइन निष्पादित किया जाता है) मैं सीधे "लक्ष्य / कक्षाओं" के लिए अनपैक्ड क्लासस निकाल रहा हूं
मैंने यहां सबसे अधिक मतदान का उत्तर देने की कोशिश की, और जार को चलाने योग्य बनाया। लेकिन कार्यक्रम सही ढंग से नहीं चला। मुझे नहीं पता कि इसका कारण क्या था। जब मैं दौड़ने की कोशिश करता Eclipse
हूं, तो मुझे एक अलग परिणाम मिलता है लेकिन जब मैं कमांड-लाइन से जार को चलाता हूं तो मुझे एक अलग परिणाम मिलता है (यह प्रोग्राम-विशिष्ट रनटाइम त्रुटि के साथ क्रैश होता है)।
मुझे ओपी के समान ही आवश्यकता थी कि मेरी परियोजना के लिए मेरे पास बहुत (मावेन) निर्भरताएं थीं। सौभाग्य से, एकमात्र समाधान जो मेरे लिए काम करता था, वह था उपयोग करना Eclipse
। बहुत सरल और बहुत सीधा। यह ओपी के लिए एक समाधान नहीं है, बल्कि एक ऐसे व्यक्ति के लिए एक समाधान है जिसकी समान आवश्यकता है लेकिन कई मावेन निर्भरता के साथ,
1) अपने प्रोजेक्ट फोल्डर (एक्लिप्स में) पर राइट-क्लिक करें और चुनें Export
2) फिर सेलेक्ट करें Java
->Runnable Jar
3) आपको जार फ़ाइल का स्थान चुनने के लिए कहा जाएगा
4) अंत में, उस क्लास का चयन करें जिसमें मुख्य विधि है जिसे आप चलाना और चुनना चाहते हैं Package dependencies with the Jar file
और क्लिक करेंFinish
यह भी एक विकल्प हो सकता है, आप अपनी जार फ़ाइल बनाने में सक्षम होंगे
<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>
उबेर-जार से विशिष्ट निर्भरता को बाहर करने के विकल्पों की तलाश करने वाले किसी भी व्यक्ति के लिए, यह एक समाधान है जो मेरे लिए काम करता है:
<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>
तो यह मवन-असेंबली-प्लगइन का कॉन्फ़िगरेशन नहीं बल्कि निर्भरता की संपत्ति है।
लाखों उत्तर पहले से ही हैं, मैं आपको जोड़ना चाहता था <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/
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 पैकेज अतिरिक्त रूप से एक फैट जार भी बनाएगा, जिसमें सभी निर्भरता जार शामिल हैं।
मावेन-असेंबली-प्लगइन ने मेरे लिए बहुत अच्छा काम किया। मैंने मावन-निर्भरता-प्लगइन के साथ घंटे बिताए और यह काम नहीं कर सका। मुख्य कारण यह था कि मुझे कॉन्फ़िगरेशन अनुभाग में स्पष्ट रूप से विरूपण साक्ष्य आइटम को परिभाषित करना था जिसे शामिल किया जाना चाहिए क्योंकि यह प्रलेखन में वर्णित है । ऐसे मामलों के लिए एक उदाहरण है जब आप इसका उपयोग करना चाहते हैं: जैसे mvn dependency:copy
, जहां कोई भी कलाकृतियों को शामिल नहीं किया गया है, लेकिन यह काम नहीं करता है।
यह ब्लॉग पोस्ट मावेन-जार और मावेन-असेंबली प्लगइन्स के संयोजन के साथ एक और दृष्टिकोण दिखाता है। ब्लॉग पोस्ट से असेंबली कॉन्फ़िगरेशन xml के साथ यह भी नियंत्रित किया जा सकता है अगर निर्भरता का विस्तार किया जाएगा या बस एक फ़ोल्डर में एकत्र किया जाएगा और प्रकट में क्लासपैथ प्रविष्टि द्वारा संदर्भित किया जाएगा:
आदर्श समाधान यह है कि जार को एक कामचलाऊ फ़ोल्डर में शामिल किया जाए और मुख्य जार की मेनिफेस्ट.एफएफ फाइल को कक्षा के सभी जार में शामिल किया जाए।
और ठीक ऐसा ही यहाँ वर्णित है: https://caffebig.wordpress.com/2013/04/05/executable-jar-file-with-dependent-jars-use-maven/
<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>
ठीक है, तो यह मेरा समाधान है। मुझे पता है कि यह 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
मैं इस पृष्ठ को इसी तरह की समस्या वाले कुछ अन्य पृष्ठों पर पोस्ट करूँगा। उम्मीद है कि मैं किसी को निराशा के एक सप्ताह से बचा सकता हूं।