java打包可运行的jar包

ing-bootjava打包java package 

整理了下各种打包可执行jar的方法，个人而言，觉得使用spring-boot插件更方便，且生成的jar包也更精简，推荐使用

 

方法一：使用maven-jar-plugin插件

Xml代码   

1. <plugin>  
2.    <groupId>org.apache.maven.plugins</groupId>  
3.    <artifactId>maven-jar-plugin</artifactId>  
4.    <version>2.6</version>  
5.    <configuration>  
6.       <archive>  
7.          <manifest>  
8.             <!--将依赖的jar添加到classpath，具体效果查看生成jar里的META-INF/MANIFEST.MF的Class-Path-->  
9.             <addClasspath>true</addClasspath>  
10.             <!--classpath路径前缀，如lib/log4j.jar-->  
11.             <classpathPrefix>lib/</classpathPrefix>  
12. <!--程序入口类-->  
13.             <mainClass>cn.qlt.service.UserService</mainClass>  
14.          </manifest>  
15.       </archive>  
16.    </configuration>  
17. </plugin>  
18. <!--该插件用于将依赖jar复制到指定文件夹-->  
19. <plugin>  
20.    <groupId>org.apache.maven.plugins</groupId>  
21.    <artifactId>maven-dependency-plugin</artifactId>  
22.    <executions>  
23.       <execution>  
24.          <id>copy</id>  
25.          <!--将该操作绑定在compile周期中-->  
26.          <phase>compile</phase>  
27.          <goals>  
28.            <goal>copy-dependencies</goal>  
29.          </goals>  
30.          <configuration>  
31.             <outputDirectory>  
32.             <!--复制的ar包存放的目录,以下路径即target/lib-->  
33.              ${project.build.directory}/lib  
34.             </outputDirectory>  
35.          </configuration>  
36.       </execution>  
37.    </executions>  
38. </plugin>  

 

运行:mvn clean package

会在target目录下生成一个可执行的jar包与存放依赖的lib文件夹，将生成的jar包与lib文件夹放入同一目录下，执行 java -jar XXX.jar即可

说明：

1、依赖的jar包与程序不能打入一个jar包，这样最终部署的时候还得程序jar与依赖的jar包同时部署，比较麻烦

2、通过设置outputDirectory:${project.build.directory}/classes/lib也做到了将依赖与程序打入一个jar，但最终运行总是找不到依赖的jar。尝试了许多次均宣告失败。若有知道用该插件将依赖与程序打为一个jar的相关配置，烦劳告知，谢谢

 

方法二：使用maven-assembly-plugin插件

 

Xml代码   

1. <plugin>  
2.                 <groupId>org.apache.maven.plugins</groupId>  
3.                 <artifactId>maven-assembly-plugin</artifactId>  
4.                 <version>2.5.5</version>  
5.                 <configuration>  
6.                     <archive>  
7.                         <manifest>  
8.                             <mainClass>cn.qlt.service.UserService</mainClass>  
9.                         </manifest>  
10.                     </archive>  
11.                     <descriptorRefs>  
12.                         <!--引用id为jar-with-dependencies的一个descriptor文件，该文件为该插件预先写好的文件。在.m2\repository\org\apache\maven\plugins\maven-assembly-plugin\2.5.5文件夹，解压maven-assembly-plugin-2.5.5.jar，在assemblies文件夹里可查看该文件-->  
13.                         <descriptorRef>jar-with-dependencies</descriptorRef>  
14.                     </descriptorRefs>  
15.                 </configuration>  
16.                 <executions>  
17.                     <execution>  
18.                         <id>make-assembly</id>  
19.                         <phase>package</phase>  
20.                         <goals>  
21.                             <goal>single</goal>  
22.                         </goals>  
23.                     </execution>  
24.                 </executions>  
25.             </plugin>  

 

 

 
 说明：通过上述方法即可生成可执行的jar包，但其将依赖的jar包都解压了，即我们看到的都是一个个文件夹与class文件，这样从管理等方面都不是很友好。

 

上面说过jar-with-dependencies其实是一个id为jar-with-dependencies的xml文件，下面就是我们自定义这种xml文件的方法。

Xml代码   

1. <plugin>  
2.             <groupId>org.apache.maven.plugins</groupId>  
3.             <artifactId>maven-assembly-plugin</artifactId>  
4.             <version>2.5.5</version>  
5.             <executions>  
6.                 <execution>  
7.                     <id>make-assembly</id>  
8.                     <phase>package</phase>  
9.                     <goals>  
10.                         <goal>single</goal>  
11.                     </goals>  
12.                     <configuration>  
13.                     <!--若为true，则在生成的jar名称后面追加assembly.xml文件中我们定义的id-->  
14.                     <appendAssemblyId>false</appendAssemblyId>  
15.                     <descriptors>  
16.                         <!--自定义的xml文件-->  
17.                         <descriptor>assembly.xml</descriptor>  
18.                     </descriptors>  
19.                     <archive>  
20.                         <manifest>  
21.                             <mainClass>cn.qlt.service.UserService</mainClass>  
22.                         </manifest>  
23.                     </archive>  
24.                     </configuration>  
25.                 </execution>  
26.             </executions>  
27.         </plugin>    

 assembly.xml：

Xml代码   

