මාවන් භාවිතා කරමින් පරායත්තතා සහිත ක්‍රියාත්මක කළ හැකි JAR එකක් නිර්මාණය කරන්නේ කෙසේද?


2407

බෙදා හැරීම සඳහා මගේ ව්‍යාපෘතිය ක්‍රියාත්මක කළ හැකි JAR එකක ඇසුරුම් කිරීමට මට අවශ්‍යය.

මගේ නිමැවුම් JAR තුළට සියලු යැපුම් JARs මාවන් ව්‍යාපෘති පැකේජයක් කරන්නේ කෙසේද?


14
කරුණාකර ඔබ යොමු කරන පරායත්ත ප්ලගිනයේ කුමන ඉලක්කයද යන්න පැහැදිලි කරන්න. මුල් ප්‍රශ්නය ඉල්ලා සිටින දෙය කරන කිසිදු ඉලක්කයක් ගැන මම නොදනිමි: A) සියලු පරායත්තයන් කතුවරුන්ගේ භාජනය තුළ නැවත ඇසුරුම් කිරීම හරහා තැබීම, හෝ B) MANIFEST හි පන්ති මාවතක අනෙක් ඒවා ඇති ක්‍රියාත්මක කළ හැකි භාජනයක් සාදන්න. MF
මැතිව් මැකලෝ

2
ඔබට මෙම ප්‍රයෝජනවත් rationaljava.com/2015/02/…
Dan


Answers:


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

23
ස්තූතියි @ අයිඩැප්ටරය. ඔබ සැමවිටම අතින් සම්පාදනය කළ යුතු බව සලකන්න, මන්ද එය "ඉලක්ක / පන්ති" තුළ ඇති ඕනෑම දෙයක් JAR හි තබනු ඇත. මූලාශ්‍ර කේතයට ඔබ මෑතකදී කළ වෙනස්කම් JAR හි ඇතුළත් බව මෙය සහතික කරයි. එබැවින්, ඔබ එවැනි දෙයක් කළ යුතුය : mvn clean compile assembly:single.
මයිකල්

10
අදියර බන්ධනය ඇතුළත් කිරීම සඳහා මම ප්‍රශ්නය සංස්කරණය කර ඇත. අතහැර දැමූ එකලස් කිරීමේ ඉලක්කය මම ඉවත් කළෙමි, මන්ද කිසිවෙකු ඒ ගැන දැනගත යුතු නැත.
ඩන්කන් ජෝන්ස්

2
මෙය උබර් භාජනයට භාජන එකතු නොකරන බව මට පෙනේ, ඒ වෙනුවට මෙය සියලුම පන්ති ලිපිගොනු බඳුනට එක් කරයි.
pitblack408

172
ඉඟිය: ඔබ ද එම මූලද්රව්යය එකතු කළ හැකි <appendAssemblyId>false</appendAssemblyId>බවට configurationනාමයෙන් කරදර කාරී "-jar-සමග-පරායත්තයන්" යන ෙපර ෙයදුම වළක්වා ගැනීමට
maxivis

7
අමතක compileකර ඔබ ඉස්කුරුප්පු කර ඇත.
prayagupd

350

පැකේජ අවධියට පෙර වෙනම නාමාවලියක සියලු පරායත්තයන් ජනනය කිරීමට ඔබට පරායත්ත-ප්ලගිනය භාවිතා කළ හැකි අතර පසුව එය මැනිෆෙස්ටයේ පන්ති පථයට ඇතුළත් කරන්න:

<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 ලෙස භාවිතා කරන්න , නමුත් පසුව ඔබට භාජන පැටවීම සඳහා අභිරුචි පන්ති පැටවීමේ කේතය එක් කිරීමට අවශ්‍ය වනු ඇත.


3
+1 විශිෂ්ටයි. මම මේවන්-එකලස්-ප්ලගිනය වෙනුවට මේවන්-පරායත්ත-ප්ලගිනය සමඟ යාමට හේතුව, මමත් බිල්ඩ්නම්බර්-මේවන්-ප්ලගිනය භාවිතා කරන අතර, මේ ආකාරයෙන් මට එක් එක් භාජනයේ මැනිෆෙස්ටයේ අනුවාද අංකය තනි තනිව ගබඩා කළ හැකිය.
PapaFreud

17
මම ඔබේ විසඳුමට කැමතියි. මම භාවිතා ${project.build.directory}/classes/libලෙස outputDirectoryඇතුළත සියලු පරායත්තයන් සමඟ එක් ප්රධාන .jar ඇති, නමුත් - මේ භාජන පූරණය අභිරුචි classloading කේතය එකතු කරන්නේ කෙසේද? මට වැඩ ක්‍රියාත්මක කිරීමට අවශ්‍ය වන්නේ : java -jar main-jar-with-deps.jar. මෙය කළ හැකිද?
මාරියෝෂ්

