Seminar Apache Grails Entwicklung von REST-APIs

Eine tragfähige API besteht nicht aus CRUD-Endpunkten allein. Ressourcen, Statuscodes, Fehlerformate, Berechtigungen und Versionierung bilden einen Vertrag, der von mehreren Clients dauerhaft genutzt wird.

Das Seminar entwickelt diesen Vertrag zuerst fachlich und setzt ihn anschließend mit Grails-Controllern, Services und JSON Views um. Positive und negative Testfälle begleiten jeden Implementierungsschritt.

Inhaltsverzeichnis

1. Zielgruppe
2. Voraussetzungen
3. Lernziele
4. Modul 1: REST-Ressourcen und API-Verträge entwerfen
5. Modul 2: URL-Mappings, Ressourcen und Versionierung
6. Modul 3: Datenbindung, Command Objects und Validierung
7. Modul 4: REST-Endpunkte mit Controllern und JSON Views
8. Modul 5: JSON Views und strukturierte API-Ausgaben
9. Modul 6: API-Sicherheit, CORS und Missbrauchsschutz
10. Modul 7: Vertrags-, Integrations- und Fehlertests für APIs
11. Praxisprojekt und Übungen
12. Arbeitsweise

Zielgruppe

Backend- und Full-Stack-Entwickler, API-Entwickler sowie Java- oder Spring-Entwickler mit Grails-Grundkenntnissen.

Voraussetzungen

Sichere Grundlagen in HTTP und JSON, objektorientierte Programmierung sowie grundlegende Kenntnisse von Grails-Controllern und Services.

Lernziele

• Ressourcen und HTTP-Semantik konsistent modellieren.
• REST-Endpunkte von Persistenz- und Domain-Details entkoppeln.
• JSON Views und einheitliche Fehlerformate einsetzen.
• API-Zugriffe, CORS und sensible Ausgaben absichern.
• Vertrag und Fehlerszenarien automatisiert testen.

Modul 1: 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 2: URL-Mappings, Ressourcen und Versionierung

Saubere, stabile URLs werden als Bestandteil der Anwendungsarchitektur geplant.

1. Schritt 1: Konventionelle und benutzerdefinierte URL-Mappings vergleichen.
2. Schritt 2: Ressourcen, verschachtelte Ressourcen und HTTP-Methoden modellieren.
3. Schritt 3: Namensräume oder Pfadsegmente für API-Versionen einführen.
4. Schritt 4: Mapping-Konflikte mit automatisierten Tests erkennen.

Modul 3: 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 4: 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 5: JSON Views und strukturierte API-Ausgaben

JSON-Antworten werden getrennt von Controller-Logik modelliert und für unterschiedliche Anwendungsfälle wiederverwendet.

1. Schritt 1: JSON Views mit typisiertem Modell erstellen.
2. Schritt 2: Listen, Detailansichten und verschachtelte Beziehungen kontrolliert rendern.
3. Schritt 3: Felder abhängig von Rolle, Kontext oder API-Version auswählen.
4. Schritt 4: Ausgabeformate durch automatisierte Strukturtests absichern.

Modul 6: API-Sicherheit, CORS und Missbrauchsschutz

Zugriffsschutz wird als Bestandteil des API-Vertrags und nicht als nachträglicher Filter behandelt.

1. Schritt 1: Authentifizierungsverfahren für Browser-, System- und Mobilzugriffe auswählen.
2. Schritt 2: Rollen und Berechtigungen an Ressourcen und Operationen binden.
3. Schritt 3: CORS, CSRF und sensible Fehlerausgaben korrekt konfigurieren.
4. Schritt 4: Rate-Limit-, Audit- und Schutzanforderungen in die Architektur aufnehmen.

Modul 7: Vertrags-, Integrations- und Fehlertests für APIs

API-Verhalten wird auf Struktur, Statuscodes, Berechtigungen und Rückwärtskompatibilität geprüft.

1. Schritt 1: Positive und negative Endpunkt-Tests erstellen.
2. Schritt 2: JSON-Strukturen und Pflichtfelder gezielt verifizieren.
3. Schritt 3: Authentifizierungs- und Autorisierungsfälle automatisieren.
4. Schritt 4: Änderungen am Vertrag mit Regressionstests absichern.

Praxisprojekt und Übungen

Eine kleine Ressourcen-API wird entworfen, implementiert und mit Rollen geschützt. Dazu entstehen Tests für erfolgreiche Abläufe, Validierungsfehler, fehlende Ressourcen und unzulässige Zugriffe.

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.