Seminar Apache Grails Plugin-Entwicklung und Framework-Erweiterung

Ein Plugin ist eine öffentliche technische Schnittstelle. Unklare Abhängigkeiten, versteckte Seiteneffekte oder fehlende Kompatibilitätsregeln verlagern Aufwand von einem Projekt auf viele Projekte.

Das Seminar entwirft deshalb zuerst Zielgruppe, API und Versionsrahmen. Anschließend wird eine Erweiterung implementiert, in einer Beispielanwendung getestet und als reproduzierbares Artefakt veröffentlicht.

Inhaltsverzeichnis

1. Zielgruppe
2. Voraussetzungen
3. Lernziele
4. Modul 1: Grails-Plugin anlegen und strukturieren
5. Modul 2: Gradle-Build und Grails-Plugins verstehen
6. Modul 3: Laufzeit-Hooks, Beans und Konventionen erweitern
7. Modul 4: Spring-Komponenten und Dependency Injection
8. Modul 5: Abhängigkeiten, Kompatibilität und Veröffentlichung
9. Modul 6: Unit-Tests mit Spock
10. Modul 7: Integrationstests mit echter Anwendungskonfiguration
11. Modul 8: Dokumentation, Beispiele und Wartbarkeit
12. Praxisprojekt und Übungen
13. Arbeitsweise

Zielgruppe

Erfahrene Grails- und Groovy-Entwickler, Framework-Verantwortliche, Plattformteams und Architekten gemeinsamer Unternehmenskomponenten.

Voraussetzungen

Sichere Grails-Kenntnisse, Erfahrung mit Spring Beans, Gradle und automatisierten Tests. Groovy-Kenntnisse werden vorausgesetzt.

Lernziele

• Plugin-Typ, Zielversionen und öffentliche API sauber festlegen.
• Beans, Konfiguration und Lebenszyklus-Hooks kontrolliert bereitstellen.
• Erweiterungen ohne globale Seiteneffekte implementieren.
• Kompatibilität mit Tests und Beispielanwendungen nachweisen.
• Versionierung, Dokumentation und Veröffentlichung professionell organisieren.

Modul 1: Grails-Plugin anlegen und strukturieren

Eine wiederverwendbare Erweiterung wird mit klarer Zielversion, API und minimalen Abhängigkeiten aufgebaut.

1. Schritt 1: Plugin- oder Web-Plugin-Profil passend auswählen.
2. Schritt 2: Metadaten, Packages und öffentliche Schnittstellen definieren.
3. Schritt 3: Artefakte, Konfiguration und Ressourcen sauber trennen.
4. Schritt 4: Plugin lokal in einer Beispielanwendung einbinden.

Modul 2: 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 3: Laufzeit-Hooks, Beans und Konventionen erweitern

Framework-Erweiterungen werden über dokumentierte Lebenszyklus- und Registrierungspunkte umgesetzt.

1. Schritt 1: Beans und Konfiguration im Plugin bereitstellen.
2. Schritt 2: Artefakte oder Hilfs-APIs nur bei echtem Bedarf ergänzen.
3. Schritt 3: Start- und Änderungsereignisse ohne globale Seiteneffekte behandeln.
4. Schritt 4: Konflikte mit Anwendungskonfiguration und anderen Plugins testen.

Modul 4: Spring-Komponenten und Dependency Injection

Grails-Konventionen und Spring-Mechanismen werden so kombiniert, dass die Anwendung transparent und testbar bleibt.

1. Schritt 1: Grails-Artefakte und reguläre Spring Beans voneinander abgrenzen.
2. Schritt 2: Beans über Annotationen oder programmatische Konfiguration registrieren.
3. Schritt 3: Konfigurationseigenschaften typisiert an Komponenten binden.
4. Schritt 4: Lebenszyklen, Scopes und Initialisierungsreihenfolgen gezielt prüfen.

Modul 5: Abhängigkeiten, Kompatibilität und Veröffentlichung

Das Plugin erhält einen reproduzierbaren Build und eine nachvollziehbare Kompatibilitätsstrategie.

1. Schritt 1: Grails-Versionen und optionale Abhängigkeiten einschränken.
2. Schritt 2: Unit-, Integrations- und Beispielanwendungstests ausführen.
3. Schritt 3: Versionsschema, Changelog und Upgrade-Hinweise pflegen.
4. Schritt 4: Artefakt in ein internes oder freigegebenes Maven-Repository veröffentlichen.

Modul 6: Unit-Tests mit Spock

Kleine fachliche Einheiten werden mit lesbaren Spezifikationen und klaren Testdoubles geprüft.

1. Schritt 1: Given-when-then-Strukturen für Services und Hilfsklassen formulieren.
2. Schritt 2: Mocks, Stubs und Spies nur entsprechend ihrer Aufgabe einsetzen.
3. Schritt 3: Tabellentests für Varianten und Randfälle entwickeln.
4. Schritt 4: Fehlerpfade und Interaktionen ohne unnötigen Framework-Start testen.

Modul 7: Integrationstests mit echter Anwendungskonfiguration

Zusammenspiel von Persistenz, Transaktionen, Spring-Kontext und Webschicht wird realitätsnah überprüft.

1. Schritt 1: Integrationsprofil und Testdaten reproduzierbar konfigurieren.
2. Schritt 2: Services und GORM gegen eine echte Testdatenbank prüfen.
3. Schritt 3: Transaktionsverhalten und Rollback bewusst kontrollieren.
4. Schritt 4: Langsame Tests strukturieren und von schnellen Tests trennen.

Modul 8: Dokumentation, Beispiele und Wartbarkeit

Nutzer des Plugins erhalten klare Konfiguration, stabile Beispiele und erkennbare Fehlermeldungen.

1. Schritt 1: Minimalbeispiel und typische Konfigurationsvarianten erstellen.
2. Schritt 2: Fehlkonfiguration beim Start mit verständlichen Meldungen erkennen.
3. Schritt 3: Öffentliche API von internen Klassen trennen.
4. Schritt 4: Kompatibilität mit einer Testmatrix automatisiert überwachen.

Praxisprojekt und Übungen

Ein wiederverwendbares Audit- oder Infrastruktur-Plugin wird erstellt, konfiguriert und in zwei Beispielanwendungen eingebunden. Eine Testmatrix prüft Konfiguration, Laufzeitverhalten und Fehlermeldungen.

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.