3
@ ඇන්ඩ්‍රේ අරොන්සන්, මම මෙම විසඳුම භාවිතා කළේ භාජනය තුළ ඇති ලිබ් ෆෝල්ඩරයක පරායත්තතාවයන් එක් කිරීමට ය, නමුත් මට සෑම විටම පන්ති සොයාගත නොහැකි ව්‍යතිරේකයක් ලැබේ, කරුණාකර එය නිවැරදි කරන්නේ කෙසේදැයි ඔබට උපදෙස් දිය හැකිද?
මහමුද් සාලේ

11
+1 ඔබට !! මේවන් එකලස් කිරීමේ ප්ලගිනය 'ජාර්-විත්-පරායත්තතා' සැබවින්ම හොඳින් ක්‍රියාත්මක නොවන බව පෙනේ. ජනනය කරන ලද භාජනයේ META-INF / spring.schemas වෙතින් සමහර සටහන් මට අස්ථානගත විය. ඒ නිසා මම භාජනය සමඟ යැපීම් ඉවත් කර ඉහත ඔබේ විසඳුම භාවිතා කළෙමි. පරිපූර්ණ ස්තූතියි !!!
ඩෙරෙක්

9
මෙම ගැටළුවට මුහුණ දෙන වෙනත් ඕනෑම කෙනෙකුට, ඔබ බඳුන ප්‍රවාහනය කරන ඕනෑම තැනක ඔබේ බඳුන සමඟ එකම නාමාවලියෙහි ලිබ් ෆෝල්ඩරය ඇතුළත් කළ යුතුය.
ස්පාර්ටිකල්ස්

226

මෙය කිරීමට විවිධ ක්‍රම කිහිපයක් ගැන මම බ්ලොග් කළෙමි.

අපාචේ මේවන් (වර්ඩ්ප්‍රෙස්) සමඟ ක්‍රියාත්මක කළ හැකි භාජනය බලන්න

