Seminar Apache Grails Build, Gradle und Abhängigkeitsmanagement

Buildprobleme werden teuer, sobald das Projekt nur noch auf einzelnen Rechnern zuverlässig erstellt werden kann. Dynamische Versionen, unklare Repository-Reihenfolgen und implizite Gradle-Aufgaben erschweren Fehleranalyse und Updates.

Das Seminar zerlegt den Grails-Build in nachvollziehbare Bestandteile. Die Teilnehmenden erzeugen ein reproduzierbares Artefakt, analysieren Konflikte und entwickeln eine CI-Struktur mit eindeutigen Qualitätsgrenzen.

Inhaltsverzeichnis

1. Zielgruppe
2. Voraussetzungen
3. Lernziele
4. Modul 1: Gradle-Build und Grails-Plugins verstehen
5. Modul 2: Abhängigkeiten, BOMs und Versionskonflikte
6. Modul 3: Buildvarianten, Konfiguration und Artefakte
7. Modul 4: Buildgeschwindigkeit und Reproduzierbarkeit
8. Modul 5: CI-Pipeline, Qualitätsgrenzen und Veröffentlichung
9. Modul 6: Build, JDK und Abhängigkeiten modernisieren
10. Praxisprojekt und Übungen
11. Arbeitsweise

Zielgruppe

Grails- und Java-Entwickler, Build-Verantwortliche, DevOps-Fachkräfte und technische Projektleiter.

Voraussetzungen

Grundkenntnisse in Java oder Groovy sowie Erfahrung mit einem Grails- oder Spring-Boot-Projekt. Elementare Gradle-Kenntnisse sind hilfreich, aber nicht zwingend.

Lernziele

• Grails- und Gradle-Plugins sowie ihre Aufgaben sicher einordnen.
• Transitive Abhängigkeiten und Versionskonflikte systematisch analysieren.
• BOMs und feste Versionierungsregeln einsetzen.
• Reproduzierbare, überprüfbare Build-Artefakte erzeugen.
• Buildlaufzeit und CI-Ablauf auf Grundlage von Messdaten verbessern.

Modul 1: Gradle-Build und Grails-Plugins verstehen

Der erzeugte Build wird nicht als Blackbox behandelt, sondern in Aufgaben, Plugins und Konfigurationen zerlegt.

1. Schritt 1: Wrapper, Settings, Buildskripte und Versionsparameter prüfen.
2. Schritt 2: Grails- und Spring-Boot-Gradle-Plugins ihren Aufgaben zuordnen.
3. Schritt 3: Wichtige Build-, Test- und Ausführungsaufgaben nachvollziehen.
4. Schritt 4: Eigene Aufgaben ohne Seiteneffekte in den Build integrieren.

Modul 2: Abhängigkeiten, BOMs und Versionskonflikte

Bibliotheksversionen werden über nachvollziehbare Regeln und kompatible Plattformen gesteuert.

1. Schritt 1: Direkte und transitive Abhängigkeiten untersuchen.
2. Schritt 2: BOMs und Dependency Constraints zur Versionssteuerung einsetzen.
3. Schritt 3: Konflikte und unerwartete Varianten mit Gradle-Berichten analysieren.
4. Schritt 4: Repositories und Abhängigkeitsquellen auf notwendige Einträge begrenzen.

Modul 3: Buildvarianten, Konfiguration und Artefakte

Lokale Entwicklung, Tests und Produktion erhalten klar getrennte, reproduzierbare Buildpfade.

1. Schritt 1: Eigenschaften und Umgebungsparameter vom eigentlichen Build trennen.
2. Schritt 2: Ausführbares Archiv und optionales Container-Artefakt erzeugen.
3. Schritt 3: Buildinformationen und Versionskennzeichnung einbetten.
4. Schritt 4: Artefakte auf Vollständigkeit und unbeabsichtigte Inhalte prüfen.

Modul 4: Buildgeschwindigkeit und Reproduzierbarkeit

Lange oder instabile Builds werden anhand messbarer Ursachen verbessert.

1. Schritt 1: Buildscan- oder Profilinformationen ohne vertrauliche Daten auswerten.
2. Schritt 2: Caching, inkrementelle Aufgaben und parallele Ausführung korrekt einsetzen.
3. Schritt 3: Nicht deterministische Schritte und dynamische Versionen beseitigen.
4. Schritt 4: Eine saubere Build-Ausführung in einer frischen Umgebung nachweisen.

Modul 5: CI-Pipeline, Qualitätsgrenzen und Veröffentlichung

Der Build wird in überprüfbare Stufen mit eindeutigen Abbruchkriterien gegliedert.

1. Schritt 1: Kompilierung, Unit-Tests, Integrationstests und Artefakterzeugung trennen.
2. Schritt 2: Abhängigkeits-, Lizenz- und Sicherheitsprüfungen einplanen.
3. Schritt 3: Artefakte unveränderlich kennzeichnen und weiterreichen.
4. Schritt 4: Freigabe- und Rückrollregeln für nachgelagerte Deployments festlegen.

Modul 6: Build, JDK und Abhängigkeiten modernisieren

Die technische Basis wird schrittweise aktualisiert, bevor fachliche Änderungen zugelassen werden.

1. Schritt 1: Ziel-JDK und Toolchain in Entwicklung und CI vereinheitlichen.
2. Schritt 2: Gradle Wrapper, Plugins und Repository-Konfiguration aktualisieren.
3. Schritt 3: Abhängigkeiten über kompatible Plattformen und feste Versionen ausrichten.
4. Schritt 4: Nach jedem Schritt einen sauberen Build und Start nachweisen.

Praxisprojekt und Übungen

Ein absichtlich fehleranfälliger Build wird bereinigt. Abhängigkeitskonflikte, dynamische Versionen und unnötige Tasks werden entfernt; anschließend wird eine mehrstufige CI-Ausführung mit wiederverwendbarem Artefakt entworfen.

Arbeitsweise

Kurze fachliche Einführungen wechseln mit Demonstrationen, angeleiteten Implementierungsschritten, selbstständigen Übungen und gemeinsamer Auswertung. Entscheidungen werden im Code, in Tests und in einer knappen technischen Dokumentation nachvollziehbar festgehalten.