java

Java 工程化构建：Maven 多模块与 Gradle 深度优化

深入解析 Maven 与 Gradle 在 Java 工程化中的核心能力，涵盖多模块聚合、依赖管理、生命周期插件、增量构建、配置缓存及 CI/CD 集成，助你打造高性能、可维护的企业级构建流水线。

Leeting Yan 2026-09-01 7 分钟阅读 3031 字

在 Java 企业级开发中，构建工具的选择与配置直接决定了团队协作效率、发布节奏与项目可维护性。Maven 与 Gradle 作为当前两大主流构建工具，在多模块管理、依赖治理、生命周期编排、增量构建与 CI/CD 集成等领域各有优势。本文从 POM 继承到 Gradle 配置缓存，从生命周期插件到远程构建缓存，全方位拆解 Java 工程化构建的核心技术点。

1. Maven POM 继承与依赖管理

Maven 的继承机制通过 <parent> 标签实现父子 POM 的级联复用，统一 JDK 版本、编码规范、依赖版本与插件配置。

<!-- 父POM：pom.xml -->
<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>

    <!-- 父POM的packaging必须是pom -->
    <groupId>com.example</groupId>
    <artifactId>parent-pom</artifactId>
    <version>2.1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <!-- 全局属性：JDK版本、编码、版本号 -->
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring-boot.version>3.2.0</spring-boot.version>
        <lombok.version>1.18.30</lombok.version>
    </properties>

    <!-- 依赖版本集中管理 -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
                <scope>provided</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.11.0</version>
                    <configuration>
                        <!-- 保留方法参数名 -->
                        <compilerArgs><arg>-parameters</arg></compilerArgs>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

子模块通过 <parent> 声明继承关系：

<!-- 子模块：service-core/pom.xml -->
<project xmlns="http://maven.apache.org/POM/4.0.0"
         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>

    <parent>
        <groupId>com.example</groupId>
        <artifactId>parent-pom</artifactId>
        <version>2.1.0-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>

    <artifactId>service-core</artifactId>

    <dependencies>
        <!-- 版本号从父POM的dependencyManagement继承 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
</project>

<relativePath> 默认为 ../pom.xml，若父 POM 不在标准位置需显式指定。

2. Maven 多模块聚合与 dependencyManagement

多模块聚合通过父 POM 的 <modules> 标签统一管理子模块生命周期。聚合与继承是两个独立概念，实践中通常结合使用。

<!-- 聚合父POM：pom.xml -->
<project xmlns="http://maven.apache.org/POM/4.0.0"
         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.platform</groupId>
    <artifactId>platform-parent</artifactId>
    <version>2.1.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <modules>
        <module>common-util</module>
        <module>domain-model</module>
        <module>service-api</module>
        <module>service-impl</module>
        <module>web-controller</module>
    </modules>

    <properties>
        <jackson.version>2.15.2</jackson.version>
        <junit.version>5.10.0</junit.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.example.platform</groupId>
                <artifactId>common-util</artifactId>
                <version>${project.version}</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>${jackson.version}</version>
            </dependency>
            <dependency>
                <groupId>org.junit.jupiter</groupId>
                <artifactId>junit-jupiter</artifactId>
                <version>${junit.version}</version>
                <scope>test</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

BOM 导入

Spring Boot 等框架提供 BOM POM，通过 import 作用域集中管理依赖版本：

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>3.2.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

3. Maven 生命周期与插件：compiler / surefire / shade / assembly

Maven 的核心是三大生命周期（clean、default、site），每个生命周期由顺序执行的 phase 组成，插件目标（goal）绑定到特定 phase 上完成实际工作。

核心生命周期映射

生命周期	关键 Phase	绑定的插件目标	作用
clean	clean	maven-clean-plugin:clean	删除 target 目录
default	compile	maven-compiler-plugin:compile	编译主源码
default	test	maven-surefire-plugin:test	执行单元测试
default	package	maven-jar-plugin:jar	打包 jar/war
default	install	maven-install-plugin:install	安装到本地仓库
default	deploy	maven-deploy-plugin:deploy	发布到远程仓库

maven-compiler-plugin

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.11.0</version>
    <configuration>
        <source>17</source>
        <target>17</target>
        <!-- 增量编译加速重复构建 -->
        <useIncrementalCompilation>true</useIncrementalCompilation>
        <annotationProcessorPaths>
            <path>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </path>
        </annotationProcessorPaths>
    </configuration>
</plugin>

maven-surefire-plugin

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.1.2</version>
    <configuration>
        <parallel>methods</parallel>
        <threadCount>4</threadCount>
        <includes>
            <include>**/*Test.java</include>
        </includes>
        <excludes>
            <exclude>**/*IT.java</exclude>
        </excludes>
    </configuration>