හෝ ක්‍රියාත්මක කළ හැකි-ජාර්-සමඟ-මේවන්-උදාහරණය (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.


Apache Maven Shade Plugin

  • වාසි
  • අවාසි
<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-plugin

  • වාසි
  • අවාසි
    • 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
මෙම පිළිතුරේ ප්‍රවේශය භාවිතා කිරීමෙන් පහත දැක්වෙන දෝෂ පණිවිඩය ලැබෙනු ඇත: 'java -jar <jar file>' භාවිතා කරමින් JAR ධාවනය කිරීමට උත්සාහ කරන විට, <jar file> වෙතින් ප්‍රධාන පන්තියේ මැනිෆෙස්ට් ගුණාංගය පැටවීමට අපොහොසත් විය
එල්මෝ

3
මෙම ලැබෙන කව්ලුවේ-භාජනයක්-plugin ලේඛනාගාරයේ කොටසක් අවශ්ය වේ <සංරක්ෂිත> <ප්රකාශ> <addClasspath> සැබෑ </ addClasspath> <mainClass> fully.qualified.MainClass </ mainClass> </ ප්රකාශ> </ සංරක්ෂිත>
Rade_303

4
සමාවන්න, මෙම පිළිතුර සරල වැරදි වේ, mainClass ටැගය ලැබෙන කව්ලුවේ-එකලස්-plugin ඇතුලත් විය ඔබ ඉල්ලා සිටින නිසා බව පැකේජය ඉලක්කය තුළ ඇති
ඇලෙක්ස් ලේමන්

මට පුදුමයි, mvn archetype: ජනනය විධානයෙන් පසු pom.xml ට දැනටමත් මෙය ඇතුළත් කළ නොහැක්කේ ඇයි? මම නව මාවන් ව්‍යාපෘතියක් නිර්මාණය කරන සෑම අවස්ථාවකම මෙය අතින් පිටපත් කිරීම යම්
තරමක කරදරයකි

මට යම් ආකාරයක ප්‍රධාන ක්‍රමයක් හෝ පන්තියක් නොමැත, මට ඇත්තේ ශ්‍රිතය සමඟ පන්තියකි. මම භාජනයක් සාදා එය භාවිතා කරන්නේ කෙසේද
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 ධාවන වේලාවේදී පන්ති පථයට පිවිසෙන්නේ කෙසේද?
ඇන්ඩ rew ස්වෑන්

එය මගේ පරායත්තතාවයේ කොටසක් වන cxf-rt-ws-security මගින් ඇදගෙන යනු ලැබීය
විජේ කටම්

මෙම ප්ලගිනය ගැන මීට පෙර කවදාවත් අසා නැත, නමුත් එය භාජන තුළ ඇති වසන්ත.හෑන්ඩ්ලර්ස් සමඟ මගේ ගැටලුව විසඳීය. ස්තූතියි!
ඇලෙක්සැන්ඩර් එල් ටෙල්ස්

11
ආරක්ෂක ව්‍යතිරේකයක් ලබා ගත් අය, DSA හි ප්‍රතිපත්ති ප්‍රකාශනයෙන් බැහැර කරති. MAven.apache.org/plugins/maven-shade-plugin/examples/…
ruhsuzbaykus

+1 මම අතීතයේ මිනිජාර්: ueberjar භාවිතා කර ඇත, නමුත් මිනිජර් ප්ලගිනය දැන් අතහැර දමා සෙවන මගින් ප්‍රතිස්ථාපනය කර ඇත
rds

19

දිගු කලක් මේවන් එකලස් කිරීමේ ප්ලගිනය භාවිතා කළ නමුත් මට ගැටලුවට විසඳුමක් සොයා ගැනීමට නොහැකි විය "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>

ප්‍රතිදානයේ ඇති අමතර පණිවිඩ ඉවත් කරන්නේ කෙසේද?
ඇලෙක්සැන්ඩර්

17

ඔබට 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>

16

පහත දැක්වෙන පරිදි 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>

නමුත් මෙය කොහොමද repo සඳහා යොදවන්නේ?
ෆ්‍රැන්චෙස්කෝ ග්වාලාසි

15

ඔබේ තනි ප්‍රති result ලයක් වන JAR තුළ ඇති අනෙකුත් JAR අන්තර්ගතයන් නැවත ඇසුරුම් කිරීමට ඔබට අවශ්‍ය නම් තවත් විකල්පයක් වන්නේ Maven Assembly ප්ලගිනයයි . එය ඉවත් කර සියල්ල ඩිරෙක්ටරියක් හරහා නැවත ඇසුරුම් කරයි <unpack>true</unpack>. එවිට ඔබට දෙවන වර්‍ගය ලැබෙනු ඇත, එය එක් දැවැන්ත JAR බවට පත් විය.

තවත් විකල්පයක් වන්නේ 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 පිහිටා ඇති නාමාවලිය වෙත කොන්සෝලය හරහා මාරු විය යුතුය. එවිට ඔබට mvn එකලස් කිරීම සිදු කළ යුතුය: තනි සහ පසුව පරායත්තතා සහිත ඔබේ ක්‍රියාත්මක කළ හැකි JAR ගොනුව බලාපොරොත්තු සහගතව ගොඩනඟනු ඇත. සමග ප්රතිදානය (ඉලක්කය) බහලුම වෙත මාරු විට ඔබ එය පරීක්ෂා කර ගත හැක cd ./target හා විධාන similiar ඔබේ භාජනයක් ආරම්භ ජාවා -jar mavenproject1-1.0-සැණරුව-භාජනයක්-සමග-dependencies.jar .

මම මෙය Apache Maven 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ඔබේ ක්‍රියාත්මක කළ හැකි භාජනයේ ප්‍රධාන පංතිය නියම කිරීමට වින්‍යාස කරන්න (පන්ති මාර්ගය සකසන්න , "භාජනය ක්‍රියාත්මක කළ හැකි කරන්න" යන පරිච්ඡේදය බලන්න ).

උදාහරණ සඳහා 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

3
ෂේඩ් ප්ලගිනයට දැන් මැනිෆෙස්ටයේ ප්‍රධාන පංතියේ ප්‍රවේශය නියම කිරීමේ ක්‍රමයක් ඇත: maven.apache.org/plugins/maven-shade-plugin/examples/…
චැඩ්වික්

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
ඇත්තෙන්ම හොඳයි! උත්පාදනය-සම්පත් අවධිය ඉවත් කිරීම සඳහා භාවිතා කිරීම වඩා හොඳ නොවේද?
nawroth

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 නොවේ) නම්, ඔබට මෙම පරායත්තතාවය ප්ලගීන කළමනාකරණ අංශයේ ඉහළම මව්පිය 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>

මෙය සිදු කිරීමෙන් පසු මෙම විධානය සමඟ MAVEN මෙවලම ධාවනය කිරීමට අමතක නොකරන්න mvn clean compile assembly: single

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


5

