Zum Inhalt

Grad Cheatsheet

Überblick

Gradle ist ein Build Automation Tool, das die Mehrsprachigkeitsentwicklung unterstützt. Es verwendet statt XML eine Groovy- oder Kotlin-basierte Domain-spezifische Sprache (DSL) zur Erklärung der Projektkonfiguration.

Installation

Paketmanager

# macOS
brew install gradle

# Ubuntu/Debian (via SDKMAN)
curl -s "https://get.sdkman.io"|bash
sdk install gradle

# Windows (Chocolatey)
choco install gradle

# Manual installation
wget https://services.gradle.org/distributions/gradle-8.0-bin.zip
unzip gradle-8.0-bin.zip
export PATH=$PATH:/path/to/gradle-8.0/bin
```_

### Klasse Wrapper
```bash
# Generate wrapper (recommended)
gradle wrapper

# Use wrapper
./gradlew build    # Unix/macOS
gradlew.bat build  # Windows
```_

## Struktur des Projekts

### Standard Layout

project/ ├── build.gradle(.kts) ├── settings.gradle(.kts) ├── gradlew ├── gradlew.bat ├── gradle/ │ └── wrapper/ ├── src/ │ ├── main/ │ │ ├── java/ │ │ └── resources/ │ └── test/ │ ├── java/ │ └── resources/ └── build/ ```_

Grundaufbau. Grad

Java Project (Groovy DSL)

```groovy plugins \\{ id 'java' id 'application' \\}

group = 'com.example' version = '1.0.0'

java \\{ sourceCompatibility = JavaVersion.VERSION_11 targetCompatibility = JavaVersion.VERSION_11 \\}

repositories \\{ mavenCentral() \\}

dependencies \\{ implementation 'org.apache.commons:commons-lang3:3.12.0' testImplementation 'junit:junit:4.13.2' testImplementation 'org.mockito:mockito-core:4.6.1' \\}

application \\{ mainClass = 'com.example.Main' \\}

test \\{ useJUnitPlatform() \\} ```_

Java Project (Kotlin DSL)

```kotlin plugins \\{ java application \\}

group = "com.example" version = "1.0.0"

java \\{ sourceCompatibility = JavaVersion.VERSION_11 targetCompatibility = JavaVersion.VERSION_11 \\}

repositories \\{ mavenCentral() \\}

dependencies \\{ implementation("org.apache.commons:commons-lang3:3.12.0") testImplementation("junit:junit:4.13.2") testImplementation("org.mockito:mockito-core:4.6.1") \\}

application \\{ mainClass.set("com.example.Main") \\}

tasks.test \\{ useJUnitPlatform() \\} ```_

Aufgaben

Eingebaute Aufgaben

```bash

Build tasks

./gradlew build # Full build ./gradlew assemble # Build without tests ./gradlew clean # Clean build directory ./gradlew check # Run all checks

Java tasks

./gradlew compileJava # Compile main Java sources ./gradlew compileTestJava # Compile test sources ./gradlew test # Run tests ./gradlew jar # Create JAR file

Application tasks

./gradlew run # Run application ./gradlew installDist # Create distribution ./gradlew distZip # Create ZIP distribution

Help tasks

./gradlew tasks # List available tasks ./gradlew help # Show help ./gradlew properties # Show project properties ```_

Kundenspezifische Aufgaben (Groovy)

```groovy task hello \\{ doLast \\{ println 'Hello, World!' \\} \\}

task copyFiles(type: Copy) \\{ from 'src/main/resources' into 'build/resources' \\}

task createDocs(type: Javadoc) \\{ source = sourceSets.main.allJava classpath = configurations.compileClasspath \\}

// Task with dependencies task buildAll \\{ dependsOn 'clean', 'build', 'createDocs' \\}

// Task with configuration task processTemplates(type: Copy) \\{ from 'src/templates' into 'build/generated' expand(project.properties) \\} ```_

Benutzerdefinierte Aufgaben (Kotlin)

