前提

Maven可以使用mvn package指令对项目进行打包，如果使用 java -jar xxx.jar 执行jar文件，可能会出现”no main manifest attribute, in xxx.jar”（没有设置Main-Class）、ClassNotFoundException（找不到依赖包）等错误。
要想jar包能直接通过java -jar xxx.jar运行，需要满足：

  1. 在jar包中的META-INF/MANIFEST.MF中指定Main-Class，这样才能确定程序的入口在哪里
  2. 要能加载到依赖包

Maven 有多种方式可以生成能直接运行的 jar 包，可以根据需要选择。

方式一

方式一：使用maven-jar-plugin和maven-dependency-plugin插件打包：
在pom.xml中配置：

  1. <build>  
  2.     <plugins>  
  3.         <plugin>  
  4.             <groupId>org.apache.maven.plugins</groupId>  
  5.             <artifactId>maven-jar-plugin</artifactId>  
  6.             <version>3.2.0</version> 
  7.             <!-- 对jar包进行配置 -->
  8.             <configuration>  
  9.                 <archive>  
  10.                     <!--生成的jar中，不要包含pom.xml和pom.properties这两个文件-->
  11.               <addMavenDescriptor>false</addMavenDescriptor>
  12.                     <manifest>  
  13.                         <!--是否要把第三方jar放到manifest的classpath中-->
  14.                         <addClasspath>true</addClasspath>  
  16.                         <!--生成的manifest中classpath的前缀，
  17.                       因为要把第三方jar放到lib目录下，
  18.                       所以classpath的前缀是lib/
  19.       -->
  20.                         <classpathPrefix>lib/</classpathPrefix>  
  22.                         <!-- jar包执行主类入口 -->
  23.                         <mainClass>com.wqc.main.SpringStart</mainClass>  
  24.                     </manifest>  
  25.                 </archive>  
  26.             </configuration>  
  27.         </plugin>  
  28.         <plugin>  
  29.             <groupId>org.apache.maven.plugins</groupId>  
  30.             <artifactId>maven-dependency-plugin</artifactId>  
  31.             <version>2.8</version>  
  32.             <executions>  
  33.                 <execution>  
  34.                     <id>copy-dependencies</id>  
  35.                     <phase>package</phase>  
  36.                     <goals>  
  37.                         <goal>copy-dependencies</goal>  
  38.                     </goals>  
  39.                     <configuration>  
  40.                         <outputDirectory>
  41.                             ${project.build.directory}/lib
  42.                         </outputDirectory>  
  43.                     </configuration>  
  44.                 </execution>  
  45.             </executions>  
  46.         </plugin>  
  47.     </plugins>  
  48. </build>
  • maven-jar-plugin用于生成META-INF/MANIFEST.MF文件的部分内容，com.xxg.Main指定MANIFEST.MF中的Main-Class，true会在MANIFEST.MF加上Class-Path项并配置依赖包，lib/指定依赖包所在目录
  • maven-dependency-plugin插件用于将依赖包拷贝到${project.build.directory}/lib指定的位置，即lib目录下。配置完成后，通过mvn package指令打包，会在target目录下生成jar包，并将依赖包拷贝到target/lib目录下
  • 缺点：生成的jar包太多不易于管理

方式二

方式二：使用maven-assembly-plugin插件打包
pom.xml中配置：

  1. <build>  
  2.     <plugins>  
  3.         <plugin>  
  4.             <groupId>org.apache.maven.plugins</groupId>  
  5.             <artifactId>maven-assembly-plugin</artifactId>  
  6.             <version>3.3.0</version>  
  7.             <configuration>  
  8.                 <archive>  
  9.                     <manifest>  
  10.                         <mainClass>com.wqc.main.SpringStart</mainClass>  
  11.                     </manifest>  
  12.                 </archive>  
  13.                 <descriptorRefs>  
  14.                     <descriptorRef>jar-with-dependencies</descriptorRef>  
  15.                 </descriptorRefs>  
  16.             </configuration>  
  17.             <executions>  
  18.                 <execution>  
  19.                     <id>make-assembly</id>  
  20.                     <phase>package</phase>  
  21.                     <goals>  
  22.                         <goal>single</goal>  
  23.                     </goals>  
  24.                 </execution>  
  25.             </executions>  
  26.         </plugin>  
  27.     </plugins>  
  28. </build>


方法三

在pom.xml中配置：

  1. <build>  
  2.     <plugins>  
  3.         <plugin>  
  4.             <groupId>org.apache.maven.plugins</groupId>  
  5.             <artifactId>maven-shade-plugin</artifactId>  
  6.             <version>2.4.1</version>  
  7.             <executions>  
  8.                 <execution>  
  9.                     <phase>package</phase>  
  10.                     <goals>  
  11.                         <goal>shade</goal>  
  12.                     </goals>  
  13.                     <configuration>  
  14.                         <transformers>  
  15.                             <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">  
  16.                                 <mainClass>com.wqc.main.SpringStart</mainClass>  
  17.                             </transformer>  
  18.                         </transformers>  
  19.                     </configuration>  
  20.                 </execution>  
  21.             </executions>  
  22.         </plugin>  
  23.     </plugins>  
  24. </build>

配置完成后，执行mvn package即可打包。在target目录下会生成两个jar包，注意不是original-xxx.jar文件，而是另外一个。和maven-assembly-plugin一样，生成的jar文件包含了所有依赖，所以可以直接运行。

  • 如果项目中用到了Spring Framework，将依赖打到一个jar包中，且运行时会出现读取XML schema文件出错。原因是Spring Framework的多个jar包中包含相同的文件spring.handlers和spring.schemas，如果生成一个jar包会互相覆盖。为了避免互相影响，可以使用AppendingTransformer来对文件内容追加合并：
    1. <build>  
    2.   <plugins>  
    3.       <plugin>  
    4.           <groupId>org.apache.maven.plugins</groupId>  
    5.           <artifactId>maven-shade-plugin</artifactId>  
    6.           <version>2.4.1</version>  
    7.           <executions>  
    8.               <execution>  
    9.                   <phase>package</phase>  
    10.                   <goals>  
    11.                       <goal>shade</goal>  
    12.                   </goals>  
    13.                   <configuration>  
    14.                       <transformers>  
    15.                           <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">  
    16.                               <mainClass>com.xxg.Main</mainClass>  
    17.                           </transformer>  
    18.                           <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">  
    19.                               <resource>META-INF/spring.handlers</resource>  
    20.                           </transformer>  
    21.                           <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">  
    22.                               <resource>META-INF/spring.schemas</resource>  
    23.                           </transformer>  
    24.                       </transformers>  
    25.                   </configuration>  
    26.               </execution>  
    27.           </executions>  
    28.       </plugin>  
    29.   </plugins>  
    30. </build>
    这样生成的jar包就只有两个了，mavenpackage-1.0.0-shaded.jar合并到了mavenpackage-1.0.0.jar中去了