Next:
Impressum
gradle
1
Impressum
2
Build-Automatisierung mit Gradle
2.1
Was ist Build-Automatisierung?
2.2
Gradle als Build-Automatisierungs-Tool
2.3
Kernkonzepte von Gradle
2.3.1
Zentrale Gradle-Begriffe im Überblick
2.4
Build-Lifecycle und Task-Ausführung
2.5
Vorteile der Build-Automatisierung mit Gradle
3
Installation und Grundkonfiguration
3.1
Systemvoraussetzungen und Installationswege
3.2
Gradle Wrapper einrichten und verwenden
3.3
Grundlegende Projektstruktur
3.4
Erste Build-Konfiguration
3.5
Gradle Properties und Umgebungskonfiguration
3.6
Erste Build-Befehle und Diagnose
3.6.1
Wichtige Gradle-Befehle und Parameter
3.6.2
Kombinierte Verwendung
4
Projektstruktur und Konventionen
4.1
Convention over Configuration in Gradle
4.1.1
Standard-Konventionen des Java-Plugins
4.2
Source Sets und ihre Verwaltung
4.2.1
Übliche Custom Source Sets
4.3
Verzeichnisstruktur für verschiedene Projekttypen
4.3.1
Projekttypen-Übersicht
4.4
Build-Verzeichnis und generierte Artefakte
4.4.1
Struktur des Build-Verzeichnisses
4.5
Multi-Modul-Projektstrukturen
4.6
Namenskonventionen und Best Practices
4.6.1
Namenskonventionen im Überblick
5
Kotlin DSL vs. Groovy DSL – Migration und Best Practices
5.1
Entwicklung und Motivation der beiden DSLs
5.2
Syntax-Unterschiede im Detail
5.2.1
Elementare syntaktische Konstrukte in Gradle
5.3
Typ-Sicherheit und IDE-Support
5.4
Migrationsstrategie von Groovy zu Kotlin
5.5
Häufige Migrationsprobleme und Lösungen
5.6
Performance-Aspekte und Best Practices
6
Dependency Management und Repositories
6.1
Grundkonzepte des Dependency Managements
6.2
Repository-Typen und ihre Konfiguration
6.2.1
Repository-Typen im Überblick
6.3
Configurations und Scopes
6.3.1
Standard-Configurations des Java-Plugins
6.4
Versionsmanagement-Strategien
6.4.1
Versions-Notationen in Gradle
6.5
Caching und Offline-Builds
6.6
Fehlerdiagnose und Dependency Insights
6.6.1
Wichtige Diagnose-Befehle
7
Dependency Constraints
7.1
Konzept und Motivation von Dependency Constraints
7.2
Platform- und BOM-Integration
7.3
Rich Version Declarations
7.4
Constraint-Vererbung in Multi-Modul-Projekten
7.5
Konfliktauflösung mit Constraints
7.6
Best Practices und Patterns
8
Configuration-Patterns
8.1
Das Grundkonzept: Drei Rollen, klare Verantwortlichkeiten
8.1.1
1. Bucket Configurations (Declarable)
8.1.2
2. Resolvable Configurations
8.1.3
3. Consumable Configurations
8.2
Praktische Anwendung: Von der Theorie zur Praxis
8.2.1
Beispiel 1: Ein Multi-Modul-Projekt strukturieren
8.2.2
Beispiel 2: Integration Tests mit eigenen Dependencies
8.2.3
Beispiel 3: Dependencies für Code-Generierung
8.3
Häufige Probleme und ihre Lösungen
8.3.1
Problem 1: “Configuration has been resolved”
8.3.2
Problem 2: Performance-Probleme durch frühe Resolution
8.3.3
Problem 3: Versionskonflikte lösen
8.4
Migration von alten Gradle-Versionen
8.4.1
Schritt 1: Ersetzen Sie veraltete Configurations
8.4.2
Schritt 2: Configuration Cache aktivieren
8.5
Best Practices für wartbare Builds
8.5.1
1. Nutzen Sie Platform/BOM für Versionsverwaltung
8.5.2
2. Strukturieren Sie Test Configurations hierarchisch
8.5.3
3. Verwenden Sie Factory-Methoden für neue Configurations
8.6
Debugging-Tools für Configuration-Probleme
8.7
Zusammenfassung: Die wichtigsten Punkte
8.8
Resolvable und Consumable Configurations
8.8.1
Schritt 1: Projekt erstellen
8.8.2
Schritt 2: Multi-Projekt konfigurieren
8.8.3
Schritt 3: Producer-Modul (stellt etwas bereit)
8.8.4
Schritt 4: Consumer-Modul (nutzt etwas)
8.8.5
Schritt 5: Ausprobieren
8.8.6
Schritt 6: Dependencies prüfen
8.8.7
🎯 Das Wichtigste auf einen Blick
8.8.8
Consumer (nutzt)
8.8.9
Was leistet der Consumer?
8.8.10
Was leistet der Producer?
8.9
Noch einfachere Variante (ohne Java)
8.9.1
Aufgabe: Übung um ein weiteres Submodul erweitern
8.9.2
Lösungsvorschlag (für Daniel)
8.10
Musterlösung: Analyzer-Modul
8.10.1
Schritt 1: settings.gradle.kts erweitern
8.10.2
Schritt 2: Consumer-Modul anpassen (consumable Configuration hinzufügen)
8.10.3
Schritt 3: Analyzer-Modul implementieren
8.10.4
Schritt 4: Ausführen und Testen
9
Praxisbeispiel: Integration-Test-Configuration aufsetzen
9.1
Motivation für separate Integrationstests
9.2
Source Set und Verzeichnisstruktur einrichten
9.3
Configuration-Hierarchie definieren
9.4
Dependencies für Integrationstests verwalten
9.5
Test-Task konfigurieren
9.6
CI/CD-Integration und Best Practices
10
Version Management und Version Catalogs
10.1
Struktur und Syntax von Version Catalogs
10.2
Verwendung in Build-Skripten
10.3
Migration bestehender Projekte
10.4
Fortgeschrittene Patterns und Features
10.4.1
Praxisbeispiel: Multi-Modul mit mehreren Catalogs
10.5
Best Practices und Governance
10.6
Übung Version Catalogs - Praxisbeispiel
10.6.1
Projekt-Setup
10.6.2
Verwendung
10.6.3
Version-Management in der Praxis
10.6.4
Best Practices
10.6.5
Migration bestehender Projekte
10.6.6
Folgerung
10.6.7
Aufgabe: Erweiterung mit eigenem Test-Catalog
11
Lazy Configuration
11.1
Provider API im Detail
11.2
Property API und Configuration Avoidance
11.3
Migration von Eager zu Lazy Patterns
11.4
Performance-Auswirkungen und Messungen
11.5
Best Practices und Patterns
11.6
Übung
11.6.1
Lazy Configuration in Gradle
11.6.2
Aufgabe: Eager vs. Lazy Configuration ausprobieren
12
Task Bindings und Layout-API (Abschied von $buildDir)
12.1
Die Problematik hardcodierter Pfade
12.2
Layout-API Grundlagen
12.3
Wire Protocol und implizite Task-Dependencies
12.4
Migration von Legacy-Patterns
12.5
FileOperations mit Layout-API
12.6
Best Practices und Performance-Optimierungen
12.7
Übung – Task Bindings mit der Layout-API
12.7.1
Ziel
12.7.2
Schritt 1: Projekt vorbereiten
12.7.3
Schritt 2: Buildskript erstellen
12.7.4
Schritt 3: Ausführen und prüfen
12.7.5
Erkenntnisse
12.7.6
Zusatzaufgabe: Dynamische Verzeichnisse mit der Layout-API
13
Benutzerdefinierte Tasks implementieren
13.1
Anatomie eines Custom Tasks
13.2
Input/Output-Annotations und ihre Semantik
13.3
Incremental Task Execution implementieren
13.4
Task-Configuration vs. Execution-Phase
13.5
Fehlerbehandlung und Validierung
13.6
Performance-Optimierung und Caching
13.7
Übung – Eigener Custom Task mit Show-Effekt
13.7.1
Ziel
13.7.2
Schritt 1: Projekt anlegen
13.7.3
Schritt 2: Buildskript erstellen
13.7.4
Schritt 3: Ausprobieren
13.7.5
Erkenntnisse
13.7.6
Aufgabe: Eigener Validierungs-Task
14
Debugging und Testen von Gradle-Skripten
14.1
Debugging-Strategien für Build-Skripte
14.2
Remote Debugging mit IDE-Integration
14.3
Build Scans als Diagnose-Werkzeug
14.4
Unit-Testing von Custom Tasks
14.5
Functional Testing mit TestKit
14.6
Best Practices für wartbare Build-Logik
14.7
Debugging-Demo-Projekt
14.7.1
Projekt initialisieren
14.7.2
build.gradle.kts
14.7.3
src/main/java/demo/Main.java
14.7.4
src/test/java/demo/MainTest.java
14.7.5
Typische Debugging-Kommandos
14.7.6
Ergebnis
15
Best Practices zur Optimierung von Skripten
15.1
Performance-Optimierung durch Configuration Avoidance
15.2
Script-Kompilierung und Build-Cache-Nutzung
15.3
BuildSrc und Convention Plugins
15.4
Parallelisierung und Task-Avoidance
15.5
Dependency Resolution Optimierung
15.6
Code-Organisation und Modularisierung
16
Grundlagen von Build-Varianten
16.1
Konzept und Motivation
16.2
Build-Typen als Basis
16.3
Produkt-Flavors für funktionale Varianten
16.4
Source-Sets und Ressourcen-Management
16.5
Dimension-Strategien für komplexe Varianten
16.6
Abhängigkeiten und Varianten
17
Anwendung in Projekten
17.1
Praktische Einsatzszenarien
17.2
Konfiguration von Umgebungsvariablen
17.3
Multi-Modul-Projekte und Varianten
17.4
Testing-Strategien für Varianten
17.5
Migration bestehender Projekte
18
Best Practices für effiziente Variantenverwaltung
18.1
Variantenanzahl kontrollieren
18.2
Source-Set-Organisation optimieren
18.3
Build-Performance optimieren
18.4
Abhängigkeiten-Management strukturieren
18.5
Continuous Integration anpassen
18.6
Dokumentation und Team-Kommunikation
19
Verwaltung mehrerer Projekte mit Gradle
19.1
Multi-Projekt-Build-Struktur
19.2
Projekt-Konfiguration und Vererbung
19.3
Abhängigkeiten zwischen Projekten
19.4
Build-Lifecycle in Multi-Projekt-Umgebungen
19.5
Gemeinsame Ressourcen und Konfiguration
19.6
Performance-Optimierung für große Projekte
20
Verwendung eigener JDKs und Toolchains
20.1
Java Toolchain Konzept
20.2
Toolchain-Resolution und Auto-Detection
20.3
Auto-Provisioning und Download-Management
20.4
Unternehmens-spezifische JDK-Repositories
20.5
Task-spezifische Toolchain-Konfiguration
20.6
Migration zu Toolchains
20.6.1
Aufgabe: Toolchain mit Foojay-Resolver nutzen
20.6.2
Lösungsansatz für die Aufgabe
21
Best Practices für Toolchains in Multi-Projekten
21.1
Zentralisierte Toolchain-Konfiguration
21.2
Toolchain-Vererbung und Überschreibung
21.3
Performance-Optimierung bei Toolchain-Resolution
21.4
Cross-Modul Testing mit verschiedenen Java-Versionen
21.5
CI/CD-Integration und Container-Strategien
21.6
Troubleshooting und Diagnostik
22
Maven-Publish: Konfiguration von Artefakten aus Unterprojekten
22.1
Grundlagen der Maven-Publication
22.2
Konfiguration von Publications in Subprojekten
22.3
Dependency-Management zwischen publizierten Modulen
22.4
Version-Koordination und Release-Management
22.5
Repository-Konfiguration und Credential-Management
22.6
Aggregierte Publications und Release-Bundles
23
Gesamt-Deployment mit Artefakten aus Unterprojekten
23.1
Deployment-Orchestrierung in Multi-Modul-Architekturen
23.2
Artefakt-Sammlung und Aggregation
23.3
Umgebungsspezifische Deployment-Konfiguration
23.4
Container-basierte Deployment-Strategien
23.5
Rollback-Mechanismen und Versionsverwaltung
23.6
CI/CD-Pipeline-Integration
24
Testautomatisierung mit Unit- und Integrationstests
24.1
Test-Framework-Integration in Gradle
24.2
Unit-Test-Organisation und Ausführung
24.3
Integration-Test-Setup und -Management
24.4
Test-Execution-Strategies
24.5
Test-Data-Management und Fixtures
24.6
Test-Coverage und Quality-Gates
25
Testkonfigurationen und Best Practices
25.1
Test-Profile und Umgebungskonfiguration
25.2
Test-Kategorisierung und Tagging-Strategien
25.3
Flaky-Test-Management
25.4
Test-Performance-Optimierung
25.5
Test-Data-Lifecycle und Cleanup
25.6
Continuous Testing und Watch-Mode
26
Generieren und Analysieren von Testberichten
26.1
Test-Report-Formate und Generierung
26.2
Aggregierte Reports über Subprojekte
26.3
Visualisierung und Dashboards
26.4
Failure-Analysis und Reporting
26.5
Historische Trend-Analyse
27
Statische Code-Analyse und Code-Qualitätsmetriken
27.1
Integration von Code-Analyse-Tools
27.2
Regel-Konfiguration und Customization
27.3
Code-Komplexität und Metriken
27.4
Quality Gates und Enforcement
27.5
Reporting und Integration
28
Automatisierung von Builds und Deployments
28.1
Build-Automatisierung im CI/CD-Kontext
28.2
Deployment-Automatisierung mit Gradle
28.3
Pipeline-Integration und Stage-Orchestrierung
28.4
Artifact-Management und Versioning
28.5
Rollout-Strategien und Monitoring
29
Build Cache und Performanceoptimierung
29.1
Build-Cache-Architektur und Funktionsweise
29.2
Remote-Cache-Strategien
29.3
Performance-Analyse mit Build Scans
29.4
Task-Parallelisierung und Worker API
29.5
Dependency-Resolution-Optimierung
30
Gradle Scans: Nutzen, Daten und Datenschutz
30.1
Build Scans als Analyse-Instrument
30.2
Erfasste Daten und Metadaten
30.3
Datenschutz und Compliance-Aspekte
30.4
Analyse-Patterns und Insights
30.5
Enterprise Integration und Automation
31
Integration in CI-Tools (Jenkins, Travis CI, etc.) – Überblick
31.1
CI-Tool-Landschaft und Gradle-Integration
31.2
Jenkins-Integration und Pipeline-Patterns
31.3
GitHub Actions und GitLab CI Integration
31.4
Cloud-CI-Services und Container-basierte Builds
31.5
Best Practices für tool-agnostische CI-Integration
32
Überwachung und Reporting von CI-Pipelines
32.1
Pipeline-Metriken und KPIs
32.2
Real-Time-Monitoring und Alerting
32.3
Dashboard-Visualisierung und Reporting
32.4
Trend-Analyse und Predictive Analytics
32.5
Integration mit Observability-Plattformen
33
Continuous Delivery mit Gradle
33.1
Continuous Delivery Prinzipien und Gradle-Integration
33.2
Deployment-Pipeline-Automatisierung
33.3
Zero-Downtime-Deployment-Strategien
33.4
Release-Orchestrierung und Rollback
33.5
Monitoring und Feedback-Loops
34
Profiling und Diagnose von Build-Problemen
34.1
Build-Profiling-Werkzeuge und -Techniken
34.2
Performance-Bottleneck-Identifikation
34.3
Memory-Analyse und Leak-Detection
34.4
Dependency-Resolution-Diagnose
34.5
Diagnose-Automation und Reporting
35
Nutzung und Erstellung von Plugins – sinnvoller Einsatz statt Eigenentwicklung
35.1
Plugin-Ecosystem und Evaluierungskriterien
35.2
Plugin-Architektur und Best Practices
35.3
Build-Convention-Plugins vs. Feature-Plugins
35.4
Plugin-Testing und Qualitätssicherung
35.5
Plugin-Distribution und Versionierung
36
Best Practices für robuste und effiziente Gradle-Builds
36.1
Build-Strukturierung und Modularisierung
36.2
Performance-Optimierung und Build-Cache
36.3
Fehlerbehandlung und Resilience
36.4
Wartbarkeit und Dokumentation
36.5
Team-Praktiken und Continuous Improvement
37
Appendix
37.1
Der Gradle Dependency Constraints Irrtum: Warum “Constraints” nicht wirklich einschränken
37.2
Zusammenfassung
37.3
Das Problem: Wenn Constraints nicht constrainen
37.3.1
Was die Dokumentation verspricht
37.3.2
Die überraschende Realität
37.4
Die tatsächliche Prioritätshierarchie
37.4.1
Strictly vs. Constraints
37.4.2
Normale Dependencies vs. Constraints
37.5
Warum ist das problematisch?
37.5.1
1. Sicherheitsrisiken
37.5.2
2. Missverständliche Nomenklatur
37.5.3
3. Verletzung des Principle of Least Surprise
37.6
Das Metadata Publishing Problem
37.7
Alternative Lösungsansätze
37.7.1
1. Enforced Platform (Empfohlen)
37.7.2
2. Resolution Strategy
37.7.3
3. Strict Version Checking
37.7.4
4. Dependency Verification
37.8
Empfehlungen für die Praxis
37.8.1
Für Entwickler
37.8.2
Für Build-Administratoren
37.9
Folgerung
37.10
Quellen und weiterführende Literatur