```kotlin tasks.register("hello") \\{ doLast \\{ println("Hello, World!") \\} \\}

tasks.register("copyFiles") \\{ from("src/main/resources") into("build/resources") \\}

tasks.register("createDocs") \\{ source = sourceSets.main.get().allJava classpath = configurations.compileClasspath.get() \\}

// Task with dependencies tasks.register("buildAll") \\{ dependsOn("clean", "build", "createDocs") \\} ```_

Abhängigkeiten

Dependency Configuration

```groovy dependencies \\{ // Compile time and runtime implementation 'org.springframework:spring-core:5.3.21'

// Compile time only
compileOnly 'org.projectlombok:lombok:1.18.24'

// Runtime only
runtimeOnly 'mysql:mysql-connector-java:8.0.29'

// Test dependencies
testImplementation 'junit:junit:4.13.2'
testRuntimeOnly 'org.junit.platform:junit-platform-launcher'

// Annotation processor
annotationProcessor 'org.projectlombok:lombok:1.18.24'

// API (for library projects)
api 'org.apache.commons:commons-lang3:3.12.0'

\\} ```_

Versionsmanagement

```groovy // Version catalog (gradle/libs.versions.toml) [versions] spring = "5.3.21" junit = "4.13.2"

[libraries] spring-core = \\{ module = "org.springframework:spring-core", version.ref = "spring" \\} junit = \\{ module = "junit:junit", version.ref = "junit" \\}

// In build.gradle dependencies \\{ implementation libs.spring.core testImplementation libs.junit \\}

// Version constraints dependencies \\{ implementation('org.springframework:spring-core') \\{ version \\{ strictly '[5.0, 6.0[' prefer '5.3.21' \\} \\} \\} ```_

Abhängigkeitsresolution

```groovy configurations.all \\{ resolutionStrategy \\{ // Force specific version force 'org.slf4j:slf4j-api:1.7.36'

    // Fail on version conflict
    failOnVersionConflict()

    // Cache for 24 hours
    cacheDynamicVersionsFor 24, 'hours'
    cacheChangingModulesFor 24, 'hours'
\\\\}

\\}

// Exclude transitive dependencies dependencies \\{ implementation('org.springframework:spring-core') \\{ exclude group: 'commons-logging', module: 'commons-logging' \\} \\} ```_

Multi-Projekt baut

Einstellungen. Grad

```groovy rootProject.name = 'my-multi-project'

include 'core' include 'web' include 'api'

// Custom project locations include 'shared' project(':shared').projectDir = file('shared-library') ```_

Root bauen. Grad

```groovy allprojects \\{ group = 'com.example' version = '1.0.0'

repositories \\\\{
    mavenCentral()
\\\\}

\\}

subprojects \\{ apply plugin: 'java'

java \\\\{
    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11
\\\\}

dependencies \\\\{
    testImplementation 'junit:junit:4.13.2'
\\\\}

\\}

// Configure specific projects project(':web') \\{ apply plugin: 'war'

dependencies \\\\{
    implementation project(':core')
    implementation 'org.springframework:spring-webmvc:5.3.21'
\\\\}

\\} ```_

Projektabhängigkeiten

```groovy // In web/build.gradle dependencies \\{ implementation project(':core') implementation project(':api')

// Specific configuration
testImplementation project(path: ':core', configuration: 'testFixtures')

\\} ```_

Plugins

Verwendung von Plugins

```groovy // Core plugins plugins \\{ id 'java' id 'application' id 'maven-publish' \\}

// Community plugins plugins \\{ id 'org.springframework.boot' version '2.7.0' id 'io.spring.dependency-management' version '1.0.11.RELEASE' id 'com.github.johnrengelman.shadow' version '7.1.2' \\}

// Legacy plugin application apply plugin: 'java' apply from: 'gradle/dependencies.gradle' ```_

Beliebte Plugins

```groovy // Spring Boot plugins \\{ id 'org.springframework.boot' version '2.7.0' id 'io.spring.dependency-management' version '1.0.11.RELEASE' \\}

// Shadow JAR (fat JAR) plugins \\{ id 'com.github.johnrengelman.shadow' version '7.1.2' \\}

shadowJar \\{ archiveBaseName = 'my-app' archiveClassifier = '' archiveVersion = '' \\}

// Docker plugins \\{ id 'com.bmuschko.docker-java-application' version '7.4.0' \\}

docker \\{ javaApplication \\{ baseImage = 'openjdk:11-jre-slim' maintainer = 'Your Name <your.email@example.com>' ports = [8080] images = ['my-app:latest'] \\} \\} ```_