</plugin>

maven-shade-plugin

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <version>3.5.1</version>
    <executions>
        <execution>
            <phase>package</phase>
            <goals><goal>shade</goal></goals>
            <configuration>
                <createDependencyReducedPom>true</createDependencyReducedPom>
                <transformers>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                        <resource>META-INF/spring.handlers</resource>
                    </transformer>
                    <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                        <mainClass>com.example.Application</mainClass>
                    </transformer>
                </transformers>
            </configuration>
        </execution>
    </executions>
</plugin>

maven-assembly-plugin

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-assembly-plugin</artifactId>
    <version>3.6.0</version>
    <configuration>
        <descriptors>
            <descriptor>src/assembly/distribution.xml</descriptor>
        </descriptors>
        <appendAssemblyId>true</appendAssemblyId>
    </configuration>
    <executions>
        <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals><goal>single</goal></goals>
        </execution>
    </executions>
</plugin>

4. Gradle 基础：Groovy vs Kotlin DSL，Tasks 与 Plugins

Gradle 采用基于有向无环图（DAG）的任务模型。从 Gradle 5.0 开始，Kotlin DSL（.gradle.kts）成为官方推荐的新项目默认选择。

Groovy DSL 与 Kotlin DSL 语法差异

特性	Groovy DSL	Kotlin DSL
插件声明	`id 'java'`	`id("java")`
依赖声明	`implementation 'g:a:v'`	`implementation("g:a:v")`
类型安全	运行时检查	编译期类型检查
IDE 支持	良好	极佳（原生 Kotlin 支持）
执行性能	稍快	首次有 Kotlin 编译开销

Kotlin DSL 构建脚本

// build.gradle.kts —— 根项目
plugins {
    java
    `maven-publish`
}

group = "com.example.platform"
version = "2.1.0-SNAPSHOT"

repositories {
    maven { url = uri("https://maven.aliyun.com/repository/public") }
    mavenCentral()
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-web:3.2.0")
    compileOnly("org.projectlombok:lombok:1.18.30")
    annotationProcessor("org.projectlombok:lombok:1.18.30")
    testImplementation("org.junit.jupiter:junit-jupiter:5.10.0")
}

tasks.withType<JavaCompile> {
    sourceCompatibility = "17"
    targetCompatibility = "17"
    options.encoding = "UTF-8"
    options.compilerArgs.add("-parameters")
}

tasks.test {
    useJUnitPlatform()
    maxParallelForks = (Runtime.getRuntime().availableProcessors() / 2).coerceAtLeast(1)
    testLogging { events("passed", "skipped", "failed") }
}

settings.gradle.kts

rootProject.name = "platform-parent"

include("common-util", "domain-model", "service-api", "service-impl", "web-controller")

pluginManagement {
    repositories {
        gradlePluginPortal()
        mavenCentral()
    }
    plugins {
        kotlin("jvm") version "1.9.20"
    }
}

子模块 build.gradle.kts

plugins { `java-library` }

dependencies {
    api(project(":service-api"))
    implementation(project(":domain-model"))
    implementation("com.fasterxml.jackson.core:jackson-databind:2.15.2")
}

5. Gradle 高级：自定义 Task、增量构建与配置缓存

自定义 Task（Kotlin DSL）

abstract class JsonSchemaValidateTask : DefaultTask() {
    @get:InputDirectory
    abstract val schemaDir: DirectoryProperty

    @get:OutputFile
    abstract val reportFile: RegularFileProperty

    @TaskAction
    fun validate() {
        val schemas = schemaDir.asFileTree.matching { include("**/*.json") }
        val passed = schemas.files.all { it.length() > 0 }
        reportFile.get().asFile.writeText(
            "校验结果: ${if (passed) "通过" else "失败"}, 共 ${schemas.files.size} 个文件"
        )
    }
}

tasks.register<JsonSchemaValidateTask>("validateSchemas") {
    group = "verification"
    description = "校验JSON Schema文件"
    schemaDir.set(file("src/main/resources/schemas"))
    reportFile.set(layout.buildDirectory.file("reports/schema-validation.txt"))
}

启用构建缓存

# gradle.properties
org.gradle.daemon=true
org.gradle.caching=true
org.gradle.parallel=true
org.gradle.configuration-cache=true
org.gradle.workers.max=8
org.gradle.jvmargs=-Xmx4g -XX:MaxMetaspaceSize=512m

配置缓存兼容写法

tasks.register<Copy>("copyConfig") {
    val env = providers.gradleProperty("deploy.env").orElse("dev").get()
    val versionCode = providers.environmentVariable("BUILD_NUMBER").orElse("0").get()
    from("src/main/config/$env")
    into(layout.buildDirectory.dir("config"))
}

