බෙදා හැරීම සඳහා මගේ ව්යාපෘතිය ක්රියාත්මක කළ හැකි JAR එකක ඇසුරුම් කිරීමට මට අවශ්යය.
මගේ නිමැවුම් JAR තුළට සියලු යැපුම් JARs මාවන් ව්යාපෘති පැකේජයක් කරන්නේ කෙසේද?
බෙදා හැරීම සඳහා මගේ ව්යාපෘතිය ක්රියාත්මක කළ හැකි JAR එකක ඇසුරුම් කිරීමට මට අවශ්යය.
මගේ නිමැවුම් JAR තුළට සියලු යැපුම් JARs මාවන් ව්යාපෘති පැකේජයක් කරන්නේ කෙසේද?
Answers:
<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
එකලස් කිරීමට පෙර සම්පාදක ඉලක්කය එකතු කළ යුතුය: තනි හෝ වෙනත් ආකාරයකින් ඔබේම ව්යාපෘතියේ කේතය ඇතුළත් නොවේ.
අදහස් වලින් වැඩි විස්තර බලන්න.
සාමාන්යයෙන් මෙම ඉලක්කය ස්වයංක්රීයව ක්රියාත්මක කිරීම සඳහා ගොඩනැගීමේ අවධියකට බැඳී ඇත. mvn install
යෙදවීම / මුදා හැරීම ක්රියාත්මක කිරීමේදී හෝ සිදු කිරීමේදී JAR ගොඩනගා ඇති බව මෙය සහතික කරයි .
<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
නාමයෙන් කරදර කාරී "-jar-සමග-පරායත්තයන්" යන ෙපර ෙයදුම වළක්වා ගැනීමට
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
ලෙස සියලුම භාජන ගොනු ප්රධාන භාජනයට ඒකාබද්ධ කිරීම සඳහා OutputDirectory ලෙස භාවිතා කරන්න , නමුත් පසුව ඔබට භාජන පැටවීම සඳහා අභිරුචි පන්ති පැටවීමේ කේතය එක් කිරීමට අවශ්ය වනු ඇත.
${project.build.directory}/classes/lib
ලෙස outputDirectory
ඇතුළත සියලු පරායත්තයන් සමඟ එක් ප්රධාන .jar ඇති, නමුත් - මේ භාජන පූරණය අභිරුචි classloading කේතය එකතු කරන්නේ කෙසේද? මට වැඩ ක්රියාත්මක කිරීමට අවශ්ය වන්නේ : 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"
. දැන්, මම තවත් ප්ලගිනයක් භාවිතා කරමි - onejar-maven-plugin . පහත උදාහරණය ( 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>
ඔබට maven-dependency-plugin භාවිතා කළ හැකිය, නමුත් ප්රශ්නය වූයේ ක්රියාත්මක කළ හැකි JAR එකක් නිර්මාණය කරන්නේ කෙසේද යන්නයි. එය සිදු කිරීම සඳහා මැතිව් ෆ්රැන්ග්ලන්ගේ ප්රතිචාරයට පහත සඳහන් වෙනස් කිරීම අවශ්ය වේ (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>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
</execution>
</executions>
</plugin>
ඔබේ තනි ප්රති result ලයක් වන JAR තුළ ඇති අනෙකුත් JAR අන්තර්ගතයන් නැවත ඇසුරුම් කිරීමට ඔබට අවශ්ය නම් තවත් විකල්පයක් වන්නේ Maven Assembly ප්ලගිනයයි . එය ඉවත් කර සියල්ල ඩිරෙක්ටරියක් හරහා නැවත ඇසුරුම් කරයි <unpack>true</unpack>
. එවිට ඔබට දෙවන වර්ගය ලැබෙනු ඇත, එය එක් දැවැන්ත JAR බවට පත් විය.
තවත් විකල්පයක් වන්නේ 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 පිහිටා ඇති නාමාවලිය වෙත කොන්සෝලය හරහා මාරු විය යුතුය. එවිට ඔබට mvn එකලස් කිරීම සිදු කළ යුතුය: තනි සහ පසුව පරායත්තතා සහිත ඔබේ ක්රියාත්මක කළ හැකි JAR ගොනුව බලාපොරොත්තු සහගතව ගොඩනඟනු ඇත. සමග ප්රතිදානය (ඉලක්කය) බහලුම වෙත මාරු විට ඔබ එය පරීක්ෂා කර ගත හැක cd ./target හා විධාන similiar ඔබේ භාජනයක් ආරම්භ ජාවා -jar mavenproject1-1.0-සැණරුව-භාජනයක්-සමග-dependencies.jar .
මම මෙය Apache Maven 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
ඔබේ ක්රියාත්මක කළ හැකි භාජනයේ ප්රධාන පංතිය නියම කිරීමට වින්යාස කරන්න (පන්ති මාර්ගය සකසන්න , "භාජනය ක්රියාත්මක කළ හැකි කරන්න" යන පරිච්ඡේදය බලන්න ).උදාහරණ සඳහා POM වින්යාසය 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 නොවේ) නම්, ඔබට මෙම පරායත්තතාවය ප්ලගීන කළමනාකරණ අංශයේ ඉහළම මව්පිය 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>
මෙය සිදු කිරීමෙන් පසු මෙම විධානය සමඟ MAVEN මෙවලම ධාවනය කිරීමට අමතක නොකරන්න mvn clean compile assembly: single
වෙනත් අය මීට පෙර සිදු කර ඇති ආකාරයට මම කෙලින්ම ප්රශ්නයට පිළිතුරු නොදෙනු ඇත, නමුත් ව්යාපෘතියේ භාජනයේම සියලු පරායත්තතාවයන් ඇතුළත් කිරීම හොඳ අදහසක් දැයි මම කල්පනා කරමි.
මම කාරණය දකිමි (යෙදවීමේ / භාවිතයේ පහසුව) නමුත් එය ඔබගේ විෂයය භාවිතා කිරීමේ අවස්ථාව මත රඳා පවතී (සහ විකල්ප තිබිය හැකිය (පහත බලන්න)).
ඔබ එය සම්පුර්ණයෙන්ම භාවිතා කරන්නේ නම්, එසේ නොකරන්නේ මන්ද?
නමුත් ඔබ ඔබේ ව්යාපෘතිය වෙනත් සන්දර්භයන්හි භාවිතා කරන්නේ නම් (වෙබ් ඇප් එකක මෙන් හෝ වෙනත් භාජන වාඩි වී ඇති ෆෝල්ඩරයක දමා ඇත), ඔබේ පන්ති මාවතේ භාජන අනුපිටපත් තිබිය හැකිය (ෆෝල්ඩරයේ ඇති ඒවා, භාජනවල ඇති). සමහර විට ලංසු ගනුදෙනුවක් නොවුනත් මම සාමාන්යයෙන් මෙය වළක්වන්නෙමි.
හොඳ විකල්පයක්:
මේ හා සමානව, අවසානයේදී මැනිෆෙස්ට් සහ “විශේෂ ගතික පන්ති පැටවුම් ප්රධාන” සමඟින් ඔබට ඔබේ ව්යාපෘතිය ආරම්භ කළ හැක්කේ:
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
) එම JMX සේවාදායකය ආරම්භ, සහ ලැබෙන බව start
හෝ stop
පරාමිතිය. ඉතින් මේ සමඟ මගේ යෙදුම මේ ආකාරයෙන් ආරම්භ කිරීමට මට හැකි විය:
java -jar ./lib/TestApp-1.0-SNAPSHOT.jar start
එය ඔබ සැමට ප්රයෝජනවත් වේ යැයි මම බලා සිටිමි.
මම මෙම ලිපියේ සඳහන් ගස් ප්ලගීන සංසන්දනය කළෙමි. මම භාජන 2 ක් සහ සියලු භාජන සහිත නාමාවලියක් ජනනය කළෙමි. මම ප්රති results ල සංසන්දනය කළ අතර අනිවාර්යයෙන්ම මේවන්-සෙවන-ප්ලගිනය හොඳම වේ. මගේ අභියෝගය වූයේ ඒකාබද්ධ කිරීමට අවශ්ය වසන්ත සම්පත් මෙන්ම ජැක්ස්-ආර්එස් සහ ජේඩීබීසී සේවාවන් මා සතුව තිබීමයි. මේවන්-එකලස්-ප්ලගිනයට සාපේක්ෂව ඒවා සියල්ලම සෙවන ප්ලගිනය මගින් නිසි ලෙස ඒකාබද්ධ කරන ලදී. ඔබ ඒවා ඔබේම සම්පත් ෆෝල්ඩරයට පිටපත් කර ඒවා එක් වරක් අතින් ඒකාබද්ධ නොකරන්නේ නම් වසන්තය අසාර්ථක වනු ඇත. ප්ලගීන දෙකම නිවැරදි පරායත්තතා ගස ප්රතිදානය කරයි. මට පරීක්ෂණය, සැපයීම, සම්පාදනය කිරීම වැනි විවිධ විෂය පථයන් තිබුණි. පරීක්ෂණය සහ ලබා දී ඇත්තේ ප්ලගීන දෙකම මග හැරීමෙනි. ඔවුන් දෙදෙනාම එකම මැනිෆෙස්ටයක් නිපදවූ නමුත් ඒවායේ ට්රාන්ස්ෆෝමරය භාවිතා කර සෙවන ප්ලගිනය සමඟ බලපත්ර ඒකාබද්ධ කිරීමට මට හැකි විය. මේවන්-යැපුම්-ප්ලගිනය සමඟ ඇත්ත වශයෙන්ම ඔබ එසේ නොවේ භාජන නිස්සාරණය නොකිරීම නිසා එම ගැටළු නොමැත. නමුත් වෙනත් සමහරක් පෙන්වා දී ඇති පරිදි නිසි ලෙස ක්රියා කිරීම සඳහා එක් අතිරේක ගොනුවක් රැගෙන යා යුතුය. මෙන්න 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
, මට වෙනස් ප්රති result ලයක් ලැබෙනු ඇත, නමුත් මම විධාන රේඛාවෙන් බඳුන ධාවනය කරන විට මට වෙනස් ප්රති result ලයක් ලැබේ (එය ක්රමලේඛ විශේෂිත ධාවන කාල දෝෂයක් සමඟ බිඳ වැටේ).
මගේ ව්යාපෘතිය සඳහා මට බොහෝ (මාවන්) පරායත්තතා තිබීම නිසා මට OP හා සමාන අවශ්යතාවයක් තිබුණි. වාසනාවකට මෙන්, මට වැඩ කළ එකම විසඳුම එය භාවිතා Eclipse
කිරීමයි. ඉතා සරල හා ඉතා සරල ය. මෙය OP සඳහා විසඳුමක් නොවන නමුත් සමාන අවශ්යතාවයක් ඇති නමුත් බොහෝ මේවන් පරායත්තතා ඇති අයෙකුට විසඳුමකි,
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>
Uber-jar වෙතින් නිශ්චිත පරායත්තයන් බැහැර කිරීමට විකල්ප සොයන ඕනෑම කෙනෙකුට, මෙය මා වෙනුවෙන් වැඩ කළ විසඳුමකි:
<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>
එබැවින් එය mvn-assembly-plugin හි වින්යාසය නොව පරායත්තතාවයේ දේපලකි.
දැනටමත් පිළිතුරු මිලියන ගණනක් ඇත, මට <mainClass>
ඔබගේ යෙදුමට ඇතුළත් කිරීමේ ස්ථානය එක් කිරීමට අවශ්ය නැතිනම් ඔබට අවශ්ය නොවන බව එක් කිරීමට අවශ්ය විය. උදාහරණයක් ලෙස API වලට අනිවාර්යයෙන්ම 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>
ඒක තමයි. මීලඟ mvn පැකේජය සියලු පරායත්ත භාජන ද ඇතුළුව එක් මේද භාජනයක් ද නිර්මාණය කරයි.
මේවන්-එකලස්-ප්ලගිනය මට හොඳට වැඩ කළා. මම මේවන්-යැපුම්-ප්ලගිනය සමඟ පැය ගණනක් ගත කළ අතර එය ක්රියාත්මක කිරීමට නොහැකි විය. ප්රධාන හේතුව වූයේ වින්යාස කොටසේ පැහැදිලිව නිර්වචනය කිරීමට සිදුවීම ලේඛනයේ විස්තර කර ඇති පරිදි ඇතුළත් කළ යුතු පුරාවස්තු අයිතමයි . ඔබට එය භාවිතා කිරීමට අවශ්ය අවස්ථාවන්හි උදාහරණයක් තිබේ : mvn dependency:copy
, කිසිදු පුරාවස්තු අයිතමයක් ඇතුළත් කර නැති නමුත් එය ක්රියා නොකරයි.
මෙම බ්ලොග් සටහන මේවන්-ජාර් සහ මේවන්-එකලස් කිරීමේ ප්ලගීන ඒකාබද්ධ කිරීම සමඟ තවත් ප්රවේශයක් පෙන්වයි. බ්ලොග් පෝස්ට් එකෙන් එක්රැස් කිරීමේ වින්යාසය සමඟ පරායත්තතා පුළුල් වේ ද නැතිනම් ෆෝල්ඩරයක එකතු කර මැනිෆෙස්ටයේ පන්ති මාර්ග ප්රවේශයකින් යොමු කරනු ලැබේ ද යන්න පාලනය කළ හැකිය:
කදිම විසඳුම වන්නේ භාජන ලිබ් ෆෝල්ඩරයකට ඇතුළත් කිරීම සහ ප්රධාන භාජනයේ මැනිෆෙස්ට් එම්එෆ් ගොනුවට පන්ති පථයේ ඇති සියලුම භාජන ඇතුළත් කිරීමයි.
එය හරියටම මෙහි විස්තර කර ඇත: https://caffebig.wordpress.com/2013/04/05/executable-jar-file-with-dependent-jars-using-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 ගොනුව භාවිතා නොකරන බව. නමුත් මගේ ක්රමලේඛය නෙට්බීන්ස් මත සම්පාදනය කිරීම හා ක්රියාත්මක කිරීම පිළිබඳ ගැටළුව මට ඇති නමුත් මම ජාවා -ජාර් මයිජාර් ෆයිල්.ජාර් උත්සාහ කළ විට එය අසාර්ථක විය. දැන්, මට මේවන් සම්පූර්ණයෙන් නොතේරෙන අතර, මගේ භාජන ගොනුව පුස්තකාලයකට ඇතුළත් කිරීම සඳහා නෙට්බීන්ස් 8.0.2 ලබා ගැනීමට අපහසු වූයේ මන්දැයි මම සිතමි. මම කල්පනා කරමින් සිටියේ සූර්යග්රහණයේ කිසිදු මාවන් නොමැති භාජන ලිපිගොනු භාවිතා කරන ආකාරය ගැන ය.
සියලු යැපීම් සහ ප්ලගීන සම්පාදනය කළ හැකි මාවන් ය. නෙට්බීන්ස් නොවේ. (ඔබට නෙට්බීන්ස් ලබා ගත හැකි නම් සහ ජාවා .ජාර් භාවිතා කිරීමට හැකි නම් කරුණාකර මට කියන්න (^. ^) V)
ටර්මිනලයක් විවෘත කිරීමෙන් [විසඳා ඇත - ලිනක්ස් සඳහා].
ඉන්පසු
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
ඒ හා සමාන ගැටලුවක් ඇති තවත් පිටු කිහිපයක මම මෙම විසඳුම පළ කරමි. බලාපොරොත්තු සුන් වූ සතියකින් මට යමෙකු බේරා ගත හැකි යැයි සිතමි.