Prüfung

JUNI 5

```groovy dependencies \\{ testImplementation 'org.junit.jupiter:junit-jupiter:5.8.2' testRuntimeOnly 'org.junit.platform:junit-platform-launcher' \\}

test \\{ useJUnitPlatform()

testLogging \\\\{
    events "passed", "skipped", "failed"
    exceptionFormat "full"
\\\\}

// System properties
systemProperty 'junit.jupiter.execution.parallel.enabled', 'true'

// JVM arguments
jvmArgs '-Xmx1024m'

\\}

// Custom test task task integrationTest(type: Test) \\{ useJUnitPlatform() testClassesDirs = sourceSets.integrationTest.output.classesDirs classpath = sourceSets.integrationTest.runtimeClasspath \\} ```_

Testberichte

```groovy test \\{ reports \\{ html.enabled = true xml.enabled = true junitXml.enabled = true \\}

finalizedBy jacocoTestReport

\\}

// Jacoco code coverage plugins \\{ id 'jacoco' \\}

jacocoTestReport \\{ reports \\{ xml.enabled true html.enabled true \\} \\}

jacocoTestCoverageVerification \\{ violationRules \\{ rule \\{ limit \\{ minimum = 0.8 \\} \\} \\} \\} ```_

Konfiguration erstellen

Quelle Sets

```groovy sourceSets \\{ main \\{ java \\{ srcDirs = ['src/main/java', 'src/generated/java'] \\} resources \\{ srcDirs = ['src/main/resources', 'src/main/config'] \\} \\}

integrationTest \\\\{
    java \\\\{
        compileClasspath += sourceSets.main.output
        runtimeClasspath += sourceSets.main.output
    \\\\}
\\\\}

\\}

configurations \\{ integrationTestImplementation.extendsFrom testImplementation integrationTestRuntimeOnly.extendsFrom testRuntimeOnly \\} ```_

Bauarten

```groovy // Environment-specific builds if (project.hasProperty('env')) \\{ apply from: "gradle/env-$\\{project.env\\}.gradle" \\}

// Debug/Release configurations task debugJar(type: Jar) \\{ archiveClassifier = 'debug' from sourceSets.main.output \\}

task releaseJar(type: Jar) \\{ archiveClassifier = 'release' from sourceSets.main.output

// Minimize JAR
exclude '**/debug/**'
exclude '**/*Test.class'

\\} ```_

Veröffentlichungen

Maven Verlag

```groovy plugins \\{ id 'maven-publish' id 'signing' \\}

publishing \\{ publications \\{ maven(MavenPublication) \\{ from components.java

        pom \\\\{
            name = 'My Library'
            description = 'A concise description of my library'
            url = 'http://www.example.com/library'

            licenses \\\\{
                license \\\\{
                    name = 'The Apache License, Version 2.0'
                    url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                \\\\}
            \\\\}

            developers \\\\{
                developer \\\\{
                    id = 'johndoe'
                    name = 'John Doe'
                    email = 'john.doe@example.com'
                \\\\}
            \\\\}

            scm \\\\{
                connection = 'scm:git:git://example.com/my-library.git'
                developerConnection = 'scm:git:ssh://example.com/my-library.git'
                url = 'http://example.com/my-library/'
            \\\\}
        \\\\}
    \\\\}
\\\\}

repositories \\\\{
    maven \\\\{
        name = "OSSRH"
        url = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
        credentials \\\\{
            username = ossrhUsername
            password = ossrhPassword
        \\\\}
    \\\\}
\\\\}

\\}

signing \\{ sign publishing.publications.maven \\} ```_

Verwendung der Befehlszeile

Grundlegende Befehle

```bash

Build project

./gradlew build

Clean build

./gradlew clean build

Run tests

./gradlew test

Run application

./gradlew run

Create distribution

./gradlew installDist

Publish to repository

./gradlew publish ```_