配置缓存要求外部输入通过 Provider API 懒加载，避免配置阶段执行 I/O 操作。

6. Maven vs Gradle 深度对比（8 维度）

维度	Maven	Gradle
配置语法	XML 声明式，结构严格	Groovy/Kotlin DSL，脚本化灵活
学习曲线	平缓，约定优于配置	较陡，需理解任务图与 API
构建性能	中等，无原生增量编译	优秀，增量+构建缓存+配置缓存三层加速
多模块构建	reactor 按序构建，支持 `-T` 并行	DAG 任务级并行，原生高度并发
依赖管理	`dependencyManagement` + BOM	`api`/`implementation` 分离传递依赖
插件生态	数量庞大，成熟稳定	数量较多，官方插件质量高
IDE 集成	Eclipse/IDEA 完善	IDEA Kotlin DSL 支持极佳
定制化	XML 表达能力有限	脚本语言直接编程，可深度定制

7. CI/CD 集成：GitHub Actions / Jenkins / GitLab CI

GitHub Actions

# .github/workflows/ci.yml
name: Java CI
on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with:
          java-version: "17"
          distribution: "temurin"
          cache: "maven"
      - run: mvn -B verify --file pom.xml
      - uses: actions/upload-artifact@v4
        if: always()
        with:
          name: surefire-reports
          path: target/surefire-reports/

Jenkins Pipeline

// Jenkinsfile
pipeline {
    agent any
    tools {
        jdk "JDK-17"
        maven "Maven-3.9"
    }
    options {
        buildDiscarder(logRotator(numToKeepStr: "10"))
        disableConcurrentBuilds()
    }
    stages {
        stage("检出") {
            steps { checkout scm }
        }
        stage("编译") {
            steps { sh "mvn -T 1C clean compile" }
        }
        stage("单元测试") {
            steps { sh "mvn test" }
            post {
                always {
                    junit "**/target/surefire-reports/*.xml"
                }
            }
        }
        stage("集成测试") {
            when {
                anyOf { branch "develop"; changeRequest() }
            }
            steps { sh "mvn verify -P integration-test" }
        }
        stage("打包发布") {
            when { branch "main" }
            steps { sh "mvn deploy -DskipTests" }
        }
    }
}

GitLab CI

# .gitlab-ci.yml
variables:
  MAVEN_OPTS: "-Dmaven.repo.local=$CI_PROJECT_DIR/.m2/repository --batch-mode"
  MAVEN_CLI_OPTS: "--settings settings.xml"

cache:
  paths: [.m2/repository]

stages: [build, test, package, deploy]

compile:
  stage: build
  image: maven:3.9-eclipse-temurin-17
  script: ["mvn $MAVEN_CLI_OPTS compile"]

unit-test:
  stage: test
  image: maven:3.9-eclipse-temurin-17
  script: ["mvn $MAVEN_CLI_OPTS test"]
  artifacts:
    when: always
    reports:
      junit: ["*/target/surefire-reports/TEST-*.xml"]

package:
  stage: package
  image: maven:3.9-eclipse-temurin-17
  script: ["mvn $MAVEN_CLI_OPTS package -DskipTests"]
  artifacts:
    paths: ["*/target/*.jar"]

deploy:
  stage: deploy
  image: maven:3.9-eclipse-temurin-17
  rules:
    - if: $CI_COMMIT_BRANCH == "main"
  script: ["mvn $MAVEN_CLI_OPTS deploy -DskipTests"]

8. 构建加速：并行构建、守护进程与远程缓存

Maven 并行构建

# 4线程并行构建
mvn -T 4 clean install
# 线程数等于CPU核心数
mvn -T 1C clean install

Maven 的 -T 基于模块依赖图并发，无依赖关系的模块并行执行。注意插件线程安全与集成测试资源冲突。

Gradle 远程构建缓存

// settings.gradle.kts
buildCache {
    local {
        directory = File(rootDir, ".gradle/build-cache")
        removeUnusedEntriesAfterDays = 30
    }
    remote<HttpBuildCache> {
        url = uri("https://gradle-cache.example.com/cache")
        isPush = System.getenv("CI") != null
        credentials {
            username = System.getenv("CACHE_USERNAME")
            password = System.getenv("CACHE_PASSWORD")
        }
    }
}

9. 发布仓库：Nexus / Artifactory

Maven 发布配置

<!-- settings.xml：认证信息 -->
<settings>
    <servers>
        <server>
            <id>nexus-releases</id>
            <username>${env.NEXUS_USERNAME}</username>
            <password>${env.NEXUS_PASSWORD}</password>
        </server>
    </servers>
</settings>

