weixin_41568110
七度&光
采纳率22.2%
2009-02-22 08:43 阅读 568
已采纳

如何使用 Maven 创建具有依赖性的可执行 JAR?

I want to package my project in a single executable JAR for distribution.

How can I make a Maven project package all dependency JARs into my output JAR?

转载于:https://stackoverflow.com/questions/574594/how-can-i-create-an-executable-jar-with-dependencies-using-maven

  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 复制链接分享

30条回答 默认 最新

  • 已采纳
    csdnceshi56 lrony* 2013-02-21 08:37
    <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>
    

    and you run it with

    mvn clean compile assembly:single
    

    Compile goal should be added before assembly:single or otherwise the code on your own project is not included.

    See more details in comments.


    Commonly this goal is tied to a build phase to execute automatically. This ensures the JAR is built when executing mvn install or performing a deployment/release.

    <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>
    
    点赞 20 评论 复制链接分享
  • csdnceshi70 笑故挽风 2010-12-01 10:46

    You can use the dependency-plugin to generate all dependencies in a separate directory before the package phase and then include that in the classpath of the manifest:

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

    Alternatively use ${project.build.directory}/classes/lib as OutputDirectory to integrate all jar-files into the main jar, but then you will need to add custom classloading code to load the jars.

    点赞 30 评论 复制链接分享
  • csdnceshi50 三生石@ 2014-06-02 03:01

    I blogged about some different ways to do this.

    See Executable Jar with Apache Maven (WordPress)

    or executable-jar-with-maven-example (GitHub)

    Notes

    Those pros and cons are provided by Stephan.


    For Manual Deployment

    • Pros
    • Cons
      • Dependencies are out of the final jar.

    Copy Dependencies to a specific directory

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

    Make the Jar Executable and Classpath Aware

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

    At this point the jar is actually executable with external classpath elements.

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

    Make Deployable Archives

    The jar file is only executable with the sibling ...lib/ directory. We need to make archives to deploy with the directory and its content.

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

    Now you have target/${project.build.finalName}.(zip|tar|tar.bz2|tar.gz) which each contains the jar and lib/*.


    Apache Maven Assembly Plugin

    • Pros
    • Cons
      • No class relocation support (use maven-shade-plugin if class relocation is needed).
    <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>
    

    You have target/${project.bulid.finalName}-jar-with-dependencies.jar.


    Apache Maven Shade Plugin

    • Pros
    • Cons
    <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>
    

    You have target/${project.build.finalName}-shaded.jar.


    onejar-maven-plugin

    • Pros
    • Cons
      • Not actively supported since 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>
    

    Spring Boot Maven Plugin

    • Pros
    • Cons
      • Add potential unecessary Spring and Spring Boot related classes.
    <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>
    

    You have target/${project.bulid.finalName}-spring-boot.jar.

    点赞 27 评论 复制链接分享
  • csdnceshi79 python小菜 2009-02-26 04:31

    Taking Unanswered's answer and reformatting it, we have:

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

    Next, I would recommend making this a natural part of your build, rather than something to call explicitly. To make this a integral part of your build, add this plugin to your pom.xml and bind it to the package lifecycle event. However, a gotcha is that you need to call the assembly:single goal if putting this in your pom.xml, while you would call 'assembly:assembly' if executing it manually from the command line.

    <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>
    
    点赞 26 评论 复制链接分享
  • csdnceshi60 ℡Wang Yan 2009-09-09 13:37

    Ken Liu has it right in my opinion. The maven dependency plugin allows you to expand all the dependencies, which you can then treat as resources. This allows you to include them in the main artifact. The use of the assembly plugin creates a secondary artifact which can be difficult to modify - in my case I wanted to add custom manifest entries. My pom ended up as:

    <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>
    
    点赞 10 评论 复制链接分享
  • csdnceshi58 Didn"t forge 2011-11-26 14:17

    You could combine the maven-shade-plugin and maven-jar-plugin.

    • The maven-shade-plugin packs your classes and all dependencies in a single jar file.
    • Configure the maven-jar-plugin to specify the main class of your executable jar (see Set Up The Classpath, chapter "Make The Jar Executable").

    Example POM configuration for 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>
    

    Finally create the executable jar by invoking:

    mvn clean package shade:shade
    
    点赞 9 评论 复制链接分享
  • csdnceshi69 YaoRaoLov 2012-03-13 20:55

    Long used the maven assembly plugin, but I could not find a solution to the problem with "already added, skipping". Now, I'm using another plugin - onejar-maven-plugin. Example below (mvn package build jar):

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

    You need to add repository for that plugin:

    <pluginRepositories>
        <pluginRepository>
            <id>onejar-maven-plugin.googlecode.com</id>
            <url>http://onejar-maven-plugin.googlecode.com/svn/mavenrepo</url>
        </pluginRepository>
    </pluginRepositories>
    
    点赞 8 评论 复制链接分享
  • csdnceshi64 游.程 2013-05-24 19:42

    The maven-assembly-plugin worked great for me. I spent hours with the maven-dependency-plugin and couldn't make it work. The main reason was that I had to define in the configuration section explicitly the artifact items which should be included as it is described in the documentation. There is an example there for the cases when you want to use it like: mvn dependency:copy, where there are not included any artifactItems but it doesn't work.

    点赞 8 评论 复制链接分享
  • csdnceshi64 游.程 2014-10-10 22:11

    I tried the most up-voted answer here, and was able to get the jar runnable. But the program didn't run correctly. I do not know what the reason was. When I try to run from Eclipse, I get a different result but when I run the jar from command-line I get a different result (it crashes with a program-specific runtime error).

    I had a similar requirement as the OP just that I had too many (Maven) dependencies for my project. Fortunately, the only solution that worked for me was that using Eclipse. Very simple and very straightforward. This is not a solution to the OP but is a solution for someone who has a similar requirement but with many Maven dependencies,

    1) Just right-click on your project folder (in Eclipse) and select Export

    2) Then select Java -> Runnable Jar

    3) You will be asked to choose the location of the jar file

    4) Finally, select the class that has the Main method that you want to run and choose Package dependencies with the Jar file and click Finish

    点赞 8 评论 复制链接分享
  • csdnceshi66 必承其重 | 欲带皇冠 2010-09-22 15:20

    Use the maven-shade-plugin to package all dependencies into one uber-jar. It can also be used to build an executable jar by specifying the main class. After trying to use maven-assembly and maven-jar , I found that this plugin best suited my needs.

    I found this plugin particularly useful as it merges content of specific files instead of overwriting them. This is needed when there are resource files that are have the same name across the jars and the plugin tries to package all the resource files

    See example below

          <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>
    
    点赞 7 评论 复制链接分享
  • csdnceshi74 7*4 2009-03-11 15:12

    Another option if you really want to repackage the other JARs contents inside your single resultant JAR is the Maven Assembly plugin. It unpacks and then repacks everything into a directory via <unpack>true</unpack>. Then you'd have a second pass that built it into one massive JAR.

    Another option is the OneJar plugin. This performs the above repackaging actions all in one step.

    点赞 6 评论 复制链接分享
  • csdnceshi77 狐狸.fox 2011-08-13 18:23

    You can add the following to your 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>
    

    Afterwards you have to switch via the console to the directory, where the pom.xml is located. Then you have to execute mvn assembly:single and then your executable JAR file with dependencies will be hopefully build. You can check it when switching to the output (target) directory with cd ./target and starting your jar with a command similiar to java -jar mavenproject1-1.0-SNAPSHOT-jar-with-dependencies.jar.

    I tested this with Apache Maven 3.0.3.

    点赞 5 评论 复制链接分享
  • csdnceshi52 妄徒之命 2015-03-09 22:22

    This is the best way i 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>
    

    With this configuration, all dependencies will be located in /dependency-jars. My application has no Main class, just context ones, but one of my dependencies do have a Main class (com.myDomain.etc.MainClassName) that starts the JMX server, and receives a start or a stop parameter. So with this i was able to start my application like this:

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

    I wait it be useful for you all.

    点赞 5 评论 复制链接分享
  • csdnceshi55 ~Onlooker 2015-11-23 20:28

    I went through every one of these responses looking to make a fat executable jar containing all dependencies and none of them worked right. The answer is the shade plugin, its very easy and straightforward.

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

    Be aware that your dependencies need to have a scope of compile or runtime for this to work properly.

    This example came from mkyong.com

    点赞 5 评论 复制链接分享
  • weixin_41568131 10.24 2016-02-24 18:12

    I compared the tree plugins mentioned in this post. I generated 2 jars and a directory with all the jars. I compared the results and definitely the maven-shade-plugin is the best. My challenge was that I have multiple spring resources that needed to be merged, as well as jax-rs, and JDBC services. They were all merged properly by the shade plugin in comparison with the maven-assembly-plugin. In which case the spring will fail unless you copy them to your own resources folder and merge them manually one time. Both plugins output the correct dependency tree. I had multiple scopes like test,provide, compile, etc the test and provided were skipped by both plugins. They both produced the same manifest but I was able to consolidate licenses with the shade plugin using their transformer. With the maven-dependency-plugin of course you don't have those problems because the jars are not extracted. But like some other have pointed you need to carry one extra file(s) to work properly. Here is a snip of the 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>
    
    点赞 5 评论 复制链接分享
  • weixin_41568174 from.. 2016-09-29 23:27

    There are millions of answers already, I wanted to add you don't need <mainClass> if you don't need to add entryPoint to your application. For example APIs may not have necessarily have main method.

    maven plugin config

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

    build

    mvn clean compile assembly:single
    

    verify

    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/
    
    点赞 5 评论 复制链接分享
  • csdnceshi55 ~Onlooker 2017-10-26 00:57

    You can use maven-shade plugin to build a uber jar like below

            <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>
    
    点赞 5 评论 复制链接分享
  • csdnceshi78 程序go 2011-02-11 03:10

    Use onejar plugin to build it as one executable jar file which packages all the dependancy jars in it. That solved my problem which was similar to this. When assembly plugin was used, it unpacked all the dependancy jars into source folder and repackage them as a jar, it had over written all the similar implementations I had inside my code which were having the same class names. onejar is an easy solution in here.

    点赞 4 评论 复制链接分享
  • weixin_41568196 撒拉嘿哟木头 2016-09-01 10:21

    To resolve this issue we will use Maven Assembly Plugin that will create the JAR together with its dependency JARs into a single executable JAR file. Just add below plugin configuration in your pom.xml file.

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

    After doing this don’t forget to run MAVEN tool with this command mvn clean compile assembly:single

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

    点赞 4 评论 复制链接分享
  • csdnceshi79 python小菜 2016-10-14 16:47

    Here's an executable jar plugin for Maven that we use at Credit Karma. It creates a jar of jars with a classloader capable of loading classes from nested jars. This allows you to have the same classpath in dev and prod and still keep all classes in a single signed jar file.

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

    And here's a blog post with details about the plugin and why we made it: https://engineering.creditkarma.com/general-engineering/new-executable-jar-plugin-available-apache-maven/

    点赞 4 评论 复制链接分享
  • csdnceshi66 必承其重 | 欲带皇冠 2017-06-21 19:35

    Add to pom.xml:

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

    and

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

    Thats it. Next mvn package will also create one fat jar additionally, including all dependency jars.

    点赞 4 评论 复制链接分享
  • csdnceshi69 YaoRaoLov 2009-10-13 12:16

    You can use maven-dependency-plugin, but the question was how to create an executable JAR. To do that requires the following alteration to Matthew Franglen's response (btw, using the dependency plugin takes longer to build when starting from a clean target):

    <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>
    
    点赞 3 评论 复制链接分享
  • weixin_41568127 ?yb? 2009-12-28 16:43

    I won't answer directly the question as other have already done that before, but I really wonder if it's a good idea to embed all the dependencies in the project's jar itself.

    I see the point (ease of deployment / usage) but it depends of the use case of your poject (and there may be alternatives (see below)).

    If you use it fully standalone, why not.

    But if you use your project in other contexts (like in a webapp, or dropped in a folder where other jars are sitting), you may have jar duplicates in your classpath (the ones in the folder, the one in the jars). Maybe not a bid deal but i usually avoid this.

    A good alternative :

    • deploy your application as a .zip / .war : the archive contains your project's jar and all dependent jars ;
    • use a dynamic classloader mechanism (see Spring, or you can easily do this yourself) to have a single entry point of your project (a single class to start - see the Manifest mechanism on another answer), which will add (dynamically) to the current classpath all the other needed jars.

    Like this, with in the end just a manifest and a "special dynamic classloader main", you can start your project with :

    java -jar ProjectMainJar.jar com.stackoverflow.projectName.MainDynamicClassLoaderClass
    
    点赞 3 评论 复制链接分享
  • csdnceshi69 YaoRaoLov 2011-03-13 11:40

    Problem with locating shared assembly file with maven-assembly-plugin-2.2.1?

    Try using descriptorId configuration parameter instead of descriptors/descriptor or descriptorRefs/descriptorRef parameters.

    Neither of them do what you need: look for the file on classpath. Of course you need adding the package where the shared assembly resides on maven-assembly-plugin's classpath (see below). If you're using Maven 2.x (not Maven 3.x), you may need adding this dependency in top-most parent pom.xml in pluginManagement section.

    See this for more details.

    Class: org.apache.maven.plugin.assembly.io.DefaultAssemblyReader

    Example:

            <!-- 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>
    
    点赞 3 评论 复制链接分享
  • weixin_41568131 10.24 2014-01-29 13:54

    You can also use this plug-in, it is pretty good and I use it for packaging my jars http://sonatype.github.io/jarjar-maven-plugin/

    点赞 3 评论 复制链接分享
  • csdnceshi58 Didn"t forge 2010-03-05 15:39

    It should be like that:

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

    Unpacking have to be in generate-resources phase because, if in package phase, will not be included as resources. Try clean package and you'll see.

    点赞 2 评论 复制链接分享
  • weixin_41568131 10.24 2013-09-24 16:11

    Something that have worked for me was:

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

    I had extraordinary case because my dependency was system one:

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

    I have changed the code provided by @user189057 with changes: 1) maven-dependency-plugin is executed in "prepare-package" phase 2) I am extracting unpacked classess directly to "target/classes"

    点赞 2 评论 复制链接分享
  • csdnceshi61 derek5. 2010-09-14 04:37

    If you want if from command Line itself . Just run the below command from the project path

    mvn assembly:assembly

    点赞 1 评论 复制链接分享
  • csdnceshi70 笑故挽风 2015-11-25 10:40

    This could also be an option,You will be able to build your jar file

    <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>
    
    点赞 1 评论 复制链接分享
  • weixin_41568126 乱世@小熊 2016-05-03 08:09

    For anyone looking for options to exclude specific dependencies from the uber-jar, this is a solution that worked for me:

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

    So it's not a configuration of the mvn-assembly-plugin but a property of the dependency.

    点赞 1 评论 复制链接分享

相关推荐