Seminar Apache Grails Kompaktseminar – Full-Stack-Webentwicklung

Das Kompaktformat bietet einen schnellen, strukturierten Überblick über den vollständigen Grails-Entwicklungsweg. Es konzentriert sich auf die wichtigsten produktiven Muster und verzichtet bewusst auf tiefe Spezialthemen.

Eine kleine Geschäftsanwendung entsteht in drei Tagen vom Projektstart bis zum getesteten Artefakt. Für weiterführende Daten-, Security-, Test- oder Betriebsthemen dient das Seminar als belastbare Grundlage.

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

Zielgruppe

Entwickler mit Java-, Groovy- oder vergleichbarer Erfahrung, technische Entscheider mit Praxisbedarf und Teams vor einem Grails-Projektstart.

Voraussetzungen

Sichere Grundlagen objektorientierter Programmierung sowie elementares Verständnis von HTTP und relationalen Datenbanken.

Lernziele

• Den Grails-Entwicklungsfluss vollständig nachvollziehen.
• Die wichtigsten Groovy- und Framework-Konventionen anwenden.
• Ein kleines Datenmodell, Services und Weboberflächen erstellen.
• Einen REST-Endpunkt mit Validierung implementieren.
• Kernfunktionen testen und ein ausführbares 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: 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 8: 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 9: 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 10: 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 11: 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 kompakte Verwaltungsanwendung wird in klaren Ausbaustufen erstellt. Nach jedem Modul steht ein funktionsfähiger Zwischenstand; am Ende sind Datenmodell, Oberfläche, API, Validierung und Basistests gemeinsam ausführbar.

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.