වෙනත් අය මීට පෙර සිදු කර ඇති ආකාරයට මම කෙලින්ම ප්‍රශ්නයට පිළිතුරු නොදෙනු ඇත, නමුත් ව්‍යාපෘතියේ භාජනයේම සියලු පරායත්තතාවයන් ඇතුළත් කිරීම හොඳ අදහසක් දැයි මම කල්පනා කරමි.

මම කාරණය දකිමි (යෙදවීමේ / භාවිතයේ පහසුව) නමුත් එය ඔබගේ විෂයය භාවිතා කිරීමේ අවස්ථාව මත රඳා පවතී (සහ විකල්ප තිබිය හැකිය (පහත බලන්න)).

ඔබ එය සම්පුර්ණයෙන්ම භාවිතා කරන්නේ නම්, එසේ නොකරන්නේ මන්ද?

නමුත් ඔබ ඔබේ ව්‍යාපෘතිය වෙනත් සන්දර්භයන්හි භාවිතා කරන්නේ නම් (වෙබ් ඇප් එකක මෙන් හෝ වෙනත් භාජන වාඩි වී ඇති ෆෝල්ඩරයක දමා ඇත), ඔබේ පන්ති මාවතේ භාජන අනුපිටපත් තිබිය හැකිය (ෆෝල්ඩරයේ ඇති ඒවා, භාජනවල ඇති). සමහර විට ලංසු ගනුදෙනුවක් නොවුනත් මම සාමාන්‍යයෙන් මෙය වළක්වන්නෙමි.

හොඳ විකල්පයක්:

  • ඔබගේ යෙදුම .zip / .war ලෙස යොදවන්න: සංරක්ෂිතයේ ඔබේ ව්‍යාපෘතියේ බඳුන සහ සියලු යැපෙන භාජන අඩංගු වේ;
  • ඔබේ ව්‍යාපෘතියේ තනි පිවිසුම් ස්ථානයක් ලබා ගැනීම සඳහා ගතික පන්ති පැටවුම් යාන්ත්‍රණයක් භාවිතා කරන්න (වසන්තය බලන්න, නැතහොත් ඔබට මෙය පහසුවෙන්ම කළ හැකිය) (ආරම්භ කිරීමට තනි පන්තියක් - වෙනත් පිළිතුරක මැනිෆෙස්ට් යාන්ත්‍රණය බලන්න), එය එකතු කරයි (ගතිකව) වත්මන් පංති මාර්ගය අනෙකුත් සියලුම අවශ්‍ය භාජන.

මේ හා සමානව, අවසානයේදී මැනිෆෙස්ට් සහ “විශේෂ ගතික පන්ති පැටවුම් ප්‍රධාන” සමඟින් ඔබට ඔබේ ව්‍යාපෘතිය ආරම්භ කළ හැක්කේ:

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

1
ව්‍යාපෘතියේ බඳුන සහ යැපෙන භාජන සියල්ල සංරක්ෂිතයට දමන්නේ කෙසේද?

4

විධාන රේඛාවෙන් ක්‍රියාත්මක කළ හැකි JAR එකක් සෑදීම සඳහා ව්‍යාපෘති මාර්ගයෙන් පහත විධානය ක්‍රියාත්මක කරන්න:

mvn assembly:assembly

4
මම හිතන්නේ ඔබට ලැබෙන දේවල් වලින් ඔබ තවමත් යම් යම් දේ කළ 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) එම JMX සේවාදායකය ආරම්භ, සහ ලැබෙන බව startහෝ stopපරාමිතිය. ඉතින් මේ සමඟ මගේ යෙදුම මේ ආකාරයෙන් ආරම්භ කිරීමට මට හැකි විය:

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

එය ඔබ සැමට ප්‍රයෝජනවත් වේ යැයි මම බලා සිටිමි.


3

මම මෙම ලිපියේ සඳහන් ගස් ප්ලගීන සංසන්දනය කළෙමි. මම භාජන 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>

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, මට වෙනස් ප්‍රති result ලයක් ලැබෙනු ඇත, නමුත් මම විධාන රේඛාවෙන් බඳුන ධාවනය කරන විට මට වෙනස් ප්‍රති result ලයක් ලැබේ (එය ක්‍රමලේඛ විශේෂිත ධාවන කාල දෝෂයක් සමඟ බිඳ වැටේ).

මගේ ව්‍යාපෘතිය සඳහා මට බොහෝ (මාවන්) පරායත්තතා තිබීම නිසා මට OP හා සමාන අවශ්‍යතාවයක් තිබුණි. වාසනාවකට මෙන්, මට වැඩ කළ එකම විසඳුම එය භාවිතා Eclipseකිරීමයි. ඉතා සරල හා ඉතා සරල ය. මෙය OP සඳහා විසඳුමක් නොවන නමුත් සමාන අවශ්‍යතාවයක් ඇති නමුත් බොහෝ මේවන් පරායත්තතා ඇති අයෙකුට විසඳුමකි,

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

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 හි වින්‍යාසය නොව පරායත්තතාවයේ දේපලකි.


