战争遗产合集绿色中文版
1.59G · 2025-11-10
在开始具体打包之前，我们先了解下主流的Java打包工具及其适用场景：
| 工具 | 适用场景 | 特点 | 输出格式 |
|---|---|---|---|
| javac + jar | 简单学习项目 | JDK内置，无需额外配置 | JAR |
| Maven | 企业级项目 | 强大的依赖管理和生命周期 | JAR, WAR |
| Gradle | 复杂大型项目 | 灵活配置，构建性能高 | JAR, WAR, 多种格式 |
| Spring Boot Maven Plugin | Spring Boot应用 | 内嵌服务器，开箱即用 | Executable JAR |
| jpackage | 桌面应用程序 | 生成原生安装包 | EXE, DMG, DEB |
| Docker | 微服务部署 | 环境隔离，持续交付 | Docker Image |
一个标准的Java项目结构如下：
MyApp/
├── src/
│ └── com/example/
│ ├── Main.java
│ └── util/
│ └── StringUtil.java
├── lib/ (第三方依赖)
└── resources/ (配置文件)
对于简单的项目，我们可以使用JDK自带的工具手动打包：
# 1. 编译Java源代码
javac -d build/classes src/com/example/**/*.java
# 2. 创建清单文件(MANIFEST.MF)
cat > MANIFEST.MF << EOF
Manifest-Version: 1.0
Main-Class: com.example.Main
Created-By: Java Packager
EOF
# 3. 打包成JAR文件
jar cfm myapp.jar MANIFEST.MF -C build/classes .
# 4. 运行应用
java -jar myapp.jar
为了提高效率，我们可以编写构建脚本：
#!/bin/bash
# build.sh - Java项目自动构建脚本
echo " 开始构建Java项目..."
# 清理构建目录
rm -rf build
mkdir -p build/classes
# 编译源码
echo " 编译Java源码..."
javac -d build/classes -sourcepath src src/com/example/**/*.java
# 拷贝资源文件
echo " 拷贝资源文件..."
cp -r resources/* build/classes/
# 创建清单文件
echo " 生成清单文件..."
cat > MANIFEST.MF << EOF
Manifest-Version: 1.0
Main-Class: com.example.Main
Class-Path: $(find lib -name "*.jar" | tr 'n' ' ')
Build-Time: $(date)
EOF
# 打包JAR
echo " 打包JAR文件..."
jar cfm myapp.jar MANIFEST.MF -C build/classes .
# 清理临时文件
rm MANIFEST.MF
echo " 构建完成！输出文件: myapp.jar"
Maven是Java领域最流行的构建工具，提供了标准化的项目结构和构建流程。
project/
├── pom.xml
├── src/
│ ├── main/
│ │ ├── java/ (Java源代码)
│ │ │ └── com/example/
│ │ │ ├── Main.java
│ │ │ └── service/
│ │ └── resources/ (资源文件)
│ │ ├── application.properties
│ │ └── log4j2.xml
│ └── test/ (测试代码)
│ └── java/
└── target/ (构建输出目录)
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!-- 项目坐标 -->
<groupId>com.example</groupId>
<artifactId>myapp</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
<properties>
<!-- 统一版本管理 -->
<java.version>11</java.version>
<maven.compiler.version>3.8.1</maven.compiler.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.17.1</version>
</dependency>
</dependencies>
<build>
<plugins>
<!-- 编译器插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>${maven.compiler.version}</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.2.2</version>
<configuration>
<archive>
<manifest>
<mainClass>com.example.Main</mainClass>
<addClasspath>true</addClasspath>
<classpathPrefix>lib/</classpathPrefix>
</manifest>
</archive>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-assembly-plugin</artifactId>
<version>3.3.0</version>
<configuration>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
<archive>
<manifest>
<mainClass>com.example.Main</mainClass>
</manifest>
</archive>
</configuration>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.2.4</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<transformers>
<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<mainClass>com.example.Main</mainClass>
</transformer>
<!-- 处理Spring配置文件 -->
<transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
<resource>META-INF/spring.handlers</resource>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
# 清理并打包
mvn clean package
# 跳过测试打包
mvn clean package -DskipTests
# 安装到本地仓库
mvn clean install
# 生成源码包和文档
mvn source:jar javadoc:jar
# 运行Spring Boot应用
mvn spring-boot:run
对于Web应用，我们需要打包成WAR格式部署到Servlet容器。
webapp/
├── pom.xml
├── src/
│ └── main/
│ ├── java/
│ │ └── com/example/
│ │ ├── controller/
│ │ ├── service/
│ │ └── config/
│ ├── resources/
│ └── webapp/ (Web资源)
│ ├── WEB-INF/
│ │ └── web.xml
│ ├── index.jsp
│ └── static/
│ ├── css/
│ ├── js/
│ └── images/
<!-- 修改打包方式为war -->
<packaging>war</packaging>
<build>
<finalName>mywebapp</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>3.3.1</version>
<configuration>
<!-- 对于Spring Boot可以忽略web.xml -->
<failOnMissingWebXml>false</failOnMissingWebXml>
<warSourceDirectory>src/main/webapp</warSourceDirectory>
</configuration>
</plugin>
</plugins>
</build>
@SpringBootApplication
public class Application extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
return application.sources(Application.class);
}
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
<!-- 排除内嵌Tomcat，使用外部容器 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
Gradle以其简洁的DSL和出色的性能受到越来越多开发者的青睐。
plugins {
id 'java'
id 'application'
}
group = 'com.example'
version = '1.0.0'
sourceCompatibility = '11'
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web:2.7.0'
testImplementation 'org.springframework.boot:spring-boot-starter-test:2.7.0'
}
application {
mainClass = 'com.example.Main'
}
// 使用Shadow插件创建胖JAR
plugins {
id 'com.github.johnrengelman.shadow' version '7.1.2'
}
shadowJar {
archiveBaseName.set('myapp')
archiveClassifier.set('')
archiveVersion.set('')
mergeServiceFiles()
}
// 或者自定义任务
task customFatJar(type: Jar) {
manifest {
attributes 'Main-Class': 'com.example.Main'
}
archiveBaseName = 'myapp-all'
from {
configurations.runtimeClasspath.collect {
it.isDirectory() ? it : zipTree(it)
}
}
with jar
duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}
# 构建项目
./gradlew build
# 创建胖JAR
./gradlew shadowJar
# 清理构建
./gradlew clean
# 运行应用
./gradlew run
容器化部署已经成为现代应用部署的标准方式。
# 第一阶段：构建阶段
FROM maven:3.8.4-openjdk-11 AS builder
WORKDIR /app
# 拷贝pom文件并下载依赖（利用Docker缓存）
COPY pom.xml .
RUN mvn dependency:go-offline
# 拷贝源码并构建
COPY src ./src
RUN mvn clean package -DskipTests
# 第二阶段：运行阶段
FROM openjdk:11-jre-slim
WORKDIR /app
# 创建非root用户（安全考虑）
RUN groupadd -r spring && useradd -r -g spring spring
USER spring
# 从构建阶段拷贝JAR文件
COPY --from=builder /app/target/*.jar app.jar
# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3
CMD curl -f http://localhost:8080/actuator/health || exit 1
# JVM参数优化
ENV JAVA_OPTS="-Xmx512m -Xms256m -XX:+UseG1GC -Djava.security.egd=file:/dev/./urandom"
# 暴露端口
EXPOSE 8080
# 启动命令
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]
version: '3.8'
services:
app:
build: .
ports:
- "8080:8080"
environment:
- SPRING_PROFILES_ACTIVE=prod
- DATABASE_URL=jdbc:mysql://db:3306/myapp
depends_on:
- db
networks:
- app-network
deploy:
resources:
limits:
memory: 512M
reservations:
memory: 256M
db:
image: mysql:8.0
environment:
MYSQL_ROOT_PASSWORD: rootpass
MYSQL_DATABASE: myapp
volumes:
- db_data:/var/lib/mysql
networks:
- app-network
volumes:
db_data:
networks:
app-network:
driver: bridge
# 构建镜像
docker build -t myapp:1.0.0 .
# 运行容器
docker run -d -p 8080:8080 --name myapp myapp:1.0.0
# 使用Docker Compose
docker-compose up -d
# 查看日志
docker logs -f myapp
# 进入容器调试
docker exec -it myapp bash
# 创建跨平台安装包
jpackage
--name MyApp
--input target/
--main-jar myapp-1.0.0.jar
--main-class com.example.Main
--type app-image
--dest installers/
--java-options '-Xmx256m'
# Windows特定选项
jpackage --type exe --win-console --icon app.ico
# macOS特定选项
jpackage --type dmg --mac-package-identifier com.example.myapp
# Linux特定选项
jpackage --type deb --linux-package-name myapp
FROM ghcr.io/graalvm/native-image:22 AS builder
WORKDIR /app
COPY . .
RUN mvn clean package -DskipTests
# 构建原生镜像
RUN native-image -jar target/myapp-1.0.0.jar
--no-fallback
--enable-https
-H:Name=myapp-native
# 运行阶段
FROM alpine:latest
RUN apk --no-cache add libstdc++
COPY --from=builder /app/myapp-native /app/myapp-native
EXPOSE 8080
ENTRYPOINT ["/app/myapp-native"]
<!-- 统一版本管理 -->
<properties>
<java.version>11</java.version>
<maven.compiler.version>3.8.1</maven.compiler.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
# 使用轻量级基础镜像
FROM openjdk:11-jre-slim
# 优化JVM参数
ENV JAVA_OPTS="-XX:+UseContainerSupport -XX:MaxRAMPercentage=75.0"
name: Java CI/CD Pipeline
on:
push:
branches: [ main ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Set up JDK 11
uses: actions/setup-java@v2
with:
java-version: '11'
distribution: 'temurin'
cache: 'maven'
- name: Build and Test
run: mvn clean package
- name: Build Docker Image
run: docker build -t myapp:${{ github.sha }} .
- name: Deploy to Registry
run: |
echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
docker push myapp:${{ github.sha }}
Java项目打包已经从简单的JAR文件发展到现代化的容器化部署。掌握这些打包技术对于Java开发者至关重要。无论是传统的Web应用还是现代的微服务，选择合适的打包方式都能大大提高开发和部署效率。
希望本文能为您提供全面的Java项目打包指导！如有任何问题，欢迎大家在评论区分享你的想法！！！
