Seminar Apache Grails Intensivseminar – Anwendungsentwicklung

Dieser Intensivpfad ist für Teams gedacht, die in einer Woche eine gemeinsame, belastbare Entwicklungsbasis benötigen. Er ersetzt keine spätere Spezialisierung, deckt aber den vollständigen Weg von der Projektanlage bis zur getesteten Anwendung ab.

Die Inhalte verdichten die Seminare zu Groovy, Grundlagen, GORM, Services, Frontend, REST und Testing. Sämtliche Übungen greifen auf ein gemeinsames Projekt zurück, damit Übergänge und Abhängigkeiten sichtbar bleiben.

Inhaltsverzeichnis

1. Zielgruppe
2. Voraussetzungen
3. Lernziele
4. Modul 1: Framework, Laufzeit und Projektökosystem einordnen
5. Modul 2: Entwicklungsumgebung und Projektstart
6. Modul 3: Groovy-Grundlagen für produktiven Grails-Code
7. Modul 4: Projektstruktur, Artefakte und Konventionen
8. Modul 5: MVC-Ablauf und Verarbeitung einer Webanfrage
9. Modul 6: Domänenmodell und GORM-Mapping
10. Modul 7: Abfragen, Projektionen und dynamische Finder
11. Modul 8: Transaktionen, Sessions und Nebenläufigkeit
12. Modul 9: Services und fachliche Anwendungslogik
13. Modul 10: Serverseitige Oberflächen mit GSP
14. Modul 11: REST-Ressourcen und API-Verträge entwerfen
15. Modul 12: REST-Endpunkte mit Controllern und JSON Views
16. Modul 13: Webschutz, Datenbindung und sichere Ausgabe
17. Modul 14: Unit-Tests mit Spock
18. Modul 15: Integrationstests mit echter Anwendungskonfiguration
19. Modul 16: Browser- und Funktionstests mit Geb und Testcontainers
20. Modul 17: Buildvarianten, Konfiguration und Artefakte
21. Praxisprojekt und Übungen
22. Arbeitsweise

Zielgruppe

Entwicklerteams mit Java-, Groovy- oder Spring-Hintergrund, die kurzfristig produktiv in die Grails-Anwendungsentwicklung einsteigen sollen.

Voraussetzungen

Sichere objektorientierte Programmierung, Grundkenntnisse von HTTP und SQL. Erfahrung mit Java oder Groovy ist erforderlich; Grails-Vorkenntnisse sind nicht notwendig.

Lernziele

• Eine Grails-Anwendung von Grund auf strukturieren und entwickeln.
• Groovy, MVC, GORM und Services als zusammenhängende Plattform nutzen.
• HTML-Oberfläche und REST-API auf derselben Fachlogik aufbauen.
• Validierung und Basissicherheit konsequent integrieren.
• Unit-, Integrations- und Browsertests erstellen.
• Ein geprüftes, reproduzierbares Build-Artefakt erzeugen.

Modul 1: Framework, Laufzeit und Projektökosystem einordnen

Das Zusammenspiel von Apache Grails, Groovy, Spring Boot, Gradle, GORM und den zentralen Grails-Plugins wird als technische Gesamtarchitektur betrachtet.

1. Schritt 1: Die Aufgaben von Framework, Laufzeit, Buildsystem und Persistenzschicht voneinander abgrenzen.
2. Schritt 2: Anwendungsprofile, Konventionen und Erweiterungspunkte einer Grails-Anwendung zuordnen.
3. Schritt 3: Die Abhängigkeiten zwischen Java-Version, Grails-Version, Groovy, Spring Boot und GORM erfassen.
4. Schritt 4: Für ein Beispielprojekt eine belastbare Technologie- und Versionsmatrix erstellen.

Modul 2: Entwicklungsumgebung und Projektstart

Eine reproduzierbare Arbeitsumgebung wird eingerichtet und mit einem neu erzeugten Projekt verifiziert.

1. Schritt 1: JDK, Grails Wrapper, Gradle Wrapper und IDE-Konfiguration prüfen.
2. Schritt 2: Ein Projekt mit geeignetem Profil und den benötigten Features erzeugen.
3. Schritt 3: Anwendung, Tests und interaktive Grails Shell kontrolliert starten.
4. Schritt 4: Lokale Konfiguration so dokumentieren, dass das Projekt auf einem zweiten System identisch läuft.

Modul 3: 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 4: 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 5: MVC-Ablauf und Verarbeitung einer Webanfrage

Eine Webanfrage wird vom URL-Mapping über Controller und Service bis zur Antwort vollständig verfolgt.

1. Schritt 1: URL-Mappings und HTTP-Methoden einer fachlichen Ressource zuordnen.
2. Schritt 2: Parameterbindung, Command Objects und Validierung kontrolliert einsetzen.
3. Schritt 3: Geschäftslogik aus dem Controller in Services verlagern.
4. Schritt 4: HTML-, JSON- und Fehlerantworten mit eindeutigen Statuscodes erzeugen.

Modul 6: Domänenmodell und GORM-Mapping

