Java程序打包常见几种方式的完整步骤(Maven/Gradle/ 手动打包)

前言

将 Java 程序打包成可执行文件或分发包的方式，取决于你的项目类型（普通 Java 项目、Maven/Gradle 项目）和需求（是否需要跨平台、是否包含依赖等）。以下是几种常见的打包方法：

一、基础方法：使用javac+jar命令手动打包（适合简单项目）

如果是不含第三方依赖的简单 Java 项目，可通过 JDK 自带工具手动打包：

1. 编译 Java 源码假设项目结构如下：

   plaintext

   myapp/
   └── src/
       └── com/
           └── example/
               └── Main.java  // 主类，含 main 方法
   

   编译生成 class 文件：

   bash

   # 进入 src 目录的父级
   cd myapp
   # 编译所有 .java 文件，输出到 classes 目录
   javac -d classes src/com/example/Main.java
   

2. 创建 MANIFEST.MF 文件用于指定主类（可执行 JAR 必需），在 classes 目录下创建 META-INF/MANIFEST.MF：

   plaintext

   Manifest-Version: 1.0
   Main-Class: com.example.Main  # 主类全限定名（包名+类名）
   

3. 打包成 JAR 文件

   bash

   # 进入 classes 目录
   cd classes
   # 打包当前目录下的所有文件为 myapp.jar
   jar cfm ../myapp.jar META-INF/MANIFEST.MF .
   

4. 运行 JAR 文件

   bash

   java -jar myapp.jar
   

二、Maven 项目打包（推荐，适合带依赖的项目）

如果使用 Maven 管理项目，可通过 maven-jar-plugin 或 maven-assembly-plugin 打包：

1. 配置 pom.xml在 pom.xml 中添加打包插件（以包含所有依赖为例）：

   xml

   <build>
       <plugins>
           <!-- 指定主类 -->
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-jar-plugin</artifactId>
               <version>3.3.0</version>
               <configuration>
                   <archive>
                       <manifest>
                           <mainClass>com.example.Main</mainClass>  <!-- 主类全限定名 -->
                       </manifest>
                   </archive>
               </configuration>
           </plugin>
           
           <!-- 打包所有依赖到一个 JAR 中（fat jar） -->
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-assembly-plugin</artifactId>
               <version>3.4.2</version>
               <configuration>
                   <descriptorRefs>
                       <descriptorRef>jar-with-dependencies</descriptorRef>
                   </descriptorRefs>
                   <archive>
                       <manifest>
                           <mainClass>com.example.Main</mainClass>
                       </manifest>
                   </archive>
               </configuration>
               <executions>
                   <execution>
                       <id>make-assembly</id>
                       <phase>package</phase>
                       <goals>
                           <goal>single</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
       </plugins>
   </build>
   

2. 执行打包命令

   bash

   mvn clean package
   

   打包结果在 target 目录下：

   • myapp-1.0-SNAPSHOT.jar：仅包含项目自身代码的 JAR
   • myapp-1.0-SNAPSHOT-jar-with-dependencies.jar：包含所有依赖的可执行 JAR（推荐运行这个）

3. 运行打包后的 JAR

   bash

   java -jar target/myapp-1.0-SNAPSHOT-jar-with-dependencies.jar
   

三、Gradle 项目打包（适合带依赖的项目）

Gradle 项目可通过 application 插件或 shadow 插件打包：

1. 配置 build.gradle（或 build.gradle.kts）

   groovy

   plugins {
       id 'java'
       id 'application'  // 用于生成可执行脚本
       id 'com.github.johnrengelman.shadow' version '7.1.2'  // 用于打 fat jar
   }
   
   mainClassName = 'com.example.Main'  // 主类全限定名
   
   // 配置 shadow 插件（可选，生成包含依赖的 JAR）
   shadowJar {
       archiveBaseName = 'myapp'
       archiveVersion = '1.0'
       archiveClassifier = 'all'
   }
   

2. 执行打包命令

   bash

   # 生成包含依赖的 fat jar
   gradle shadowJar
   # 或生成可执行脚本（Windows 为 .bat，Linux 为 .sh）
   gradle installDist
   

3. 运行打包结果

   • Fat jar：java -jar build/libs/myapp-1.0-all.jar
   • 可执行脚本：build/install/myapp/bin/myapp（Linux）或 build/install/myapp/bin/myapp.bat（Windows）

四、打包成 EXE 或原生应用（适合 Windows 桌面程序）

如果需要将 Java 程序打包成 Windows 可执行文件（.exe），可使用第三方工具：

1. Launch4j

   • 功能：将 JAR 包包装成 EXE，支持指定 JRE 版本、图标等。
   • 步骤：
     1. 下载 Launch4j 并安装
     2. 配置「Input file」为你的 JAR 路径，「Output file」为生成的 EXE 路径
     3. 配置「JRE」选项（如最小版本），点击「Build wrapper」生成 EXE

2. Excelsior JET

   • 功能：将 Java 字节码编译为原生机器码（.exe），不依赖 JRE，启动更快。
   • 适合商业项目（免费版有功能限制）。

五、打包注意事项

1. 依赖管理

   • 简单项目：手动复制依赖 JAR 到指定目录，运行时通过 -cp 指定类路径。
   • 复杂项目：优先使用 Maven/Gradle 的 fat jar 功能，避免依赖缺失。

2. 主类指定

   • 可执行 JAR 必须在 MANIFEST.MF 中指定 Main-Class，否则需通过 java -cp jar包 主类名 运行。

3. JRE 依赖

   • 打包后的 JAR 或 EXE 仍需目标机器安装对应版本的 JRE（除非使用 Excelsior JET 等工具编译为原生代码）。

4. 资源文件

   • 确保项目中的资源文件（如配置文件、图片）被正确打包到 JAR 中，读取时使用 getClass().getResourceAsStream() 方法。

根据项目复杂度选择合适的方法：简单项目用 jar 命令，依赖较多的项目用 Maven/Gradle，需原生 EXE 则用 Launch4j 等工具。

到此这篇关于Java程序打包常见几种方式(Maven/Gradle/ 手动打包)的文章就介绍到这了,更多相关Java程序打包内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

最新评论