Seminar Groovy für Apache-Grails-Entwickler

Java-Entwickler können Grails-Code schnell lesen, schreiben aber häufig unnötig umständlichen oder zu dynamischen Groovy-Code. Produktiver Einsatz verlangt ein bewusstes Gleichgewicht zwischen Ausdrucksstärke, Typensicherheit und Wartbarkeit.

Das Seminar konzentriert sich auf Sprachmittel, die in Controller-, Service-, Domain- und Testklassen unmittelbar eingesetzt werden. Unkontrollierte Metaprogrammierung wird klar von sinnvollen Framework-DSLs abgegrenzt.

Inhaltsverzeichnis

1. Zielgruppe
2. Voraussetzungen
3. Lernziele
4. Modul 1: Groovy-Grundlagen für produktiven Grails-Code
5. Modul 2: Statische Typisierung, Traits und Metaprogrammierung
6. Modul 3: Projektstruktur, Artefakte und Konventionen
7. Modul 4: Datenbindung, Command Objects und Validierung
8. Modul 5: Services und fachliche Anwendungslogik
9. Modul 6: Unit-Tests mit Spock
10. Praxisprojekt und Übungen
11. Arbeitsweise

Zielgruppe

Java-, Kotlin- oder andere JVM-Entwickler, die Grails-Projekte entwickeln oder warten sollen, sowie Grails-Einsteiger mit unsicheren Groovy-Kenntnissen.

Voraussetzungen

Sichere Grundlagen objektorientierter Programmierung. Java-Kenntnisse sind hilfreich; Groovy- oder Grails-Vorkenntnisse sind nicht erforderlich.

Lernziele

• Groovy-Syntax und Collections idiomatisch einsetzen.
• Closures und DSL-artige APIs sicher lesen und schreiben.
• Dynamische und statisch typisierte Bereiche bewusst wählen.
• Traits und Erweiterungsmethoden wartbar verwenden.
• Groovy-Code nahtlos mit Java-Bibliotheken kombinieren.
• Kleine Einheiten mit Spock verständlich testen.

Modul 1: Groovy-Grundlagen für produktiven Grails-Code

Die für Grails wesentlichen Sprachmittel werden anhand typischer Controller-, Service- und Domänenklassen erarbeitet.

1. Schritt 1: Variablen, Datentypen, Operatoren, Strings und Collections praktisch anwenden.
2. Schritt 2: Closures, optionale Parameter und benannte Argumente in Framework-APIs einsetzen.
3. Schritt 3: Null-Sicherheit, Elvis-Operator und sichere Navigation gezielt verwenden.
4. Schritt 4: Groovy-Code mit Java-Bibliotheken und bestehenden Java-Klassen kombinieren.

Modul 2: Statische Typisierung, Traits und Metaprogrammierung

Dynamische Sprachmittel werden gegen Wartbarkeit, Tool-Unterstützung und Laufzeitrisiken abgewogen.

1. Schritt 1: Typinferenz, CompileStatic und TypeChecked anhand realer Klassen vergleichen.
2. Schritt 2: Traits und Erweiterungsmethoden für wiederverwendbares Verhalten einsetzen.
3. Schritt 3: AST-Transformationen und Grails-eigene Transformationen technisch einordnen.
4. Schritt 4: Dynamische Metaprogrammierung auf klar abgegrenzte, testbare Einsatzfälle begrenzen.

Modul 3: Projektstruktur, Artefakte und Konventionen

Die Verzeichnisstruktur und die Lebenszyklen der wichtigsten Grails-Artefakte werden systematisch erschlossen.

1. Schritt 1: Controller, Services, Domain-Klassen, Tag Libraries und Konfiguration lokalisieren.
2. Schritt 2: Artefakte über Grails Shell und Gradle-Aufgaben erzeugen und prüfen.
3. Schritt 3: Namenskonventionen, Packages und Komponenten-Scanning sauber festlegen.
4. Schritt 4: Eigene Quellbereiche und gemeinsame Bibliotheken ohne Konventionsbruch integrieren.

Modul 4: Datenbindung, Command Objects und Validierung

Eingabedaten werden nur in ausdrücklich freigegebene Strukturen gebunden und fachlich validiert.

1. Schritt 1: Bindungsquellen und zulässige Felder festlegen.
2. Schritt 2: Command Objects mit deklarativen Constraints entwerfen.
3. Schritt 3: Verschachtelte Daten, Datumswerte und Aufzählungen sicher konvertieren.
4. Schritt 4: Validierungsfehler internationalisierbar und testsicher aufbereiten.

Modul 5: Services und fachliche Anwendungslogik

Services werden als klar definierte fachliche Schnittstellen mit kontrollierten Abhängigkeiten aufgebaut.

1. Schritt 1: Service-Verantwortlichkeiten aus Anwendungsfällen ableiten.
2. Schritt 2: Abhängigkeiten über Konstruktor- oder Framework-Injection bereitstellen.
3. Schritt 3: Transaktionsgrenzen und Rückgabemodelle explizit festlegen.
4. Schritt 4: Services mit Unit- und Integrationstests unabhängig von Controllern prüfen.

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.

Praxisprojekt und Übungen

Typische Java-nahe Grails-Klassen werden schrittweise in klaren Groovy-Code überführt. Collections, Closures, Traits und Typisierung werden verglichen und mit Spock-Spezifikationen abgesichert.

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.