<!-- pom.xml：发布仓库地址 -->
<distributionManagement>
    <repository>
        <id>nexus-releases</id>
        <url>https://nexus.example.com/repository/maven-releases/</url>
    </repository>
    <snapshotRepository>
        <id>nexus-snapshots</id>
        <url>https://nexus.example.com/repository/maven-snapshots/</url>
    </snapshotRepository>
</distributionManagement>

Gradle 发布配置

plugins {
    `maven-publish`
    signing
}

publishing {
    publications {
        create<MavenPublication>("mavenJava") {
            from(components["java"])
            pom {
                name.set("Platform Service Core")
                licenses {
                    license {
                        name.set("Apache-2.0")
                        url.set("https://www.apache.org/licenses/LICENSE-2.0")
                    }
                }
            }
        }
    }
    repositories {
        maven {
            name = "Nexus"
            val releasesUrl = "https://nexus.example.com/repository/maven-releases/"
            val snapshotsUrl = "https://nexus.example.com/repository/maven-snapshots/"
            url = uri(if (version.toString().endsWith("SNAPSHOT")) snapshotsUrl else releasesUrl)
            credentials {
                username = System.getenv("NEXUS_USERNAME")
                password = System.getenv("NEXUS_PASSWORD")
            }
        }
    }
}

signing {
    val key = System.getenv("GPG_SIGNING_KEY")
    val pwd = System.getenv("GPG_SIGNING_PASSWORD")
    if (key != null && pwd != null) {
        useInMemoryPgpKeys(key, pwd)
        sign(publishing.publications["mavenJava"])
    }
}

10. 版本管理：SemVer 与 Release Plugin

语义化版本（SemVer）

格式 MAJOR.MINOR.PATCH：

MAJOR：不兼容 API 变更
MINOR：向后兼容功能新增
PATCH：向后兼容问题修复

预发布版本示例：2.1.0-beta.1、2.1.0-SNAPSHOT。

Maven Release Plugin

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-release-plugin</artifactId>
    <version>3.0.1</version>
    <configuration>
        <preparationGoals>clean verify</preparationGoals>
        <goals>deploy</goals>
        <autoVersionSubmodules>true</autoVersionSubmodules>
    </configuration>
</plugin>

# 准备发布：修改版本号、打标签
mvn release:prepare
# 执行发布：部署到远程仓库
mvn release:perform

Gradle Version Catalog

# gradle/libs.versions.toml
[versions]
spring-boot = "3.2.0"
jackson = "2.15.2"
junit = "5.10.0"

[libraries]
jackson-databind = { module = "com.fasterxml.jackson.core:jackson-databind", version.ref = "jackson" }
junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit" }

[bundles]
testing = ["junit-jupiter"]

[plugins]
spring-boot = { id = "org.springframework.boot", version.ref = "spring-boot" }

// build.gradle.kts
dependencies {
    implementation(libs.jackson.databind)
    testImplementation(libs.bundles.testing)
}

FAQ

Q1：Maven 多模块项目中，子模块是否必须继承父 POM？

A1：不是。<modules> 用于聚合，<parent> 用于继承，二者独立。实践中通常合并使用，但跨组织复用时可以设计独立继承父 POM。

Q2：Gradle 的配置缓存与构建缓存有什么区别？

A2：构建缓存保存任务输出产物（如 .class、.jar），配置缓存保存配置阶段解析的任务图模型。前者减少任务执行，后者跳过配置阶段。

Q3：为什么推荐 implementation 替代 compile？

A3：Gradle 3.4+ 引入 api/implementation 分离模型。implementation 不向下游传递依赖，减少编译传递面与依赖冲突概率。

Q4：Maven -T 并行构建是否可用于生产环境？

A4：多数场景安全，但需验证插件线程安全性。集成测试若共享数据库等外部资源，并发执行可能导致冲突，建议编译和单元测试并行、集成测试串行。

Q5：Gradle Kotlin DSL 首次构建慢如何优化？

A5：启用守护进程与配置缓存，升级 Gradle 获取 Kotlin 编译优化，CI 中预热 Gradle 缓存。首次编译开销换取类型安全与 IDE 补全，长期收益显著。

总结

Maven 以"约定优于配置"提供标准化的企业构建体验，适合追求规范统一的大型传统项目。Gradle 凭借 DAG 任务模型与三层缓存，在构建性能与定制化上占优，更适合深度优化构建速度与拥抱 Kotlin 生态的现代化团队。无论选择何种工具，掌握多模块聚合、依赖治理、CI/CD 集成与构建加速技术，都是 Java 工程化建设的必由之路。

继续阅读

探索更多技术文章

浏览归档，发现更多关于系统设计、工具链和工程实践的内容。

全部文章返回首页