1. <assembly  
2.     xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.     xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2 http://maven.apache.org/xsd/assembly-1.1.2.xsd">  
5.     <id>distribution</id>  
6.     <!-- 如果为true，会将文件打入以项目ArtifactId为名的文件夹内-->  
7.     <includeBaseDirectory>false</includeBaseDirectory>  
8.     <formats>  
9.         <!--打包类型-->  
10.         <format>jar</format>  
11.     </formats>  
12.     <fileSets>  
13.         <fileSet>  
14.                         <!--将指定目录中文件打包到下面定义目录，这里为classes目录-->  
15.             <directory>${project.build.outputDirectory}</directory>  
16.             <outputDirectory>/</outputDirectory>  
17.         </fileSet>  
18.     </fileSets>  
19.     <dependencySets>  
20.         <dependencySet>  
21.                        <!--若为true，则将依赖解压，即我们看到的是文件夹和class文件 -->  
22.             <unpack>false</unpack>  
23.             <!--是否将当前项目的非执行jar包打入依赖-->   
24.                         <useProjectArtifact>false</useProjectArtifact>  
25.                          <!--依赖的输出地址-->  
26.                  <outputDirectory>/lib</outputDirectory>  
27.         </dependencySet>  
28.     </dependencySets>  
29. </assembly>  

 通过这种方式，我们将依赖与我们的程序都打入一个jar包了，但java -jar运行程序的时候，依赖的类都是notfound，是不是因为没有添加到classpath，不知道怎么解决。在MANIFEST.MF中配置Class-Path只能配置当前jar包外面的路径，因依赖jar已打入jar包，不知如何配置

 

方法三：使用maven-shade-plugin插件

 

Xml代码   

1. <plugin>  
2.     <groupId>org.apache.maven.plugins</groupId>  
3.     <artifactId>maven-shade-plugin</artifactId>  
4.     <version>2.4.1</version>  
5.     <configuration>  
6.         <transformers>  
7.             <transformer          
8.                 implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">  
9. <!--设置入口类-->              <mainClass>cn.qlt.service.UserService</mainClass>  
10.             </transformer>  
11.         </transformers>  
12.     </configuration>  
13.     <executions>  
14.         <execution>  
15.                         <!--绑定在maven的package生命周期上-->  
16.             <phase>package</phase>  
17.             <goals>  
18.                 <goal>shade</goal>  
19.             </goals>  
20.         </execution>  
21.     </executions>  
22. </plugin>   

 

运行:mvn clean package，会在target目录里生成xxx-shaded.jar,运行该jar即可

 

说明：

1、和上面maven-assembly-plugin插件一样，通过该方法生成的可运行jar文件，将我们依赖的jar包都解压了，即我们看到的是一个个的文件夹与class，这对于我们的管理十分的不方便

2、如果想去掉生成的jar文件名的后缀shaded或者改一个名字，在<configuration></configuration>中增加<shadedArtifactAttached>false</shadedArtifactAttached>或<shadedClassifierName>自定义的ClassifierName</shadedClassifierName>即可

 

方法四：使用spring-boot插件（建议）

maven：

Xml代码   

1. <plugin>  
2.         <groupId>org.springframework.boot</groupId>  
3.         <artifactId>spring-boot-maven-plugin</artifactId>  
4.         <version>1.2.5.RELEASE</version>  
5.         <executions>  
6.             <execution>  
7.                 <goals>  
8.                     <goal>repackage</goal>  
9.                 </goals>  
10.                 <configuration>  
11.                     <!--非必填项，即在生成的jar包名称后面追加该分类名称-->  
12.                     <classifier>boot</classifier>  
13.                     <mainClass>cn.qlt.service.UserService</mainClass>  
14.                 </configuration>  
15.             </execution>  
16.         </executions>  
17. </plugin>   

 

 

运行mvn clean package即可。该方法将依赖与我们自己的程序打入同意jar包。且依赖jar没有解压放入lib文件夹下。通过jar -jar运行没有出现依赖找不到的情况。

 

说明：

若出现以下异常：[ERROR] Failed to execute goal org.springframework.boot:spring-boot-maven-plugin:1.2.5.RELEASE:repackage (default) on project maven-service: Execution default of goal org.springframework.boot:spring-boot-maven-plugin:1.2.5.RELEASE:repackage failed: For artifact {cn.qlt:maven-service:0.0.1-SNAPSHOT:jar}: An attached artifact must have a different ID than its corresponding main artifact

 

请检查是否在spring-boot-maven-plugin插件中配置了finalname，若配置了该属性，请同时配置classifier。因为若不配置classifier且又设置了finalname导致了同一group和artifact中出现了两个jar包(我们生成的可执行的jar和普通的jar)，这样maven就不知道用哪个了

 

gradle：

Java代码   

1. buildscript {  
2.     //引入spring-boot-gradle插件  
3.     dependencies {  
4.         classpath("org.springframework.boot:spring-boot-gradle-plugin:1.0.0.RC1")  
5.     }  
6. }  
7. //使用spring-boot插件  
8. apply plugin: 'spring-boot'  
9.   
10. springBoot {  
11.         //配置入口类  
12.         mainClass = "main.Zone"  
13. }  

 

 

以上就是整理的打包可执行程序方法。若哪位兄弟知道其他更好的方法或者有好的建议，劳烦提出，谢谢