Seminar Apache Grails Grundlagen und Webanwendungsentwicklung

Der produktive Einstieg in Grails verlangt ein gemeinsames Verständnis von Groovy, Framework-Konventionen, Spring-Komponenten, Persistenz und Webverarbeitung. Einzelne Codebeispiele genügen nicht, wenn die Übergänge zwischen diesen Bereichen unklar bleiben.

Das Seminar entwickelt über vier Tage eine vollständige Anwendung. Neue Konzepte werden jeweils in die bestehende Lösung eingebaut, getestet und hinsichtlich ihrer Rolle in der Gesamtarchitektur eingeordnet.

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: Services und fachliche Anwendungslogik
12. Modul 9: Serverseitige Oberflächen mit GSP
13. Modul 10: REST-Endpunkte mit Controllern und JSON Views
14. Modul 11: Webschutz, Datenbindung und sichere Ausgabe
15. Modul 12: Grails-Artefakte isoliert testen
16. Modul 13: Buildvarianten, Konfiguration und Artefakte
17. Praxisprojekt und Übungen
18. Arbeitsweise

Zielgruppe

Entwickler mit Java-, Groovy- oder vergleichbarer objektorientierter Erfahrung, die vollständige Webanwendungen mit Grails entwickeln sollen.

Voraussetzungen

Sichere Grundlagen objektorientierter Programmierung, Grundkenntnisse von HTTP und relationalen Datenbanken. Vorkenntnisse in Groovy oder Grails sind nicht erforderlich.

Lernziele

• Groovy-Sprachmittel gezielt im Grails-Kontext einsetzen.
• Projektstruktur, Artefakte und MVC-Verarbeitung sicher beherrschen.
• Domänenmodelle und Datenzugriffe mit GORM implementieren.
• Services, GSP-Oberflächen und REST-Endpunkte entwickeln.
• Validierung, Sicherheit und Tests von Anfang an integrieren.
• Ein reproduzierbares Anwendungsartefakt erstellen und ausführen.

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: 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 9: 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 10: 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 11: 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 12: Grails-Artefakte isoliert testen

Controller, Domain-Klassen und andere Artefakte werden mit den passenden Grails-Testtraits geprüft.

1. Schritt 1: Testtrait und Testumgebung für das jeweilige Artefakt auswählen.
2. Schritt 2: Datenbindung, Validierung und Controller-Antworten isoliert testen.
3. Schritt 3: Service-Abhängigkeiten kontrolliert ersetzen.
4. Schritt 4: Testaufbau vereinfachen und versteckte globale Zustände vermeiden.

Modul 13: 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

Über alle vier Tage entsteht eine kleine Geschäftsanwendung mit Datenmodell, Service-Schicht, HTML-Oberfläche und REST-Schnittstelle. Die Anwendung wird validiert, abgesichert, getestet und als reproduzierbares Artefakt bereitgestellt.

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.