Erweiterte Optionen

```bash

Parallel execution

./gradlew build --parallel

Offline mode

./gradlew build --offline

Refresh dependencies

./gradlew build --refresh-dependencies

Profile build

./gradlew build --profile

Debug mode

./gradlew build --debug

Continuous build

./gradlew build --continuous

Build specific project

./gradlew :web:build

Exclude tasks

./gradlew build -x test ```_

Systemeigenschaften

```bash

Set system properties

./gradlew build -Dorg.gradle.debug=true

Set project properties

./gradlew build -Penv=production

Set JVM options

./gradlew build -Dorg.gradle.jvmargs="-Xmx2g -XX:+HeapDumpOnOutOfMemoryError" ```_

Eigenschaften des Grades

gradle.properties

```properties

JVM settings

org.gradle.jvmargs=-Xmx2048m -XX:+HeapDumpOnOutOfMemoryError

Gradle daemon

org.gradle.daemon=true

Parallel execution

org.gradle.parallel=true

Build cache

org.gradle.caching=true

Configuration cache

org.gradle.configuration-cache=true

Project properties

version=1.0.0 group=com.example

Custom properties

database.url=jdbc:mysql://localhost:3306/mydb api.key=your-api-key ```_

Umwelt-Specific Properties

```bash

gradle-dev.properties

database.url=jdbc:h2:mem:testdb debug.enabled=true

gradle-prod.properties

database.url=jdbc:mysql://prod-server:3306/mydb debug.enabled=false

Usage

./gradlew build -Penv=dev ```_

Leistungsoptimierung

Cache bauen

```groovy // Enable build cache buildCache \\{ local \\{ enabled = true directory = file("$\\{rootDir\\}/.gradle/build-cache") \\}

remote(HttpBuildCache) \\\\{
    url = 'https://example.com/build-cache/'
    push = true
    credentials \\\\{
        username = buildCacheUsername
        password = buildCachePassword
    \\\\}
\\\\}

\\} ```_

Parallele Ausführung

```properties

gradle.properties

org.gradle.parallel=true org.gradle.workers.max=4 org.gradle.configureondemand=true ```_

Incremental Compilation

groovy tasks.withType(JavaCompile) \\\\{ options.incremental = true options.fork = true options.forkOptions.jvmArgs = ['-Xmx1024m'] \\\\}_

Best Practices

Projektstruktur

```groovy // Use version catalog dependencyResolutionManagement \\{ versionCatalogs \\{ libs \\{ from(files("gradle/libs.versions.toml")) \\} \\} \\}

// Consistent formatting plugins \\{ id 'com.diffplug.spotless' version '6.7.2' \\}

spotless \\{ java \\{ googleJavaFormat() removeUnusedImports() trimTrailingWhitespace() endWithNewline() \\} \\} ```_

Fehlerbehebung

```groovy // Fail fast on dependency conflicts configurations.all \\{ resolutionStrategy.failOnVersionConflict() \\}

// Validate required properties if (!project.hasProperty('apiKey')) \\{ throw new GradleException('apiKey property is required') \\}

// Check Java version if (!JavaVersion.current().isJava11Compatible()) \\{ throw new GradleException('Java 11 or higher is required') \\} ```_

Fehlerbehebung

Gemeinsame Themen

```bash

Clear Gradle cache

rm -rf ~/.gradle/caches/

Refresh dependencies

./gradlew build --refresh-dependencies

Debug dependency resolution

./gradlew dependencies ./gradlew dependencyInsight --dependency spring-core

Check for deprecated features

./gradlew build --warning-mode all

Profile build performance

./gradlew build --profile --scan ```_

Debug Mode

```bash

Enable debug logging

./gradlew build --debug

Enable info logging

./gradlew build --info

Stack trace on failure

./gradlew build --stacktrace ```_

Ressourcen

  • *offizielle Dokumentation: gradle.org/docs
  • Benutzerhandbuch: [docs.gradle.org/current/userguide](https://__LINK_4___
  • Plugin Portal: [plugins.gradle.org](__LINK_4___
  • *Build Scans: gradle.com