Maven/Gradle/ 手动打包：Java 程序打包的完整步骤

将 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 等工具。