Fachliche Modelle werden so entworfen, dass Persistenz, Validierung und spätere Erweiterbarkeit zusammenpassen.

1. Schritt 1: Domain-Klassen, Identitäten und Wertobjekte aus fachlichen Anforderungen ableiten.
2. Schritt 2: Assoziationen und Kardinalitäten explizit modellieren.
3. Schritt 3: Constraints, Mapping-Block und Datenbanknamen festlegen.
4. Schritt 4: Das resultierende Schema prüfen und typische Modellierungsfehler korrigieren.

Modul 7: Abfragen, Projektionen und dynamische Finder

GORM-Abfragen werden nach Lesbarkeit, Ausdrucksstärke und erzeugtem Datenbankzugriff ausgewählt.

1. Schritt 1: Dynamische Finder und Where Queries für einfache Fälle einsetzen.
2. Schritt 2: Kriterienabfragen und HQL für komplexe Filter entwickeln.
3. Schritt 3: Projektionen, Sortierung und Pagination effizient gestalten.
4. Schritt 4: Erzeugte SQL-Anweisungen analysieren und unnötige Datenzugriffe beseitigen.

Modul 8: Transaktionen, Sessions und Nebenläufigkeit

Transaktionsgrenzen werden aus fachlichen Operationen abgeleitet und nicht dem Zufall einzelner Datenzugriffe überlassen.

1. Schritt 1: Transaktionale Service-Methoden und Read-only-Operationen unterscheiden.
2. Schritt 2: Flush-Verhalten, Dirty Checking und Session-Lebenszyklus nachvollziehen.
3. Schritt 3: Optimistische und pessimistische Sperren für Konfliktsituationen bewerten.
4. Schritt 4: Rollback, Wiederholung und Fehlerbehandlung mit Tests überprüfen.

Modul 9: 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 10: Serverseitige Oberflächen mit GSP

Groovy Server Pages werden für wartbare, zugängliche und wiederverwendbare HTML-Oberflächen eingesetzt.

1. Schritt 1: Modelldaten ohne Geschäftslogik in GSP ausgeben.
2. Schritt 2: Layouts, Templates und Tag Libraries zur Wiederverwendung strukturieren.
3. Schritt 3: Formulare mit Validierungshinweisen und sicherer Ausgabe erstellen.
4. Schritt 4: Internationalisierung, Navigation und Fehlerdarstellung konsistent integrieren.

Modul 11: REST-Ressourcen und API-Verträge entwerfen

Die API wird aus fachlichen Ressourcen, Zustandsübergängen und klaren Fehlerfällen abgeleitet.

1. Schritt 1: Ressourcen, Identitäten und Beziehungen festlegen.
2. Schritt 2: HTTP-Methoden, Statuscodes und Idempotenz konsistent zuordnen.
3. Schritt 3: Request- und Response-Modelle von internen Domain-Klassen trennen.
4. Schritt 4: Versionierungs-, Pagination- und Filterstrategie dokumentieren.

Modul 12: REST-Endpunkte mit Controllern und JSON Views

Die entworfenen Verträge werden mit Grails-Mitteln umgesetzt, ohne Persistenzdetails nach außen durchzureichen.

1. Schritt 1: Ressourcenorientierte URL-Mappings und Controller erzeugen.
2. Schritt 2: Command Objects für eingehende Daten und Service-Aufrufe einsetzen.
3. Schritt 3: JSON Views oder Renderer für konsistente Ausgaben erstellen.
4. Schritt 4: Fehler, Validierung und nicht gefundene Ressourcen einheitlich behandeln.

Modul 13: Webschutz, Datenbindung und sichere Ausgabe

Typische Webrisiken werden durch Framework-Konfiguration und disziplinierte Implementierung reduziert.

1. Schritt 1: CSRF-Schutz und sichere Cookie-Eigenschaften prüfen.
2. Schritt 2: XSS durch kontextgerechte Ausgabe und restriktive Eingabeverarbeitung verhindern.
3. Schritt 3: Datenbindung auf erlaubte Felder begrenzen.
4. Schritt 4: Sicherheitsrelevante Header und Fehlerseiten konfigurieren.

Modul 14: 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 15: 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 16: Browser- und Funktionstests mit Geb und Testcontainers

Kritische Benutzerwege werden in einer reproduzierbaren Browserumgebung automatisiert.

1. Schritt 1: Geb-Seitenobjekte und Module für stabile Selektoren entwerfen.
2. Schritt 2: Containerisierte Browser für identische lokale und CI-Ausführung nutzen.
3. Schritt 3: Anmeldung, Formularabläufe und Fehlersituationen automatisieren.
4. Schritt 4: Screenshots, Aufzeichnungen und Diagnosedaten bei Fehlern sichern.

Modul 17: 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.

Praxisprojekt und Übungen

Eine vollständige Anwendung wird iterativ aufgebaut. Jeder Tag endet mit einem lauffähigen Zwischenstand; am fünften Tag werden HTML-Oberfläche, API, Persistenz, Sicherheit und automatisierte Tests in einem gemeinsamen Release-Kandidaten zusammengeführt.

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.