Java Gradle构建案例

本文目录导读：

1. 基础Java项目
2. Spring Boot项目
3. 高级配置
4. 常用命令行操作
5. 生产环境优化

我来提供一个完整的Java Gradle构建案例，包含常见的最佳实践。

基础Java项目

项目结构

my-java-project/
├── build.gradle
├── settings.gradle
├── gradle.properties
├── gradlew
├── gradlew.bat
├── gradle/
│   └── wrapper/
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
└── src/
    ├── main/
    │   └── java/
    │       └── com/example/
    │           └── App.java
    └── test/
        └── java/
            └── com/example/
                └── AppTest.java

settings.gradle

rootProject.name = 'my-java-project'

build.gradle（基础版）

plugins {
    id 'java'
    id 'application'
}
group = 'com.example'
version = '1.0.0'
repositories {
    mavenCentral()
}
dependencies {
    // 日志
    implementation 'org.slf4j:slf4j-api:2.0.13'
    implementation 'ch.qos.logback:logback-classic:1.5.6'
    // 测试
    testImplementation platform('org.junit:junit-bom:5.10.2')
    testImplementation 'org.junit.jupiter:junit-jupiter'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}
application {
    mainClass = 'com.example.App'
}
test {
    useJUnitPlatform()
    testLogging {
        events "passed", "skipped", "failed"
    }
}

源码示例

src/main/java/com/example/App.java

package com.example;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class App {
    private static final Logger log = LoggerFactory.getLogger(App.class);
    public static void main(String[] args) {
        log.info("Application started!");
        Calculator calculator = new Calculator();
        int result = calculator.add(5, 3);
        log.info("5 + 3 = {}", result);
    }
}
class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

src/test/java/com/example/AppTest.java

package com.example;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
class AppTest {
    @Test
    void testAdd() {
        Calculator calculator = new Calculator();
        assertEquals(5, calculator.add(2, 3));
    }
    @Test
    void testAddWithNegative() {
        Calculator calculator = new Calculator();
        assertEquals(0, calculator.add(-1, 1));
    }
}

Spring Boot项目

build.gradle

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.3.0'
    id 'io.spring.dependency-management' version '1.1.5'
}
group = 'com.example'
version = '0.0.1-SNAPSHOT'
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}
configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}
repositories {
    mavenCentral()
}
dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-validation'
    // 数据库
    runtimeOnly 'com.mysql:mysql-connector-j'
    runtimeOnly 'com.h2database:h2'
    // Lombok
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    // 测试
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
}
tasks.named('test') {
    useJUnitPlatform()
}

多模块项目示例

settings.gradle

rootProject.name = 'multi-module-project'
include 'common', 'domain', 'web', 'api'

build.gradle（根项目）

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.3.0' apply false
    id 'io.spring.dependency-management' version '1.1.5' apply false
}
allprojects {
    group = 'com.example'
    version = '1.0.0'
    repositories {
        mavenCentral()
    }
}
subprojects {
    apply plugin: 'java'
    java {
        toolchain {
            languageVersion = JavaLanguageVersion.of(17)
        }
    }
    tasks.withType(JavaCompile).configureEach {
        options.encoding = 'UTF-8'
    }
    test {
        useJUnitPlatform()
    }
}

common/build.gradle

dependencies {
    implementation 'org.apache.commons:commons-lang3:3.14.0'
    implementation 'com.fasterxml.jackson.core:jackson-databind:2.17.1'
}

domain/build.gradle

dependencies {
    implementation project(':common')
    implementation 'org.springframework.data:spring-data-jpa'
    implementation 'jakarta.persistence:jakarta.persistence-api:3.1.0'
}

web/build.gradle

dependencies {
    implementation project(':common')
    implementation project(':domain')
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-validation'
}

高级配置

gradle.properties

# JVM设置
org.gradle.jvmargs=-Xmx2g -XX:MaxMetaspaceSize=512m -Dfile.encoding=UTF-8
org.gradle.parallel=true
org.gradle.caching=true
# 依赖版本
junitVersion=5.10.2
springBootVersion=3.3.0

自定义任务和插件

// 自定义任务示例
tasks.register('printProjectInfo') {
    doLast {
        println "Project: ${project.name}"
        println "Version: ${project.version}"
        println "Java Version: ${java.toolchain.languageVersion.get()}"
    }
}
// 复制jar文件
tasks.register('copyJar', Copy) {
    from processes.main.outputs
    into layout.buildDirectory.dir('dist')
}
// 生成文档
javadoc {
    options {
        encoding = 'UTF-8'
        links 'https://docs.oracle.com/en/java/javase/17/docs/api/'
    }
}

构建扫描和性能优化

// build.gradle
plugins {
    id 'com.gradle.enterprise' version '3.17.4'
}
// 或启用build scan
gradleEnterprise {
    buildScan {
        termsOfServiceUrl = 'https://gradle.com/terms-of-service'
        termsOfServiceAgree = 'yes'
        publishAlways()
    }
}

常用命令行操作

# 构建项目（跳过测试）
./gradlew build -x test
# 运行应用
./gradlew run
# 运行测试
./gradlew test
# 清理构建
./gradlew clean
# 查看任务列表
./gradlew tasks
# 依赖树
./gradlew dependencies
# 增量构建
./gradlew build --build-cache
# 并行构建
./gradlew build --parallel
# 调试模式运行测试
./gradlew test --debug-jvm
# 持续构建
./gradlew build --continuous

生产环境优化

// 多环境配置
def env = System.getenv('ENV') ?: 'dev'
dependencies {
    if (env == 'prod') {
        // 生产环境依赖
    }
}
// 打包优化
jar {
    manifest {
        attributes 'Main-Class': application.mainClass
    }
}
// 构建产物清理
clean {
    delete 'build', 'out', '.gradle'
}
// 依赖锁定
dependencyLocking {
    lockAllConfigurations()
}
// 一致性检查
tasks.register('verifyDependencies') {
    doLast {
        configurations.all { config ->
            config.dependencies.each { dep ->
                // 验证依赖
            }
        }
    }
}

这个案例涵盖了Java Gradle构建的大部分常见场景，从基础配置到高级特性都有涉及，你可以根据项目需求选择合适的配置方式。