Seminar Apache Grails Datenzugriff mit GORM und Hibernate

GORM reduziert den Schreibaufwand erheblich, versteckt aber nicht die physikalischen Eigenschaften einer relationalen Datenbank. Ungünstige Beziehungen, unkontrolliertes Fetching oder zu breite Transaktionen werden unter realen Datenmengen schnell sichtbar.

Das Seminar verbindet die produktiven GORM-APIs mit dem notwendigen Verständnis für Hibernate, SQL und Transaktionsverhalten. Jede Modellierungsentscheidung wird anhand der erzeugten Abfragen und ihrer Betriebswirkung geprüft.

Inhaltsverzeichnis

1. Zielgruppe
2. Voraussetzungen
3. Lernziele
4. Modul 1: Domänenmodell und GORM-Mapping
5. Modul 2: Datenbindung, Command Objects und Validierung
6. Modul 3: Abfragen, Projektionen und dynamische Finder
7. Modul 4: Assoziationen, Fetching und Konsistenz
8. Modul 5: Transaktionen, Sessions und Nebenläufigkeit
9. Modul 6: Datenbank- und GORM-Performance
10. Modul 7: Datenbankschema und kontrollierte Migrationen
11. Modul 8: Integrationstests mit echter Anwendungskonfiguration
12. Praxisprojekt und Übungen
13. Arbeitsweise

Zielgruppe

Grails- und Backend-Entwickler, Datenbanknahe Softwarearchitekten sowie Java-Entwickler mit ORM-Erfahrung.

Voraussetzungen

Grails-Grundkenntnisse, sichere objektorientierte Programmierung und Grundkenntnisse relationaler Datenbanken sowie SQL.

Lernziele

• Domänenmodelle mit tragfähigen Beziehungen und Constraints entwerfen.
• Für jeden Anwendungsfall eine geeignete GORM-Abfrageform wählen.
• Fetching und Assoziationen ohne N-plus-eins-Probleme gestalten.
• Transaktionsgrenzen, Sperren und Flush-Verhalten kontrollieren.
• Schemaänderungen und Datenmigrationen reproduzierbar ausführen.

Modul 1: 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 2: 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 3: 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 4: Assoziationen, Fetching und Konsistenz

Beziehungen werden mit kontrolliertem Ladeverhalten und eindeutigen Verantwortlichkeiten implementiert.

1. Schritt 1: Owning Side, bidirektionale Beziehungen und Kaskadenregeln bestimmen.
2. Schritt 2: Lazy und eager fetching an konkreten Zugriffspfaden vergleichen.
3. Schritt 3: N-plus-eins-Probleme reproduzieren und mit Join Fetch oder Projektionen beheben.
4. Schritt 4: Lösch-, Aktualisierungs- und Validierungsregeln durch Integrationstests absichern.

Modul 5: 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 6: Datenbank- und GORM-Performance

Persistenzzugriffe werden anhand realer Abfragen, Ausführungspläne und Objektmengen optimiert.

1. Schritt 1: Langsame und häufige Abfragen aus Logs und Metriken identifizieren.
2. Schritt 2: N-plus-eins-Probleme, unnötige Joins und Volltabellenzugriffe beheben.
3. Schritt 3: Indizes und Projektionen passend zu Zugriffsmustern auswählen.
4. Schritt 4: Poolgrößen, Transaktionsdauer und Sperrkonflikte überwachen.

Modul 7: Datenbankschema und kontrollierte Migrationen

Schemaänderungen werden versioniert, geprüft und getrennt von spontanen Laufzeitänderungen ausgeführt.

1. Schritt 1: Änderungen am Domänenmodell in explizite Migrationsschritte überführen.
2. Schritt 2: Vorwärts- und Rückwärtsstrategie für kritische Änderungen festlegen.
3. Schritt 3: Migrationen gegen realistische Datenbestände testen.
4. Schritt 4: Deployment-Reihenfolge von Anwendung und Datenbank dokumentieren.

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

Praxisprojekt und Übungen

Ein fachliches Bestellmodell wird aufgebaut, mit realistischen Daten befüllt und über mehrere Abfragevarianten optimiert. Transaktionskonflikte und Schemaänderungen werden reproduziert und mit Tests 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.