34 题: 如何使用Maven创建具有依赖关系的可执行JAR?

在...创建的问题 Thu, May 31, 2018 12:00 AM

我想将我的项目打包在一个可执行的JAR中进行分发。

如何让Maven项目将所有依赖JAR打包到我的输出JAR中?

    
2180
  1. 请解释您所指的依赖插件的目标。我知道没有做出原始问题请求的目标:将所有依赖项A)放入作者jar中通过重新打包,或者B)创建一个可执行jar,其他人在MANIFEST.MF的类路径中
    2009-03-11 15:11:50Z
  2. 你可能会发现这个有用的 rationaljava.com/2015/02 /...
    2015-02-02 19:01:54Z
  3. 2017-03-30 06:54:18Z
  4. 2017-09-11 08:18:16Z
  5. 醇>
    30答案                              30 跨度>                         
     
    <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>
    
        
    2128
    2013-02-21 08:37:32Z
    1. 谢谢@IAdapter。请注意,您应该事先进行编译,因为它只会在JAR中放置“target /classes”中的内容。这将确保JAR包含您最近对源代码所做的任何更改。所以,你应该做类似的事情:mvn clean compile assembly:single
      2011-05-31 19:03:33Z
    2. 我编辑了包含相位绑定的问题。我删除了已弃用的程序集目标,因为没有人需要了解它。
      2013-02-21 08:38:26Z
    3. 我看到这不会将jar添加到uber jar中,而只是将所有类文件添加到jar中。
      2015-04-07 16:31:12Z
    4. 提示:您还可以将元素<appendAssemblyId>false</appendAssemblyId>添加到configuration中,以避免名称
      中出现恼人的“-jar-with-dependencies”后缀
      2015-05-06 19:22:29Z
    5. 忘了compile而且你搞砸了。
      2016-11-13 00:44:06Z
    6. 醇>

    您可以使用dependency-plugin在包阶段之前在单独的目录中生成所有依赖项,然后将其包含在清单的类路径中:

     
    <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将所有jar文件集成到主jar中,但是你需要添加自定义类加载代码来加载jar。

        
    321
    2014-09-23 12:08:39Z
    1. + 1优秀。我使用maven-dependency-plugin而不是maven-assembly-plugin的原因是我还使用buildnumber-maven-plugin,这样我就可以将版本号分别存储在每个jar的清单中。 /DIV>
      2011-09-15 10:16:34Z
    2. 我喜欢你的解决方案。我使用${project.build.directory}/classes/lib作为outputDirectory有一个主要的.jar里面有所有依赖项,但是 - 如何添加自定义类加载代码来加载这个jar?我需要像以下那样执行工作:java -jar main-jar-with-deps.jar。这可能吗?
      2012-03-13 19:09:55Z
    3. @AndréAronsen,我用这个解决方案在jar里面的lib文件夹中添加依赖项,但是我总是得到类找不到异常,请你指教一下如何解决这个问题。
      2012-08-01 11:36:40Z
    4. + 1给你!!看起来像maven程序集插件'jar-with-dependencies'并不能很好地工作。我在生成的jar中错过了META-INF /spring.schemas中的一些条目。所以我废弃了依赖jar的jar并使用了上面的解决方案。非常感谢!!!
      2012-08-06 13:35:02Z
    5. 对于遇到此问题的其他人,您必须将jar文件夹包含在jar的同一目录中,然后将jar传输到。
      2014-10-25 11:13:42Z
    6. 醇>

    我在博客中介绍了一些不同的方法。

    请参阅使用Apache Maven的可执行文件夹(WordPress)

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

    备注

    这些优点和缺点由 Stephan 提供。


    用于手动部署

    • 赞成
    • 缺点
      • 依赖性不在最后一个罐子里。

    将依赖项复制到特定目录

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

    使Jar可执行文件和类路径感知

     
    <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),每个包含jarlib/*


    Apache Maven程序集插件

    • 赞成
    • 缺点
      • 没有类重定位支持(如果需要类重定位,请使用maven-shade-plugin)。
     
    <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>
      <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-行家-插件

    • 赞成
    • 缺点
      • 自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插件

    • 赞成
    • 缺点
      • 添加可能不必要的Spring和Spring Boot相关类。
     
    <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

        
    183
    2017-05-23 12:03:09Z
    1. 唯一适合我的是手动部署。
      2016-09-16 02:48:20Z
    2. @ caiohamamura你可以克隆 GitHub存储库,看看所有配置文件的工作原理。
      2016-09-16 11:58:07Z
    3. 问题在于我使用的软件包: stackoverflow.com/a /2548351分之12622037
      2016-09-17 01:48:06Z
    4. 以多种方式回答问题的最佳答案。
      2018-11-25 15:32:06Z
    5. 醇>

    采取未答复的答案并重新格式化,我们有:

     
    <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生命周期事件。但是,如果将它放在pom.xml中,则需要调用assembly:single目标,而如果从命令行手动执行它则调用'assembly:assembly'。

     
    <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>
    
        
    131
    2012-11-28 16:59:25Z
    1. 使用此答案中的方法会导致以下错误消息:'尝试运行时无法从&lt; jar文件&gt;'加载Main-Class清单属性JAR使用'java -jar&lt; jar文件&gt;'
      2010-09-10 11:37:57Z
    2. 需要存档部分maven-jar-plugin&lt; archive&gt; &LT;清单&GT; &LT; addClasspath&GT;真&LT; /addClasspath&GT; &LT; mainClass&GT; fully.qualified.MainClass&LT; /mainClass&GT; &LT; /清单&GT; &LT; /存档&GT;
      2011-11-16 14:40:09Z
    3. 对不起,这个答案是完全错误的,mainClass标签必须在maven-assembly-plugin条目上,因为你在包目标期间调用它
      2012-09-01 23:27:40Z
    4. @ AlexLehmann true!
      2012-11-22 13:24:58Z
    5. 我很惊讶,为什么不能在mvn archetype:generate命令之后将pom.xml包含在内?每次创建新的maven项目时,手动复制粘贴都会很烦人......
      2016-07-23 19:32:46Z
    6. 醇>

    使用maven-shade-plugin将所有依赖项打包到一个超级jar中。它还可以用于通过指定主类来构建可执行jar。在尝试使用maven-assembly和maven-jar之后,我发现这个插件最适合我的需求。

    我发现这个插件特别有用,因为它合并特定文件的内容而不是覆盖它们。当资源文件在jar中具有相同名称且插件尝试打包所有资源文件时,需要这样做

    见下面的例子

     
          <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>
    
        
    96
    2012-07-10 16:07:14Z
    1. 那么bcprov-jdk15.jar如何在运行时进入类路径,因为它已从着色过程中排除?
      2010-10-12 06:10:22Z
    2. 它被cxf-rt-ws-security所取代,这是我的依赖
      2010-10-18 22:58:11Z
    3. 之前从未听说过这个插件,但它解决了我在jar中使用spring.handlers的问题。谢谢!
      2011-03-26 16:02:20Z
    4. 获得安全异常的人,将DSA从Manifest中排除。查看 maven.apache.org/plugins/maven-shade -plugin /示例/...
      2011-07-19 07:41:53Z
    5. + 1我过去使用过minijar:ueberjar,但minijar插件现已弃用并被shade
      取代
      2011-12-08 12:39:03Z
    6. 醇>

    长期使用 maven程序集插件,但我无法找到问题的解决方案 "already added, skipping" 。现在,我正在使用另一个插件 - onejar-maven-plugin 。下面的例子(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>
    

    您需要为该插件添加存储库:

     
    <pluginRepositories>
        <pluginRepository>
            <id>onejar-maven-plugin.googlecode.com</id>
            <url>http://onejar-maven-plugin.googlecode.com/svn/mavenrepo</url>
        </pluginRepository>
    </pluginRepositories>
    
        
    19
    2017-05-23 11:33:24Z
    1. 如何摆脱输出中的额外消息?
      2016-04-08 12:33:45Z
    2. 醇>

    您可以使用maven-dependency-plugin,但问题是如何创建可执行JAR。要做到这一点,需要对Matthew Franglen的响应进行以下更改(顺便说一句,使用依赖插件从清洁目标开始时需要更长时间才能构建):

     
    <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>
    
        
    17
    2009-10-13 12:16:24Z

    如果你真的想在你的单个结果JAR中重新打包其他JAR内容,那么另一个选择就是 Maven Assembly插件。它解压缩然后通过<unpack>true</unpack>将所有内容重新打包到目录中。然后你会有第二遍将它构建成一个巨大的JAR。

    另一个选项是OneJar插件。这样就可以一步完成上述重新打包操作。

        
    15
    2009-03-11 15:20:35Z

    您可以将以下内容添加到 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 assembly:single ,然后有希望构建具有依赖项的可执行JAR文件。使用 cd ./target 切换到输出(目标)目录并使用类似于 java -jar mavenproject1-1.0-SNAPSHOT-jar-with-的命令启动jar时,可以检查它dependencies.jar 即可。

    我用 Apache Maven 3.0.3 测试了这个。

        
    13
    2011-08-13 18:23:43Z

    你可以结合使用maven-shade-pluginmaven-jar-plugin

    • maven-shade-plugin将您的类和所有依赖项打包在一个jar文件中。
    • 配置maven-jar-plugin以指定可执行jar的主类(请参阅设置类路径,“使Jar可执行”一章。)。

    maven-jar-plugin的示例POM配置:

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

    最后通过调用:

    创建可执行jar  
    mvn clean package shade:shade
    
        
    11
    2013-01-31 00:24:21Z
    1. Shade插件现在可以在清单中指定Main-Class条目: maven.apache.org/plugins/maven-shade-plugin/examples /...
      2012-02-27 21:35:40Z
    2. 醇>

    我经历了这些响应中的每一个,希望制作一个包含所有依赖项的胖可执行jar,但它们都没有正常工作。答案是阴影插件,它非常简单直接。

     
        <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

        
    11
    2015-11-23 22:04:39Z
    1. 当我修复此问题时,您是否介意更新您的评论。在发布之前我没有考虑过您的想法,并在看到您的评论后迅速做出修复
      2015-11-23 22:10:27Z
    2. plugin元素在pom.xml下进入build/plugins
      2017-12-24 01:54:36Z
    3. 醇>

    您可以使用maven-shade插件构建如下所示的超级jar

     
            <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>
    
        
    11
    2017-10-26 00:57:51Z
    1. 但那么如何将其部署到repo?
      2018-05-30 08:43:52Z
    2. 醇>

    Ken Liu在我看来是正确的。 maven依赖插件允许您扩展所有依赖项,然后您可以将其视为资源。这允许您将它们包含在工件中。使用程序集插件会创建一个难以修改的辅助工件 - 在我的情况下,我想添加自定义清单条目。我的pom最终成了:

     
    <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>
    
        
    9
    2009-09-09 13:37:43Z
    1. 非常好!使用generate-resources阶段进行解包不是更好吗?
      2013-08-08 11:58:19Z
    2. 醇>

    这是我们在Credit Karma使用的Maven的可执行jar插件。它创建了一个jar罐,其中包含一个能够从嵌套jar加载类的类加载器。这允许您在dev和prod中具有相同的类路径,并且仍然将所有类保存在单个签名的jar文件中。

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

    这是一篇博客文章,其中详细介绍了该插件以及我们制作插件的原因: https://engineering.creditkarma.com/一般工程/新可执行-JAR-插件可用的Apache-行家/

        
    9
    2016-10-14 16:47:48Z

    应该是这样的:

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

    解包必须处于生成资源阶段,因为如果处于打包阶段,则不会将其作为资源包含在内。 尝试清洁包装,你会看到。

        
    8
    2018-02-04 11:45:40Z

    使用 onejar插件将其构建为一个可执行jar包含所有依赖罐的文件。这解决了我的问题,与此类似。当使用程序集插件时,它将所有依赖jar解压缩到源文件夹中并将它们重新打包为jar,它已经覆盖了我在代码中具有相同类名的所有类似实现。 onejar是一个简单的解决方案。

        
    7
    2013-01-08 03:05:02Z

    使用maven-assembly-plugin-2.2.1找到共享程序集文件的问题?

    尝试使用descriptorId配置参数而不是descriptors /descriptor或descriptorRefs /descriptorRef参数。

    他们都没有做你需要的:在classpath上查找文件。 当然,您需要在maven-assembly-plugin的类路径中添加共享程序集所在的包(请参阅下文)。 如果您正在使用Maven 2.x(而不是Maven 3.x),则可能需要在pluginManagement部分的最顶级父pom.xml中添加此依赖项。

    请参阅了解更多详情。

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

    示例:

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

    我不会像其他人之前那样直接回答这个问题,但我真的很想知道将所有依赖项嵌入项目的jar本身是否是一个好主意。

    我看到了重点(易于部署/使用),但这取决于你的项目的用例(并且可能有替代方案(见下文))。

    如果您完全独立使用它,为什么不呢。

    但是如果您在其他环境中使用您的项目(例如在webapp中,或者放在其他罐子所在的文件夹中),您可能在类路径中有jar副本(文件夹中的那些,罐子中的那个) )。也许不是出价协议,但我通常会避免这种情况。

    一个很好的选择:

    • 将您的应用程序部署为.zip /.war:存档包含项目的jar和所有相关的jar;
    • 使用动态类加载器机制(请参阅Spring,或者您可以轻松地自己完成此操作)以获得项目的单个入口点(单个类开始 - 请参阅另一个答案的Manifest机制),这将添加(动态) )到当前的类路径所有其他需要的罐子。

    像这样,最后只有一个清单和一个“特殊的动态类加载器主”,你可以用:

    开始你的项目  
    java -jar ProjectMainJar.jar com.stackoverflow.projectName.MainDynamicClassLoaderClass
    
        
    5
    2009-12-28 16:43:35Z
    1. 如何将项目的jar和所有相关的jar放入存档中?
      2010-11-06 18:06:27Z
    2. 醇>

    要解决此问题,我们将使用Maven Assembly Plugin,它将JAR及其依赖项JAR创建到单个可执行JAR文件中。只需在pom.xml文件中添加以下插件配置即可。

     
    <build>
       <pluginManagement>
          <plugins>
             <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                   <archive>
                      <manifest>
                         <addClasspath>true</addClasspath>
                         <mainClass>com.your.package.MainClass</mainClass>
                      </manifest>
                   </archive>
                   <descriptorRefs>
                      <descriptorRef>jar-with-dependencies</descriptorRef>
                   </descriptorRefs>
                </configuration>
                <executions>
                   <execution>
                      <id>make-my-jar-with-dependencies</id>
                      <phase>package</phase>
                      <goals>
                         <goal>single</goal>
                      </goals>
                   </execution>
                </executions>
             </plugin>
          </plugins>
       </pluginManagement>
    </build>
    

    执行此操作后,不要忘记使用此命令运行MAVEN工具mvn clean compile assembly:single

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

        
    4
    2016-09-01 10:21:52Z

    如果你想要命令Line本身。只需从项目路径

    运行以下命令即可

    mvn assembly:assembly

        
    3
    2010-09-14 04:37:43Z
    1. 我认为你仍然需要在pom.xml中做一些事情,否则你会得到Error reading assemblies: No assembly descriptors found.。无论如何,这就是我发生的事情。
      2017-09-08 18:59:07Z
    2. 醇>

    你也可以使用这个插件,它非常好,我用它来包装我的罐子 http://sonatype.github.io/jarjar-maven-plugin/

        
    2
    2014-01-29 13:54:01Z

    对我有用的东西是:

     
      <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)maven-dependency-plugin在“prepare-package”阶段执行 2)我将解压缩的classess直接提取到“target /classes”

        
    2
    2014-03-15 15:47:14Z

    我在这里尝试了最多投票的答案,并且能够让jar可以运行。但程序运行不正常。我不知道原因是什么。当我尝试从Eclipse运行时,我得到了不同的结果,但是当我从命令行运行jar时,我得到了不同的结果(它因程序特定的运行时错误而崩溃)。

    我对OP有类似的要求,因为我的项目有太多(Maven)依赖项。幸运的是,唯一对我有用的解决方案是使用Eclipse。非常简单,非常简单。这不是OP的解决方案,但对于具有类似要求但具有许多Maven依赖性的人来说是一种解决方案,

    1)只需右键单击项目文件夹(在Eclipse中),然后选择Export

    2)然后选择Java - &gt; Runnable Jar

    3)将要求您选择jar文件的位置

    4)最后,选择具有您要运行的Main方法的类,然后选择Package dependencies with the Jar file并单击Finish

        
    2
    2014-10-10 22:11:18Z

    这是我找到的最佳方式:

     
      <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服务器,并接收startstop参数。因此,我能够启动我的应用程序像这样:

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

    我等你对大家都有用。

        
    2
    2015-09-30 17:22:48Z

    我比较了这篇文章中提到的树插件。我生成了2个罐子和一个包含所有罐子的目录。我比较了结果,绝对是maven-shade-plugin是最好的。我的挑战是我有多个需要合并的spring资源,以及jax-rs和JDBC服务。与maven-assembly-plugin相比,它们都被shade插件正确合并。在这种情况下,弹簧将失败,除非您将它们复制到您自己的资源文件夹并手动合并它们一次。两个插件都输出正确的依赖树。我有多个范围,如测试,提供,编译等测试和提供被两个插件跳过。他们都产生了相同的清单,但我能够使用他们的变压器使用阴影插件合并许可证。 使用maven-dependency-plugin当然没有这些问题,因为没有提取jar。但正如其他一些人指出的那样,你需要携带一个额外的文件才能正常工作。 这是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
    2016-02-24 18:12:01Z

    对于那些寻找从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
    2016-06-18 14:50:17Z

    已有数百万个答案,我想补充一点,如果您不需要将entryPoint添加到您的应用程序中,则不需要<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
    2016-09-29 23:27:04Z

    添加到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包还将创建一个fat jar,包括所有依赖jar。

        
    2
    2018-11-07 07:17:09Z

    maven-assembly-plugin对我很有用。 我花了几个小时使用maven-dependency-plugin并且无法使其工作。主要原因是我必须在配置部分明确定义应该包含的工件项,如文档。 当你想要使用它时,有一个例子:mvn dependency:copy,其中没有包含任何artifactItem但它不起作用。

        
    1
    2013-05-24 19:42:04Z

    这也可以是一个选项,您将能够构建您的jar文件

     
    <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
    2015-11-25 10:40:27Z
来源放置 这里