核心概念：为什么需要打包？

当你用 Eclipse 编写 Java 程序时，它会生成一堆 .class 文件，这些文件是 Java 虚拟机（JVM）能理解的字节码，为了方便分发和运行，我们需要将这些文件以及项目依赖的其他库（.jar 文件）打包成一个单独的文件，最常见的就是 可执行的 JAR 文件。

一个可执行的 JAR 文件通常包含两部分：

1. 你的代码编译后的 .class 文件。
2. 一个特殊的 META-INF/MANIFEST.MF 文件，这个文件告诉 JVM 当你运行这个 JAR 时，应该从哪个 .class 文件的哪个 main 方法开始执行。

使用 Eclipse 的导出功能（最简单，适合初学者）

这是 Eclipse 内置的功能，图形化操作，非常直观，但不够灵活,适合没有复杂依赖的简单项目。

步骤：

1. 准备项目：确保你的项目已经成功编译（没有红色错误标记），一个标准的 Java 项目结构如下：

   
   （图片来源网络，侵删）

   MyProject/
   ├── src/
   │   └── com/
   │       └── example/
   │           └── Main.java  (包含 public static void main(String[] args) 方法)
   └── lib/  (如果依赖了第三方库，请放在这里)

2. 打开导出向导：

   • 在 Eclipse 的 Package Explorer（包资源管理器）中,右键点击你的项目。
   • 选择 Export... (导出...)。

3. 选择导出类型：

   • 在弹出的窗口中，展开 Java 文件夹，然后选择 JAR file。
   • 点击 Next。

4. 配置 JAR 文件选项：

   • Select the export destination：选择你想要生成的 JAR 文件存放的位置和名称（C:\Users\YourUser\Desktop\MyApp.jar）。
   • Select the resources to export：确保勾选了你的项目，通常默认就是你的整个项目，你可以展开项目，只选择你需要的 src 文件夹和 lib 文件夹（如果需要的话）。
   • Export generated class files and resources：默认勾选，表示导出编译后的 .class 文件。
   • Export source files：如果你想把源代码也一起打包,可以勾选上。
   • Export JAR file with the following options：这里是最关键的部分。
     • Override the manifest from a specified workspace file：这是指定主类的推荐方式。
       • 勾选此项。
       • 点击右侧的 Browse... 按钮，选择你项目中已经创建好的 MANIFEST.MF 文件（关于如何创建这个文件，见下面的“创建 MANIFEST.MF 文件”步骤）。
     • 或者，你也可以选择 Generate the manifest file，然后在下方的 Main class 字段中直接输入你的主类的完整路径（com.example.Main），Eclipse 会自动帮你生成 MANIFEST.MF。

5. 完成导出：

   • 点击 Finish，Eclipse 会在你指定的位置生成 JAR 文件。

如何运行生成的 JAR？ 打开命令行（CMD 或 PowerShell），进入到 JAR 文件所在的目录,然后运行：

java -jar MyApp.jar

创建 MANIFEST.MF 文件（方法一的补充）

在上一步中，我们需要一个 MANIFEST.MF 文件来指定主类,下面是如何创建它：

1. 在项目中创建文件夹：在项目的根目录下创建一个名为 META-INF 的文件夹（注意：全大写）。
2. 创建文件：在 META-INF 文件夹中，创建一个名为 MANIFEST.MF 的文本文件。
3. 编辑文件内容：用文本编辑器打开 MANIFEST.MF，输入以下内容：

   Manifest-Version: 1.0
   Main-Class: com.example.Main

   • Manifest-Version: 1.0 是固定的版本号。
   • Main-Class: com.example.Main 指定你的主类的完整路径（包名 + 类名）。
   • 注意：冒号后面有一个空格，并且文件末尾必须有一个空行,否则在某些系统上可能会解析失败。

使用 Maven 或 Gradle（行业标准，推荐用于复杂项目）

如果你的项目依赖很多（Spring, Hibernate 等），手动管理 JAR 文件会非常麻烦，使用构建工具（如 Maven 或 Gradle）是最佳实践，它们不仅能管理依赖，还能轻松地打包出可执行的 JAR。

使用 Maven (Maven Assembly Plugin)

1. 配置 pom.xml：确保你的项目是 Maven 项目，pom.xml 文件中已经正确配置了依赖。

2. 添加 Maven Assembly Plugin：在 pom.xml 的 <plugins> 标签内添加以下配置：

   <build>
       <plugins>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-assembly-plugin</artifactId>
               <version>3.6.0</version> <!-- 使用较新版本 -->
               <configuration>
                   <archive>
                       <manifest>
                           <mainClass>com.example.Main</mainClass>
                       </manifest>
                   </archive>
                   <descriptorRefs>
                       <descriptorRef>jar-with-dependencies</descriptorRef>
                   </descriptorRefs>
               </configuration>
               <executions>
                   <execution>
                       <id>make-assembly</id>
                       <phase>package</phase>
                       <goals>
                           <goal>single</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
       </plugins>
   </build>

   • <mainClass>: 指定你的主类。
   • <descriptorRef>jar-with-dependencies</descriptorRef>: 这是关键，它会告诉 Maven 创建一个包含所有项目依赖的“胖 JAR”（Fat JAR / Uber JAR）。

3. 执行打包命令：

   • 打开命令行，进入到项目根目录（包含 pom.xml 的目录）。
   • 运行以下命令：

     mvn clean package

   • 命令执行成功后，你会在 target 目录下找到两个 JAR 文件：
     • your-app-1.0-SNAPSHOT.jar: 普通的不带依赖的 JAR。
     • your-app-1.0-SNAPSHOT-jar-with-dependencies.jar: 你需要的、包含了所有依赖的“胖 JAR”。

如何运行？ 直接运行“胖 JAR”即可：

java -jar target/your-app-1.0-SNAPSHOT-jar-with-dependencies.jar

使用 Gradle (Shadow Plugin)

1. 配置 build.gradle：确保你的项目是 Gradle 项目。

2. 添加 Shadow Plugin：在 build.gradle 文件中添加插件和配置。

   plugins {
       id 'java'
       id 'application' // 应用插件，可以方便地指定主类
       id 'com.github.johnrengelman.shadow' version '8.1.1' // Shadow 插件
   }
   group = 'com.example'
   version = '1.0-SNAPSHOT'
   repositories {
       mavenCentral()
   }
   dependencies {
       // 在这里添加你的依赖，
       // implementation 'org.slf4j:slf4j-api:1.7.36'
   }
   application {
       mainClass = 'com.example.Main' // 指定主类
   }
   // Shadow 插件会自动创建一个 fat JAR
   shadowJar {
       archiveBaseName.set('my-app') // 生成的 JAR 文件名
       archiveVersion.set('1.0')     // 版本号
       archiveClassifier.set('')     // 移除默认的 "all" 后缀
   }

3. 执行打包命令：

   • 打开命令行，进入到项目根目录（包含 build.gradle 的目录）。
   • 运行以下命令：

     gradle shadowJar

   • 命令执行成功后，你会在 build/libs 目录下找到名为 my-app-1.0.jar 的“胖 JAR”。

如何运行？

java -jar build/libs/my-app-1.0.jar

总结与对比

强烈建议：从学习 Maven 或 Gradle 开始，它们是现代 Java 开发的基石，虽然初期有一定学习成本,但长期来看会为你节省大量的时间和精力。