我怎样才能创build一个使用Maven的依赖关系的可执行JAR？

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

我如何使Maven将所有依赖JAR包装到我的JAR中？

Answer 1

<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 

编译目标应该在汇编之前添加：单独或否则您自己的项目上的代码不包括在内。

在评论中看到更多细节。

---

通常这个目标与一个构build阶段相关联，以便自动执行。 这可以确保在执行mvn install或执行部署/释放时构buildJAR。

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

Answer 2

您可以使用依赖插件在包阶段之前生成一个单独目录中的所有依赖项，然后将其包含在清单的类path中：

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

Answer 3

以未回答的答案和重新格式化，我们有：

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

接下来，我build议将它作为构build的一个自然部分，而不是明确地调用。 为了使它成为你构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> 

Answer 4

我博客了一些不同的方式来做到这一点。

请参阅使用Apache Maven的可执行文件夹 （WordPress）

或可执行jar-with-maven-example （GitHub）

笔记

这些优点和缺点是由斯蒂芬提供的。

---

对于手动部署

• 优点
• 缺点
  • 依赖关系不在最后一个jar子里。

将依赖关系复制到特定的目录

 <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子可执行和类path知道

 <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实际上是用外部类path元素执行的。

 $ 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/* 。

---

Apache Maven Assembly插件

• 优点
• 缺点
  • 没有class级重新定位支持（如果需要class级重新定位，请使用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

• 优点
• 缺点

 <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的插件

• 优点
• 缺点
  • 自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 。

Answer 5

使用maven-shade-plugin将所有依赖关系打包成一个超级jar文件。 它也可以用来通过指定主类来构build可执行的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 - ie 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> 

Answer 6

你可以使用maven-dependency-plugin，但问题是如何创build一个可执行的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> 

Answer 7

长期使用的Maven的组装插件 ，但我找不到"already added, skipping"的问题的解决scheme。 现在，我正在使用另一个插件 – 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> 

Answer 8

如果你真的想重新包装你的单个合成JAR内的其他JAR内容的另一个select是Maven Assembly插件 。 它解包，然后通过<unpack>true</unpack>所有东西重新打包到一个目录中。 然后你会有第二遍把它build成一个巨大的JAR。

另一个select是OneJar插件 。 这一步完成了上述的重新包装操作。

Answer 9

您可以将以下内容添加到您的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程序集：single ，然后你的可执行JAR文件将会被依赖。 使用cd ./target切换到输出（目标）目录时，可以用类似于 java -jar mavenproject1-1.0-SNAPSHOT-jar-with-dependencies.jar的命令启动jar。

我用Apache Maven 3.0.3testing了这个。

Answer 10

你可以结合maven-shade-plugin和maven-jar-plugin 。

• maven-shade-plugin将你的类和所有的依赖关系打包在一个jar文件中。
• configurationmaven-jar-plugin以指定可执行jar的主类（请参见设置类path ，“使jar可执行”一章）。

maven-jar-plugin示例POMconfiguration：

  <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 

Answer 11

这里是我们在Credit Karma中使用的Maven的可执行jar插件。 它创build了一个jar子的jar包与类加载器能够从嵌套jar装载类。 这使您可以在dev和prod中拥有相同的类path，并将所有类保留在单个签名的jar文件中。

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

这里有一篇关于插件的细节的博客文章，以及为什么我们做了这个： https ： //engineering.creditkarma.com/general-engineering/new-executable-jar-plugin-available-apache-maven/

Answer 12

肯刘在我看来是对的。 Maven依赖项插件允许您展开所有依赖项，然后您可以将其视为资源。 这可以让你把它们包含在主神器中。 使用程序集插件会创build一个辅助工件，这很难修改 – 在我的情况下，我想添加自定义清单条目。 我的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> 

Answer 13

我经历了每一个这些反应，看起来像一个胖的可执行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

Answer 14

它应该是这样的

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

拆包必须在生产资源阶段，因为如果在包装阶段，将不被包括为资源。 尝试清洁包，你会看到

Answer 15

使用onejar插件将其构build为一个可执行的jar文件，该文件打包所有的依赖性jar文件。 这解决了我的问题，这是类似的。 当使用程序集插件时，它将所有的依赖性jar包解压缩到源文件夹中，并将它们重新打包为一个jar文件，结果写在我的代码中的所有类似的实现中，它们具有相同的类名。 onejar在这里是一个简单的解决scheme。

Answer 16

用maven-assembly-plugin-2.2.1查找共享程序集文件的问题？

尝试使用descriptorIdconfiguration参数而不是descriptor / descriptor或descriptorRefs / descriptorRef参数。

他们都没有做你所需要的：寻找类path上的文件。 当然，你需要在maven-assembly-plugin的类path中添加共享程序集所在的程序包（见下文）。 如果您使用的是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> 

Answer 17

我不会像以前那样直接回答这个问题，但是我真的想知道是否将所有依赖项embedded到项目的jar本身中是一个好主意。

我明白了这一点（易于部署/使用），但是取决于你的项目的用例（可能有替代scheme（见下文））。

如果你完全独立使用它，为什么不呢。

但是，如果您在其他上下文中使用您的项目（如在Web应用程序中，或者放在其他jar子所在的文件夹中），则可能会在您的类path中存在jar副本（文件夹中的jar副本）。 也许不是一个出价交易，但我通常避免这一点。

一个好的select：

• 将应用程序部署为.zip / .war：压缩文件包含项目的jar和所有依赖的jar;
• 使用dynamic类加载器机制（请参阅Spring，或者您可以自己轻松地完成此操作）拥有项目的单个入口点（单个类即可启动 – 请参阅另一个答案上的Manifest机制），该机制将（dynamic）添加到当前类path所有其他需要的jar子。

像这样，最后只是一个清单和一个“特殊的dynamic类加载器主”，你可以通过以下方式启动你的项目：

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

Answer 18

如果你想从命令行本身。 只需从项目path运行下面的命令

mvn程序集：程序集

Answer 19

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

Answer 20

有些为我工作的是：

  <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）我将解压后的类直接解压到“target / classes”

Answer 21

这是我发现的最好的方法：

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

有了这个configuration，所有的依赖关系都将位于/dependency-jars 。 我的应用程序没有Main类，只是上下文类，但是我的一个依赖项有一个启动JMX服务器的Main类（ com.myDomain.etc.MainClassName ），并接收一个start或stop参数。 所以，我可以像这样开始我的应用程序：

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

我等着它对大家有用。

Answer 22

maven-assembly-plugin为我工作得很好。 我花了几个小时的Maven的依赖插件，并不能使其工作。 主要原因是我必须在configuration部分中明确定义文档中应该包含的工件项目。 有一个例子，当你想使用它的情况下，如： mvn dependency:copy ，其中没有包括任何artifactItems，但它不起作用。

Answer 23

我在这里尝试了最多的答案，并能够运行jar。 但程序没有正确运行。 我不知道是什么原因。 当我尝试从Eclipse运行时，我得到了一个不同的结果，但是当我从命令行运行该jar时，我得到了一个不同的结果（它崩溃与程序特定的运行时错误）。

我和OP有类似的要求，只是我的项目有太多的（Maven）依赖关系。 幸运的是，唯一的解决scheme是使用Eclipse 。 非常简单，非常简单。 这不是OP的解决scheme，但是对于有类似需求但有许多Maven依赖的人来说，这是一个解决scheme，

1）只需右键单击您的项目文件夹（在Eclipse中），然后selectExport

2）然后selectJava – > Runnable Jar

3）您将被要求selectjar文件的位置

4）最后，select要运行Main方法的类，然后Package dependencies with the Jar fileselectPackage dependencies with the Jar file然后单击Finish

Answer 24

这也可以是一个选项，你将能够build立你的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> 

Answer 25

我比较了这篇文章中提到的树插件。 我生成了2个jar子和一个包含所有jar子的目录。 我比较了结果，绝对是maven-shade-plugin是最好的。 我的挑战是我有多个需要合并的spring资源，以及jax-rs和JDBC服务。 与maven-assembly-plugin相比，它们都被阴影插件合并了。 在这种情况下，弹簧将会失败，除非将它们复制到自己的资源文件夹并手动合并一次。 两个插件都输出正确的依赖关系树。 我有多个范围testing，提供，编译等testing和提供被两个插件跳过。 他们都制作了相同的清单，但我能够使用变压器合并灯罩插件的许可证。 有了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> 

Answer 26

为了解决这个问题，我们将使用Maven Assembly Plugin，它将创buildJAR和它的依赖JAR到一个可执行的JAR文件中。 只需在你的pom.xml文件中添加下面的插件configuration。

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

做完这个之后不要忘记用这个命令mvn clean compile assembly运行MAVEN工具：single

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

Answer 27

添加到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包也会创build一个胖jar包，包括所有的依赖jar。

Answer 28

你可以使用maven-shade插件来构build一个像下面这样的超级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> 

Answer 29

这篇博客文章展示了另一种结合maven-jar和maven-assembly插件的方法。 使用博客文章中的程序集configurationxml，如果依赖关系将被展开或者仅仅被收集到一个文件夹中并且被清单中的类path条目引用，那么它也可以被控制：

理想的解决scheme是将jar包括在lib文件夹中，主jar的manifest.mf文件包含classpath中的所有jar。

正是这个描述在这里： https : //caffebig.wordpress.com/2013/04/05/executable-jar-file-with-dependent-jars-using-maven/

Answer 30

好的，这是我的解决scheme。 我知道这不是使用pom.xml文件。 但是我遇到了我的程序在Netbeans上编译和运行的问题，但是当我尝试使用Java -Jar MyJarFile.jar时，它失败了。 现在，我不完全理解Maven，我想这是为什么有困难让Netbeans 8.0.2将我的jar文件包含在一个库中，把它们放入一个jar文件。 我在考虑如何在Eclipse中使用没有Maven的jar文件。

Maven可以编译所有的依赖和插件。 不是Netbeans。 （如果你可以得到Netbeans，并能够使用Java .jar来做到这一点，请告诉我如何（^。^）v）

[解决 – 对于Linux]通过打开一个terminal。

然后

 cd /MyRootDirectoryForMyProject 

下一个

 mvn org.apache.maven.plugins:maven-compiler-plugin:compile 

下一个

 mvn install 

这将在目标目录中创buildjar文件。

 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

我将在其他几个页面上发布这个解决scheme，并解决类似的问题。 希望我能从一周的挫折中拯救一个人。