JAVA生成（可执行）Jar包的全面详解说明[打包][SpringBoot][Eclips。。。

JAVA⽣成（可执⾏）Jar包的全⾯详解说明[打包][SpringBoot][Eclips。

⾟苦所得,转载还请注明:
得空整理了关于java 开发中,所有打包⽅式的⼀个操作⽅法, 有基于IDE的,有基于构建⼯具的.
这⾥还是⽐较建议新⼿朋友尽快习惯 maven 和 gradle 等构建⼯具⾃带的打包⽅式. 不是说逼格⾼,的确是因为不依赖 IDE, 配置好⼀两⾏命令就搞定. 离开IDE 照样出包.
⼤概分为这⼏个步骤
⼀. 关于Jar 包(example.jar) 的结构/作⽤/使⽤说明
⼆. 不依赖IDE和构建⼯具⽣成⼀个简单的 Jar 包
依赖编译器
三. 基于IDE( Eclipse /IDEA)⽣成 jar 包
四. 基于IDE( Eclipse /IDEA)⽣成可执⾏ jar 包
只依赖构建⼯具
五. 基于Maven ⽣成 Jar 包[第三⽅依赖包和代码⽂件放在⼀起, 为⼀个包] [fat-jar]
六. 基于Maven ⽣成 Jar 包[分离第三⽅依赖包, 独⽴存放在 *_libs 中][推荐]
七. 基于Gradle ⽣成 Jar 包 [第三⽅依赖包和代码⽂件放在⼀起, 为⼀个包] [fat-jar]
⼋. 基于Gradle ⽣成 Jar 包 [分离第三⽅依赖包, 独⽴存放在 *_libs 中]
注意事项:
1. 项⽬均为简单项⽬,不存在不懂得情况,代码相关废话不说;
2. 第三条中的项⽬,是⼀个简单的⼯具类集合.(就是把⼯具类打成⼀个JAR 包,⽅便其他项⽬使⽤,如我们使⽤的⼤多数第三⽅类库)
3. 第四五六七⼋条中的项⽬均为同⼀个简单的SpringBoot项⽬,构建⽅式不同⽽已\
本⽂⽤的jar包查看⼯具: JD-GUI.jar
使⽤⽅式:右键>打开⽅式> Java(TM) ...
官⽹: (JD-GUI的Tab栏有Download,⾥⾯提供独⽴版本,eclispe/idea插件版本)
⼀. 关于Jar 包(example.jar) 的详细说明
JAR(Java Archive File),Java 档案⽂件.通常jar 为压缩⽂件, 与 ZIP/RAR 压缩⽂件⼀样的概念,区别在于 jar ⽂件中存在⼀个名为META-INF/MANIFEST.MF 的清单⽂件,
关于JAR包的描述信息、启动时的配置信息和安全性信息等均保存在其中,可以理解为 jar 的⼀个'配置说明⽂件'
以spring-boot-starter-2.0.5.RELEASE.jar为例,⽤⼯具打开
⼀般都会存在⼀些属性,某些属性只是为了说明jar的信息,还有⼀些属性,时为能够让jar正常的执⾏⾥⾯类的功能,⽐如mysql 的 jar 包 :mysql-connector-java-8.0.11.jar ⾥⾯就⼀堆属性.
下⾯选⼏个⽤的到属性说⼀下,没有的参照官⽅⽂档:
基础属性:
Manifest-Version: ⽤来定义 manifest⽂件的版本，例如：Manifest-Version: 1.0
Created-By: 该⽂件的⽣成者，⼀般该属性是由jar命令⾏⼯具⽣成的，例如：Created-By: Apache Ant 1.8 .2
Signature-Version: 签名版本
Class-Path: 依赖项列表，若存在多个依赖项时则采⽤空格分隔。

依赖项路径为以JAR包路径为参考系的相对路径, 有个⼩细节就是, 如果⾃⼰⽣成这个⽂件,在引⽤了所有的以来后, 后⾯还有⼀个 '.', 对,⼀个点;可执⾏属性:
Main-Class: main函数所在的全限定类名,该类必须是⼀个可执⾏的类,可以侠义理解为存在 main()函数的类
⼀旦定义了此属性,即可通过 java -jar example.jar 来运⾏此jar包
⽆关紧要的属性,看看就⾏,⽤到了再找:
还有关于其他的jar的相关的:
说了这么多,意思就是这个⽂件挺重要的,有时候不能运⾏的时候,可以考虑检查⼀下jar包.
⼆. 不依赖IDE和构建⼯具⽣成⼀个简单的 Jar 包
这⾥我们以简单的demo做例⼦.
我们知道在所有的 *.java ⽂件都会经由JDK编译后⽣成⼀个相应的 *.class⽂件, 通常我们所使⽤的第三⽅类库,和我们所发布的代码⼀般都是 *.class⽂件.⽰例1: ExampleMain.java
Example.java
进⼊⽂件所在⽂件夹, ⿏标不选中⽂件,位于空⽩处, Shift+⿏标右键, 在此处打开CMD/PowerShell 窗⼝.(进⼊cmd , cd 命令切换到⽬录都可以)
在命令⾏中执⾏: javac ⽂件名.java即可将 *.java 编译为 *.class⽂件,如下图:
下⾯我们来说打包.
关于JDK中的打包命令在CMD中输⼊jar即可查看,如下图:
以我们上⾯创建的Example.* ExampleMain.* 为例:
切回上级 cn ⽬录,执⾏命令: jar cf example01.jar cn
我们来看⼀眼这个example01.jar ⾥⾯的东西:
cn中⽂件很好理解,因为我们编译完成本⾝就有4个⽂件,关于这个META-INF , 是打包时jdk⾃动加⼊进去的,⾥⾯保存了⼀些基础属性,关于这个⽂件有疑问可以去看上⾯那个写介绍jar包结构的.⼀个很简单的jar就完成了. 正常情况打包的时候,我们会删除 *.java , ⽤的是编译出的*.class ⽂件.
上⾯这个例⼦打出的jar包为"类库"概念的包,就是你可以导⼊使⽤,导⼊后,可以直接调⽤Example中的someMethod() ⽅法;
下⾯说可运⾏jar包
我们的ExampleMain 中包含了⼀个main()函数,即有⼀个程序⼊⼝. 我们知道关于jar包的META-INF⽂件夹jdk会⾃⼰⽣成,当然也可以⾃⼰指定.
在某个位置(只要你找得到)下新建⼀个mainfest 的⽂件(名字随你起),⾥⾯输⼊相关的属性信息:
这⾥指定了⼀个程序⼊⼝,就是我们说的Example.java 中的 main() ⽅法. 这⾥就需要⽤到jar 参数中的-m 参数,指定清单属性信息;
打包语句: jar cmf [mainfese⽂件] example02.jar [指定的*.class⽬录]
然后就可使⽤java-jar example02.jar 执⾏这个jar包,会输出我们前⾯编写的打印语句
请格外关注这个Class-Path:这个属性是依赖环境选项,最基础的可运⾏jar包都会存在这个属性,就好⽐运⾏程序需要JRE 环境⼀样.
⽐如我们的⼀个web应⽤, 会在这个地⽅引⼊所有的引⽤的第三⽅jar包.
另外,请格外注意这个 "点",就是Class-Path 后⾯这个点(".") .
三. 基于IDE ( Eclipse / IDEA) ⽣成 jar 包
四. 基于IDE ( Eclipse / IDEA) ⽣成可执⾏ jar 包
这两条放在⼀起说吧,因为都是依赖IDE的功能⽣成的,很⽅便,也不需要⼿动配置清单⽂件.
jar 包现在我们⼤致分为两类,⼀类为之提供"类库"的功能型包,⼀类为可运⾏的包(⼤多数情况的需求);
下⾯我们新建⼀个简单的springboot项⽬,因为是demo, 就利⽤springboot官⽹提供的在线快速⽣成⼯具了,当然也可以⾃⼰创建项⽬.
⼯具地址:
下⾯是具体的打包教程:
补充⼀点,如果打包时不需要把配置⽂件/静态⽂件打⼊jar包,Eclipse下可以把src/main/resources 右键Build Path> Remove就可以,IDEA 下在选择编译输出⽬录时取消resources 的勾选即可导⼊之后的⽂件⽬录结构:
他会⾃动⽣成程相关demo⽂件和配置⽂件,配置⽂件需要⾃⾏添加配置
我们简单写个配置和controller 测试
启动项⽬,浏览器访问:localhost:8080/demo, (缺省端⼝为8080) 浏览器会返回我们的测试数据,程序demo通过.
下⾯打包:
Eclipse:
⽅法:
项⽬上右键 > Export > 选择需要到处的jar包类型 (JAR file/ Runnable JAR file) > 填写相关信息 > Finish
“类库”型的选择: JAR file
可运⾏的选择 : Runnable JAR file
我们分别导出两种包做⽐较
第⼀种:⽆法启动,类似于”类库型的”
在到处界⾯选择Runnable JAR file (绝⼤多数的选择)
下⾯对⽐⼀下两个jar包
第⼀种”类库”⽅式导出的程序,只能提供给哦其他程序通过引⽤来使⽤相关的类功能,不能作为程序启动
第⼆种Runnable JAR file⽅式的, 可以看见在清单⽂件中,Claa-Type:中引⽤所有依赖的jar 包,同时拥有Main-Class 程序⼊⼝,可以在当前⽬录进⼊cmd 命令⾏,使⽤ java -jar *.jar来启动
附上第⼆种jar包的启动结果
IDEA:
利⽤项⽬的Artifacts (构建,蛮好⽤的功能)可以轻易实现这个功能, 他⾥⾯更多的是⼿动定制,⽐如指定mainfest 清单⽂件/输出的*.class ⽂件等.我们的两种jar都是基于这种⽅式.这⾥详细介绍可运⾏的⽅式,”类库”⼯具类性的⼀个道理,甚⾄更简单,取消⼀些的导出⽂件即可
⽅法:
菜单栏File > Project Structure(也可以使⽤快捷键 Ctrl+ Shift +Alt +S) > 配置好Artifacts 保存> 菜单栏Build > Build Artifacts > 然后点击操作
选择项⽬设置 Project Setting 下⾯的构建 Artifacts , 点击+号新建⼀个Artifacts
然后配置相关的构建属性
这⾥如果只是构建”类库”型的jar包,⼤可以选择第⼀种JAR包⽅式还简单⼀些
中途在配置相关属性的时候,需要注意两个问题:
1. IDEA的版本问题: 选择other 类型的构建时,导致不能在jar 包添加mainfest⽂件
2. 关于mainfest ⽂件的配置中 class-type: 他是不会添加⽂件夹前缀,可能需要⼿条件⼀下
配置好⼤概是这么个样⼦:
执⾏构建,输出jar包
然后选择我们相关 Artifac > build 即可.
然后就会在配置的输出⽬录内看到这个example-runnable.jar ⽂件了
结果如下:
下⾯4个⽅法,其实也是依赖⼯具的构建功能
五. 基于Maven ⽣成 Jar 包 [第三⽅依赖包和代码⽂件放在⼀起, 为⼀个包] [fat-jar]
优点: 简单,⽆脑
缺点: 包体积过于⼤,包含所有第三⽅依赖包和配置⽂件,每次更新内容过⼤
这个过于简单,不提供操作截图
⽅法: 在项⽬⽂件夹下进⼊命令⾏执⾏下⾯两条mvn 命令即可
mvn compile
mvn pakage
执⾏完毕之后会在 target ⽂件夹下⽣成⼀个 jar ,这个jar包含了所有的第三⽅依赖包,清单⽂件,我们的项⽬内容,⽤JD-GUI.jar ⼯具打开,就能看见所有结果⽂件,⼀⽬了然六. 基于Maven ⽣成 Jar 包 [分离第三⽅依赖包, 独⽴存放在 *_libs 中][推荐]
优点: 只需要在pom.xml配置, 然后配置⽂件/静态⽂件分离,主程序代码单独为⼀个jar包,更新⽅便推荐⽅式
缺点: 需要pom.xml 的maven 配置
关于pom.xml配置如下,需要点开+号查看
配置完成之后, 项⽬⽬录下执⾏,即可输出: mvn compile　mvn pakage
<build>
<sourceDirectory>src/main/java</sourceDirectory>
<finalName>example</finalName>
<resources>
<resource>
<directory>src/main/resources</directory>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
<include>**/*.jar</include>
</includes>
</resource>
</resources>
<plugins>
<!--编译-->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<fork>true</fork>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
<!--⽤以⽣成jar包的-->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.1.0</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
<configuration>
<!--区别于maven本⾝⽣成的构件，加上相关后缀-->
<classifier>release</classifier>
<!--排除的⽂件以及⽬录，这个是以class为当前⽬录的-->
<excludes>
<exclude>picture/**</exclude>
<exclude>mapper/**</exclude>
<exclude>**.yml</exclude>
<exclude>**.xml</exclude>
</excludes>
<archive>
<!--这⾥是添加当前⽬录到classpath的依赖-->
<manifestEntries>
<class-path>.</class-path>
</manifestEntries>
<manifest>
<addClasspath>true</addClasspath>
<!--这个就是清单⽂件中classpath的前缀配置,⽐如你把所有jar包放⼊example_lib⽂件夹中,这⾥就配置example_lib-->
<classpathPrefix>example_lib/</classpathPrefix>
<!--程序⼊⼝,main()所在⽂件的全限定类名-->
<mainClass>cn.lnexin.demo.ExampleApplication</mainClass>
<addDefaultImplementationEntries>true</addDefaultImplementationEntries>
<addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
</manifest>
</archive>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<executions>
<execution>
<id>copy-dependencies</id>
<phase>package</phase>
<goals>
<goal>
copy-dependencies
</goal>
</goals>
<configuration>
<!--第三⽅将jar要导出的⽂件路径-->
<outputDirectory>${project.build.directory}/toufang_lib</outputDirectory>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
详细的pom.xml 配置
关于Gradle的两种操作新开⼀篇⽂章,更新了会贴上链接
七. 基于Gradle ⽣成 Jar 包 [第三⽅依赖包和代码⽂件放在⼀起, 为⼀个包] [fat-jar]
⼋. 基于Gradle ⽣成 Jar 包 [分离第三⽅依赖包, 独⽴存放在 *_libs 中]。