2

දැනටමත් පිළිතුරු මිලියන ගණනක් ඇත, මට <mainClass>ඔබගේ යෙදුමට ඇතුළත් කිරීමේ ස්ථානය එක් කිරීමට අවශ්‍ය නැතිනම් ඔබට අවශ්‍ය නොවන බව එක් කිරීමට අවශ්‍ය විය. උදාහරණයක් ලෙස API වලට අනිවාර්යයෙන්ම mainක්‍රමයක් නොතිබිය හැකිය .

maven ප්ලගීන වින්‍යාසය

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

ඒක තමයි. මීලඟ mvn පැකේජය සියලු පරායත්ත භාජන ද ඇතුළුව එක් මේද භාජනයක් ද නිර්මාණය කරයි.


1

මේවන්-එකලස්-ප්ලගිනය මට හොඳට වැඩ කළා. මම මේවන්-යැපුම්-ප්ලගිනය සමඟ පැය ගණනක් ගත කළ අතර එය ක්‍රියාත්මක කිරීමට නොහැකි විය. ප්‍රධාන හේතුව වූයේ වින්‍යාස කොටසේ පැහැදිලිව නිර්වචනය කිරීමට සිදුවීම ලේඛනයේ විස්තර කර ඇති පරිදි ඇතුළත් කළ යුතු පුරාවස්තු අයිතමයි . ඔබට එය භාවිතා කිරීමට අවශ්‍ය අවස්ථාවන්හි උදාහරණයක් තිබේ : mvn dependency:copy, කිසිදු පුරාවස්තු අයිතමයක් ඇතුළත් කර නැති නමුත් එය ක්‍රියා නොකරයි.


1

මෙම බ්ලොග් සටහන මේවන්-ජාර් සහ මේවන්-එකලස් කිරීමේ ප්ලගීන ඒකාබද්ධ කිරීම සමඟ තවත් ප්‍රවේශයක් පෙන්වයි. බ්ලොග් පෝස්ට් එකෙන් එක්රැස් කිරීමේ වින්‍යාසය සමඟ පරායත්තතා පුළුල් වේ ද නැතිනම් ෆෝල්ඩරයක එකතු කර මැනිෆෙස්ටයේ පන්ති මාර්ග ප්‍රවේශයකින් යොමු කරනු ලැබේ ද යන්න පාලනය කළ හැකිය:

කදිම විසඳුම වන්නේ භාජන ලිබ් ෆෝල්ඩරයකට ඇතුළත් කිරීම සහ ප්‍රධාන භාජනයේ මැනිෆෙස්ට් එම්එෆ් ගොනුවට පන්ති පථයේ ඇති සියලුම භාජන ඇතුළත් කිරීමයි.

එය හරියටම මෙහි විස්තර කර ඇත: https://caffebig.wordpress.com/2013/04/05/executable-jar-file-with-dependent-jars-using-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 ගොනුව භාවිතා නොකරන බව. නමුත් මගේ ක්‍රමලේඛය නෙට්බීන්ස් මත සම්පාදනය කිරීම හා ක්‍රියාත්මක කිරීම පිළිබඳ ගැටළුව මට ඇති නමුත් මම ජාවා -ජාර් මයිජාර් ෆයිල්.ජාර් උත්සාහ කළ විට එය අසාර්ථක විය. දැන්, මට මේවන් සම්පූර්ණයෙන් නොතේරෙන අතර, මගේ භාජන ගොනුව පුස්තකාලයකට ඇතුළත් කිරීම සඳහා නෙට්බීන්ස් 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

ඒ හා සමාන ගැටලුවක් ඇති තවත් පිටු කිහිපයක මම මෙම විසඳුම පළ කරමි. බලාපොරොත්තු සුන් වූ සතියකින් මට යමෙකු බේරා ගත හැකි යැයි සිතමි.


2
ඔබ නෙට්බීන්ස් සමඟ නිර්මාණය කළ මාවන් ව්‍යාපෘතිය විවෘත කිරීමට උත්සාහ කරන්න. නෙට්බීන්ස් හි මූලික රීතිය සැමවිටම මාවන් ව්‍යාපෘතියක් නිර්මාණය කරන අතර කිසි විටෙකත් 'ජාවා යෙදුමක්' නොවේ. චාම් එකක් වගේ වැඩ කරනවා.
rjdkolb
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.