Architektur, die bewohnbar bleibt
Gedanken zu Jakarta EE, Scala, UI-Architektur und der stillen Arbeit an langlebigen Systemen.
Eine vollständige Webanwendung mit Scala entwickeln
Eine praxisnahe Reihe, in der aus einem leeren Repository ein bereitgestellter Blog mit Scala, Scala.js und PostgreSQL entsteht. Zum Einstieg geht es um die Funktionen, den Technologie-Stack und den Weg einer Anfrage.
Vom leeren Verzeichnis zum lauffähigen Projekt
Wir erstellen die erste funktionierende Version unseres Scala-Blogs: sbt-Build einrichten, Undertow, RESTEasy und CDI verbinden und den HTTP-Endpunkt mit einem echten Integrationstest prüfen.
Einen HTTP-Server mit Jakarta-Komponenten starten
Undertow, RESTEasy und Weld über die CDI-Erkennung verbinden, einen Endpunkt für die Erreichbarkeit ergänzen, den Weg einer Anfrage durch ihre Gültigkeitsbereiche verfolgen und Registrierung sowie Aufräumen mit echten HTTP-Tests prüfen.
Datenbankzugriff und Transaktionen verstehen
PostgreSQL, Hibernate, Agroal und Narayana verbinden. Einen Persistence Context bis zur Serialisierung der Antwort offen halten und Commit sowie Rollback mit echten Datenbanktests prüfen.
Unser erstes Domänenmodell
BlogPost mit UUID, Version, eindeutigem Slug und Veröffentlichungsregeln modellieren. Entitäten über CDI finden, in PostgreSQL abbilden und Validierung sowie optimistisches Locking prüfen.
Das Datenmodell weiterentwickeln
Ein bestehendes PostgreSQL-Schema mit Hibernate DDL Manager übernehmen, Tabellen und Spalten stabile Identitäten geben und eine optionale Zusammenfassung ergänzen, ohne Artikel oder Veröffentlichungsregeln zu verlieren.
Eine Entität mit EntitySchema beschreiben
Ein gemeinsames Feldmodell für JSON-Mapping und typisierte Criteria-Abfragen definieren. Alle BlogPost-Felder abdecken, Zeitstempel erhalten und prüfen, dass lesbare Felder vor eingehenden Änderungen geschützt bleiben.
Artikel über REST bereitstellen
Das BlogPost-Modell als öffentliche API anbieten. Mit Entity-Graphen, JSON-Mapper und Data/Table-Antworten veröffentlichte Listen und Details ausgeben und den Vertrag durch echte HTTP-Anfragen prüfen.
Die erste Oberfläche mit Scala.js entwickeln
Mit der Komponenten-DSL von Scala.js UI ein lesbares Journal bauen. Properties, Bedingungen und Listen binden, die Seite über Undertow ausliefern und Tastaturbedienung sowie mobiles Layout in einem echten Browser prüfen.
Frontend und Backend verbinden
Veröffentlichte Artikel in Scala.js-Modelle laden, Routen-Loader mit der REST-API verbinden und leere Listen, fehlgeschlagene Anfragen und Navigation behandeln, ohne den Entity-Vertrag zu verlieren.
Benutzerkonten und Anmeldung
Den ersten Administrator anlegen und Soteria in Undertow integrieren: Passwortanmeldung, geschützte Sitzungen und ein Kontoformular mit Scala.js.
Registrierung und Kontowiederherstellung
Den Besitz einer E-Mail-Adresse vor dem Anlegen eines Leserkontos bestätigen, einmalig nutzbare Links versenden und Passwörter zurücksetzen, wobei bestehende Sitzungen widerrufen werden.
Berechtigungen und HATEOAS
Berechtigungen für Endpunkte, Objekte und Felder durchsetzen. Die Redaktionsoberfläche folgt den Aktionen, die jede Antwort anbietet.
Änderungen sicher anwenden
Änderungen an Entitäten vor der Mutation vorbereiten, aktuelle Versionen erzwingen, das vollständige Ergebnis validieren und hilfreiche Fehler zurückgeben, ohne die Atomarität zu verlieren.
Ein Formular vom Anfang bis zum Ende entwickeln
Das Artikelmodell direkt an ein Formular binden, Feldfehler anzeigen und neuere Eingaben erhalten, wenn Speicherantworten oder Konflikte eintreffen.
Suchen, filtern und paginieren
Mit HibernateSearch und CDI-Providern typisierte Filter, kompakte Listenprojektionen und URL-gesteuerte Paginierung entwickeln, die Neuladen und Browserverlauf übersteht.
Entitätsbeziehungen verwalten
Autoren und Tags als gemeinsam genutzte Entitäten modellieren, sichere ID-Referenzen annehmen und Beziehungen kontrolliert über API und Formular aktualisieren.
Medien hochladen und ausliefern
Bilder sicher hochladen, als Artikelreferenzen speichern, jeden Abruf anhand der Sichtbarkeit autorisieren und zurückgelassene Uploads sicher bereinigen.
Einen Artikel-Editor integrieren
Einen Markdown-Editor in das Artikelformular integrieren, Uploads und Referenzen absichern und Vorschau sowie öffentliche Leseansicht gemeinsam darstellen.
Die Benutzeroberfläche übersetzen
Englische und deutsche Routen, Nachrichtenkatalog und Sprachwechsel ergänzen und dabei Formularzustand sowie redaktionelle Inhalte erhalten.
Blog-Inhalte übersetzen
Deutsche Artikelfassungen separat veröffentlichen, Suche und Sprachwahl abstimmen und bei fehlender Übersetzung vollständig auf Englisch zurückfallen.
Seiten auf dem Server rendern
Den vorhandenen Scala.js-Blog mit GraalJS rendern, damit lokalisierte Beiträge als vollständiges HTML mit passendem HTTP-Status ankommen.
Die serverseitig gerenderte Seite hydrieren
Den Server-DOM erhalten, seine öffentliche Anfangsantwort einmal wiederverwenden und Interaktivität ohne erneuten Datenabruf aktivieren.
Die öffentlichen Seiten vervollständigen
Den Blog mit konsistenten Metadaten, veröffentlichten Sprachvarianten, Sitemap, Atom-Feeds und passenden HTTP-Antworten abschließen.