Übungsaufgaben zur Anmeldung mit Keycloak: Mitfahrgesuche nach Rolle

Übungsaufgaben zur Anmeldung mit Keycloak: Mitfahrgesuche nach Rolle

https://bildung.social/@oerinformatik/

https://oer-informatik.de/javafx-anmeldung-keycloak-uebungsaufgaben

JavaFX, Keycloak, OAuth 2.0, OpenID Connect, PKCE, native App, Loopback-Redirect, Refresh Token, Rollen, Fehlersuche, Übungsaufgaben, Prüfungsvorbereitung

tl/dr; (Bearbeitungszeit insgesamt 56 min, mehrere Aufgaben): Übungen zur Anmeldung der JavaFX-Desktop-App über Keycloak: Du ordnest die Schritte des Authorization Code Flow mit PKCE und ordnest Werte und Tokens zu, steuerst das Gesuche-Fenster nach Rolle, schreibst einen Token-Speicher, der rechtzeitig erneuert, und findest die Ursachen von Redirect- und Token-Fehlern anhand ihrer Meldungen [AI-Assisted]. (Zuletzt geändert am 11.11.2026)

Dieser Artikel ist Teil einer Artikelreihe über eine Desktop-App mit JavaFX: Übersicht / Kanban-Projektstart / Projekt anlegen / FXML, Layouts und CSS / Properties, Bindings und MVVM / Backend anbinden / TableView für Buchungen / Formulare und Dialoge / Anmeldung mit Keycloak / Verwaltung und Diagramme / GUI-Tests mit TestFX / Abnahmetest und Kanban-Metriken / Paketieren mit jpackage

Diese Übungsaufgaben gehören zum Artikel Anmeldung einer Desktop-App mit Keycloak: Authorization Code mit PKCE über den Systembrowser. Sie spielen im Projekt Mitfahrlabor und führen den Strang der Mitfahrgesuche weiter: Seit den Übungen zu Formularen und Dialogen können Mitfahrende im Gesuche-Fenster selbst ein Gesuch eintragen. Jetzt soll das Fenster wissen, wer angemeldet ist.

Hinweise zur Bearbeitung: Bis zur Teil-1-Prüfung der IT-Berufe solltest Du die Basiskompetenz beherrschen, also Aufgabe 1.1. Als FIA, FIDP oder FIDV musst Du zur Teil-2-Prüfung Aufgaben auf Kernkompetenz-Ebene lösen können, das sind Aufgabe 2.1 und Aufgabe 2.2. Von FIA wird zusätzlich erwartet, dass ihnen Aufgaben auf Profilkompetenz-Ebene (Aufgabe 3.1) keine Probleme bereiten. Als Startcode für die Aufgaben 2.1 und 2.2 dient der Code-Stand src/07-formulare-dialoge/uebung-mitfahrgesuche mit Deinem GesucheViewModel aus den letzten Übungen; das Paket …desktop.anmeldung übernimmst Du aus dem Code-Stand des Artikels (src/08-anmeldung-keycloak/mitfahrlabor-desktop), dazu requires jdk.httpserver; in module-info.java. Eine vollständige Beispiellösung mit allen Tests liegt unter src/08-anmeldung-keycloak/uebung-mitfahrgesuche. Code-Aufgaben löst Du am besten am Rechner und prüfst sie mit gradlew test (bzw. mvnw test); für Aufgabe 3.1 brauchst Du kein laufendes Keycloak. Die Operatoren (nennen, beschreiben, erläutern, beurteilen …) sind im Artikel Wie sind die Aufgaben aufgebaut? erklärt. Schreib Deine Lösung zuerst vollständig auf, bevor Du die Beispiellösung aufklappst.

Du möchtest eigene Aufgaben zum Üben von einem KI-Sprachmodell generieren lassen? Prompt ein-/ausblenden

Erstelle neue Übungsaufgaben zum Thema „Anmeldung mit Keycloak:
Mitfahrgesuche nach Rolle“.

Bauplan: Halte Dich an Aufbau, Kompetenzstufen, Operatoren,
Anforderungsbereiche, Punkte und Zeitschätzung, die im Artikel
https://oer-informatik.de/aufgaben-aufbau beschrieben sind.

Fachliche Grundlage:
- https://oer-informatik.de/javafx-anmeldung-keycloak
- https://oer-informatik.de/szenario-mitfahrlabor
- https://oer-informatik.de/javafx-kanban-projektstart
- Stilbeispiel: https://oer-informatik.de/javafx-anmeldung-keycloak-uebungsaufgaben

Die Aufgaben sollen Inhalte zu diesen Schlagwörtern abdecken:
- JavaFX
- Keycloak
- OAuth 2.0
- OpenID Connect
- PKCE
- native App
- Loopback-Redirect
- Refresh Token
- Rollen
- Fehlersuche

Kompetenzstufe: Kernkompetenz (alternativ: Basiskompetenz, Profilkompetenz, Expertise)
Anzahl: 1 Aufgabe mit Teilaufgaben
Bearbeitungszeit in Minuten ca.: <5 bis 30 min>
Szenario: eines der Szenarien aus dem Bauplan

Vorgehen:
1. Lies zuerst die verlinkten Artikel. Kannst Du keine Webseiten
   abrufen, sag mir das, statt zu raten.
2. Steht bei einer Angabe noch ein Platzhalter in <…>, frag mich
   zuerst danach. Richte Punkte und Zahl der Teilaufgaben nach der
   Bearbeitungszeit (ca. 0,9 min je Punkt).
3. Gib je Aufgabe Titel mit Kompetenzstufe, Ausgangssituation und
   Teilaufgaben mit Operator und Punktzahl aus, dazu die geschätzte
   Bearbeitungszeit.
4. Gib die Beispiellösungen mit Punkteverteilung erst aus, wenn ich
   danach frage.

Aufgabe 1.1: Den Ablauf der Anmeldung ordnen (Basiskompetenz)

(ca. 13 min Bearbeitungszeit)

Aylin Kaya (Pseudonym Morgenmuffel) startet das Gesuche-Fenster der Desktop-App zum ersten Mal mit Anmeldung. Oksana Melnyk erklärt einer neuen Person im Übungsteam, was dabei passiert.

1. Bringe die folgenden Schritte in die richtige Reihenfolge. (4 Punkte)

• 1. Der Systembrowser ruft http://127.0.0.1:61420/callback?code=…&state=… auf.
• (B) Die App schickt Code, code_verifier und Redirect-URI an den Token-Endpunkt von Keycloak.
• (C) Die App erzeugt code_verifier, state und nonce und startet einen HTTP-Server auf 127.0.0.1 mit Port 0.
• (D) Aylin gibt im Browser Pseudonym und Passwort ein.
• (E) Die App prüft das ID Token und zeigt „Angemeldet als Morgenmuffel · NUTZER“.
• (F) Die App öffnet die Anmeldeadresse mit code_challenge im Standardbrowser.
• (G) Die App vergleicht den state aus dem Rückruf mit ihrem eigenen.
• (H) Keycloak antwortet mit Access Token, Refresh Token und ID Token.

2. Kreuze an, welcher Wert an welcher Stelle über die Leitung geht. Ein Wert kann an mehreren Stellen vorkommen. (5 Punkte)

3. Nenne für jedes der drei Tokens, wer es auswertet und wofür die Desktop-App es nutzt. (3 Punkte)

4. Ein Mitglied des Übungsteams schlägt vor, die Anmeldeseite in einem WebView im Gesuche-Fenster anzuzeigen, „damit Aylin nicht in den Browser wechseln muss“. Nenne zwei Gründe, die dagegen sprechen. (2 Punkte)

Aufgabe 2.1: Das Gesuche-Fenster nach Rolle steuern (Kernkompetenz)

(ca. 14 min Bearbeitungszeit)

Im Replenishment hat Heike Brinkmann aus dem Sekretariat (Pseudonym Sekretariat-HB, Rolle ORGA) gebeten, unpassende Gesuche aus der Liste entfernen zu können, etwa wenn jemand eine private Telefonnummer in die Notiz geschrieben hat. Das Übungsteam nimmt das als Ticket JFX-25 „Gesuche nach Rolle“ auf:

• Mit Rolle NUTZER ist „Gesuch eintragen …“ bedienbar, sonst gesperrt.
• Mit Rolle ORGA erscheint der Button „Gesuch entfernen“; ohne ORGA ist er unsichtbar und nimmt keinen Platz ein. Er ist nur bedienbar, wenn in der Tabelle ein Gesuch gewählt ist.
• Das Entfernen geschieht vorerst nur in der Liste der App (wie das Eintragen); ohne ORGA lehnt das ViewModel es ab.

1. Ergänze GesucheViewModel um einen Konstruktor GesucheViewModel(GesuchQuelle quelle, Executor hintergrund, Sitzung sitzung) und die beiden schreibgeschützten Properties eintragenErlaubtProperty() und verwaltungSichtProperty(). Der bisherige Konstruktor soll weiter funktionieren und Aylin Kaya (Morgenmuffel, Nutzer-ID 2, Rolle NUTZER) annehmen. (4 Punkte)

2. Schreibe die Methode entfernen(Gesuch gesuch), die das Gesuch mit derselben id aus der Liste nimmt und ohne Rolle ORGA eine IllegalStateException wirft. (2 Punkte)

3. Ergänze gesuche.fxml und GesucheController um den Button gesuchEntfernenButton und binde beide Buttons nach den Akzeptanzkriterien. (4 Punkte)

4. Schreibe einen Komponententest GesucheRollenTest mit mindestens drei Testfällen: NUTZER, nur ORGA (mit erfolgreichem Entfernen) und Entfernen ohne ORGA. (3 Punkte)

5. Erläutere, warum JFX-25 trotz dieser Umsetzung erst „Fertig“ sein kann, wenn das Backend beteiligt ist. (2 Punkte)

private final Sitzung sitzung;
private final ReadOnlyBooleanWrapper eintragenErlaubt = new ReadOnlyBooleanWrapper(this, "eintragenErlaubt");
private final ReadOnlyBooleanWrapper verwaltungSicht = new ReadOnlyBooleanWrapper(this, "verwaltungSicht");

/** Ohne Anmeldung (Beispieldaten, ältere Tests): Aylin Kaya (Morgenmuffel) mit Rolle NUTZER. */
public GesucheViewModel(GesuchQuelle quelle, Executor hintergrund) {
    this(quelle, hintergrund, new Sitzung("Morgenmuffel", 2, Set.of(Sitzung.ROLLE_NUTZER)));
}

public GesucheViewModel(GesuchQuelle quelle, Executor hintergrund, Sitzung sitzung) {
    this.quelle = quelle;
    this.hintergrund = hintergrund;
    this.sitzung = sitzung;
    eintragenErlaubt.set(sitzung.hatRolle(Sitzung.ROLLE_NUTZER));
    verwaltungSicht.set(sitzung.hatRolle(Sitzung.ROLLE_ORGA));
    // … Filter und Hinweis wie bisher
}

public ReadOnlyBooleanProperty eintragenErlaubtProperty() {
    return eintragenErlaubt.getReadOnlyProperty();
}

public ReadOnlyBooleanProperty verwaltungSichtProperty() {
    return verwaltungSicht.getReadOnlyProperty();
}

public void entfernen(Gesuch gesuch) {
    if (!sitzung.hatRolle(Sitzung.ROLLE_ORGA)) {
        throw new IllegalStateException("Nur die Schulverwaltung (Rolle ORGA) darf Gesuche entfernen.");
    }
    gesuche.removeIf(g -> g.id() == gesuch.id());
}

<Button fx:id="gesuchEntfernenButton" text="Gesuch ent_fernen" mnemonicParsing="true"
        onAction="#gesuchEntfernen" GridPane.columnIndex="1" GridPane.rowIndex="6"/>

@FXML private Button gesuchEintragenButton;
@FXML private Button gesuchEntfernenButton;

// in initialize():
gesuchEintragenButton.disableProperty().bind(viewModel.eintragenErlaubtProperty().not());
gesuchEntfernenButton.visibleProperty().bind(viewModel.verwaltungSichtProperty());
gesuchEntfernenButton.managedProperty().bind(viewModel.verwaltungSichtProperty());
gesuchEntfernenButton.disableProperty().bind(
        gesucheTabelle.getSelectionModel().selectedItemProperty().isNull());

@FXML
private void gesuchEntfernen() {
    Gesuch gewaehlt = gesucheTabelle.getSelectionModel().getSelectedItem();
    if (gewaehlt != null) {
        viewModel.entfernen(gewaehlt);
    }
}

class GesucheRollenTest {

    @BeforeAll
    static void plattformStarten() throws InterruptedException {
        FxPlattform.starten();
    }

    private static GesucheViewModel viewModel(String... rollen) throws Exception {
        GesucheViewModel vm = new GesucheViewModel(Beispielgesuche::offeneGesuche, Runnable::run,
                new Sitzung("Testperson", 99, Set.of(rollen)));
        FxPlattform.aufFxThread(() -> {
            vm.laden();
            return null;
        });
        FxPlattform.warten();
        return vm;
    }

    @Test
    void nutzerDarfEintragenSiehtAberKeineVerwaltung() throws Exception {
        GesucheViewModel vm = viewModel("NUTZER");
        assertTrue(vm.eintragenErlaubtProperty().get());
        assertFalse(vm.verwaltungSichtProperty().get());
    }

    @Test
    void orgaOhneNutzerDarfNichtEintragenAberEntfernen() throws Exception {
        GesucheViewModel vm = viewModel("ORGA");
        assertFalse(vm.eintragenErlaubtProperty().get());
        assertTrue(vm.verwaltungSichtProperty().get());
        int vorher = vm.getPassendeGesuche().size();
        vm.entfernen(vm.getPassendeGesuche().get(0));
        assertEquals(vorher - 1, vm.getPassendeGesuche().size());
    }

    @Test
    void entfernenOhneOrgaWirdAbgelehntUndAendertNichts() throws Exception {
        GesucheViewModel vm = viewModel("NUTZER");
        int vorher = vm.getPassendeGesuche().size();
        assertThrows(IllegalStateException.class, () -> vm.entfernen(vm.getPassendeGesuche().get(0)));
        assertEquals(vorher, vm.getPassendeGesuche().size());
    }
}

Aufgabe 2.2: Einen Token-Speicher schreiben (Kernkompetenz)

(ca. 12 min Bearbeitungszeit)

Das Gesuche-Fenster soll die Tokens nicht über die Klasse Anmeldung verwalten, sondern über einen eigenen, kleinen TokenSpeicher im Paket …desktop.anmeldung. Er kennt zusätzlich, wie lange das Refresh Token gilt; Keycloak liefert dafür refresh_expires_in (im Realm 1800 Sekunden). Vereinfachend kennt der Speicher nur den Ablauf des ersten Refresh Tokens; Keycloak verlängert ihn bei Nutzung. Ist das Refresh Token abgelaufen, soll der Speicher Keycloak gar nicht erst fragen.

public class TokenSpeicher {
    public TokenSpeicher(TokenDienst tokenDienst, Clock uhr, Duration puffer) { … }
    public void speichern(Tokens neu, Instant refreshGueltigBis) { … }
    public String gueltigesAccessToken() { … }
    public void vergessen() { … }
}

1. Schreibe die Klasse. gueltigesAccessToken() soll

• ohne gespeicherte Tokens einen AnmeldeFehler mit dem Code nicht_angemeldet werfen,
• das gespeicherte Access Token liefern, solange es länger als puffer gilt,
• ein abgelaufenes Refresh Token erkennen, die Tokens vergessen und einen AnmeldeFehler mit dem Code invalid_grant werfen,
• sonst über tokenDienst.erneuern(…) neue Tokens holen und ein neues Refresh Token übernehmen; schickt Keycloak keines, bleibt das alte. (7 Punkte)

2. Schreibe Komponententests mit einer Uhr, die der Test vorstellen kann, und einem Ersatz-TokenDienst, der seine Aufrufe mitschreibt. Teste mindestens: kein Aufruf bei gültigem Token, Erneuern innerhalb des Puffers mit Weitergabe des neuen Refresh Tokens, abgelaufenes Refresh Token ohne Aufruf bei Keycloak. (4 Punkte)

3. Erläutere, warum gueltigesAccessToken() als synchronized deklariert sein sollte, obwohl die Oberfläche nur einen Thread hat. (2 Punkte)

public class TokenSpeicher {

    private final TokenDienst tokenDienst;
    private final Clock uhr;
    private final Duration puffer;

    private Tokens tokens;
    private Instant refreshAblauf;

    public TokenSpeicher(TokenDienst tokenDienst, Clock uhr, Duration puffer) {
        this.tokenDienst = tokenDienst;
        this.uhr = uhr;
        this.puffer = puffer;
    }

    public synchronized void speichern(Tokens neu, Instant refreshGueltigBis) {
        tokens = neu;
        refreshAblauf = refreshGueltigBis;
    }

    public synchronized String gueltigesAccessToken() {
        if (tokens == null) {
            throw new AnmeldeFehler("nicht_angemeldet", "Bitte zuerst anmelden.");
        }
        Instant jetzt = uhr.instant();
        if (!tokens.laeuftBaldAb(jetzt, puffer)) {
            return tokens.accessToken();
        }
        if (tokens.refreshToken() == null || !jetzt.isBefore(refreshAblauf)) {
            vergessen();
            throw new AnmeldeFehler("invalid_grant", "Die Anmeldung ist abgelaufen. Bitte neu anmelden.");
        }
        Tokens neu = tokenDienst.erneuern(tokens.refreshToken());
        // Rotation: neues Refresh Token übernehmen, sonst das alte behalten
        tokens = new Tokens(neu.accessToken(),
                neu.refreshToken() != null ? neu.refreshToken() : tokens.refreshToken(),
                tokens.idToken(), neu.ablauf());
        return tokens.accessToken();
    }

    public synchronized void vergessen() {
        tokens = null;
        refreshAblauf = null;
    }
}

class TokenSpeicherTest {

    private final AnmeldungTest.TestUhr uhr = new AnmeldungTest.TestUhr();
    private final List<String> aufrufe = new ArrayList<>();

    private final TokenDienst keycloak = new TokenDienst() {
        @Override public Tokens codeEinloesen(String code, URI redirectUri, String codeVerifier) {
            throw new UnsupportedOperationException();
        }
        @Override public Tokens erneuern(String refreshToken) {
            aufrufe.add("erneuern " + refreshToken);
            return new Tokens("access-2", "refresh-2", null, uhr.jetzt.plusSeconds(300));
        }
        @Override public void abmelden(String refreshToken) {
        }
    };

    private TokenSpeicher speicherMitTokens() {
        TokenSpeicher speicher = new TokenSpeicher(keycloak, uhr, Duration.ofSeconds(30));
        speicher.speichern(new Tokens("access-1", "refresh-1", null, uhr.jetzt.plusSeconds(300)),
                uhr.jetzt.plusSeconds(1800));
        return speicher;
    }

    @Test
    void gueltigesTokenOhneAufrufBeiKeycloak() {
        TokenSpeicher speicher = speicherMitTokens();
        uhr.jetzt = uhr.jetzt.plusSeconds(269);
        assertEquals("access-1", speicher.gueltigesAccessToken());
        assertTrue(aufrufe.isEmpty());
    }

    @Test
    void innerhalbDesPuffersWirdErneuertUndDasNeueRefreshTokenGenutzt() {
        TokenSpeicher speicher = speicherMitTokens();
        uhr.jetzt = uhr.jetzt.plusSeconds(271);
        assertEquals("access-2", speicher.gueltigesAccessToken());
        uhr.jetzt = uhr.jetzt.plusSeconds(280);
        speicher.gueltigesAccessToken();
        assertEquals(List.of("erneuern refresh-1", "erneuern refresh-2"), aufrufe);
    }

    @Test
    void abgelaufenesRefreshTokenFragtKeycloakNichtUndVerlangtNeueAnmeldung() {
        TokenSpeicher speicher = speicherMitTokens();
        uhr.jetzt = uhr.jetzt.plusSeconds(1800);
        AnmeldeFehler fehler = assertThrows(AnmeldeFehler.class, speicher::gueltigesAccessToken);
        assertTrue(fehler.neuAnmeldenNoetig());
        assertTrue(aufrufe.isEmpty());
    }
}

Aufgabe 3.1: Redirect-Fehler anhand ihrer Meldungen finden (Profilkompetenz)

(ca. 17 min Bearbeitungszeit)

Im Übungsteam hat jede Person die Anmeldung für das Gesuche-Fenster selbst nachgebaut. Der Client mitfahrlabor-desktop im Realm ist bei allen gleich (Redirect-URI http://127.0.0.1/callback, PKCE S256). Vier Fassungen scheitern; jede enthält genau einen absichtlich eingebauten Fehler. Die Ausschnitte zeigen nur die Stelle, an der sie vom Code-Stand des Artikels abweichen.

Fassung 1: Der Browser öffnet sich und zeigt sofort die Fehlerseite von Keycloak „Invalid parameter: redirect_uri“.

// ABSICHTLICH FEHLERHAFT (Fassung 1), in LoopbackEmpfaenger
public URI redirectUri() {
    return URI.create("http://localhost:" + server.getAddress().getPort() + PFAD);
}

Fassung 2: Die Anmeldeseite erscheint, nach Pseudonym und Passwort zeigt der Browser aber „Verbindung abgelehnt“ für http://127.0.0.1:50817/callback?state=…&code=…. Die App meldet nach fünf Minuten „Im Browser wurde keine Anmeldung abgeschlossen.“

// ABSICHTLICH FEHLERHAFT (Fassung 2), in Anmeldung.anmelden
URI redirectUri;
CompletableFuture<Rueckruf> antwort;
try (LoopbackEmpfaenger empfaenger = LoopbackEmpfaenger.starten()) {
    redirectUri = empfaenger.redirectUri();
    antwort = empfaenger.rueckruf();
}
browser.accept(konfiguration.anmeldeAdresse(redirectUri, state, nonce, pkce));
Rueckruf rueckruf = antwort.get(wartezeit.toMillis(), TimeUnit.MILLISECONDS);

Fassung 3: Nach der Anmeldung zeigt der Browser „Anmeldung abgeschlossen“. Die App meldet invalid_grant: Incorrect redirect_uri.

// ABSICHTLICH FEHLERHAFT (Fassung 3), in Anmeldung.anmelden
Tokens neu = tokenDienst.codeEinloesen(rueckruf.code(),
        URI.create("http://127.0.0.1" + LoopbackEmpfaenger.PFAD), pkce.codeVerifier());

Fassung 4: Auch hier zeigt der Browser „Anmeldung abgeschlossen“. Die App meldet invalid_grant: PKCE verification failed: Code mismatch. Ein zweiter Versuch mit demselben Code endet mit invalid_grant: Code not valid.

// ABSICHTLICH FEHLERHAFT (Fassung 4), in Anmeldung.anmelden
Tokens neu = tokenDienst.codeEinloesen(rueckruf.code(), redirectUri, Pkce.erzeugen(zufall).codeVerifier());

1. Erläutere für jede Fassung, warum der Fehler genau dieses Symptom erzeugt, und gib die korrigierte Stelle an. (12 Punkte)

2. Eine fünfte Fassung meldet sich fehlerfrei an. Etwa fünf Minuten nach dem Start schlägt aber jedes Laden mit 401 Unauthorized fehl, bis die App neu gestartet wird. Erläutere die Ursache in dieser Zeile und korrigiere sie. (3 Punkte)

// ABSICHTLICH FEHLERHAFT (Fassung 5), beim Anlegen des ApiClient
String token = anmeldung.accessToken();
client.setRequestInterceptor(anfrage -> anfrage.header("Authorization", "Bearer " + token));

3. Nach dem Ärger mit Fassung 1 schlägt jemand vor, im Realm "redirectUris": ["*"] einzutragen, „dann gibt es nie wieder Redirect-Fehler“. Beurteile den Vorschlag. (3 Punkte)

client.setRequestInterceptor(anfrage -> anfrage.header("Authorization", "Bearer " + anmeldung.accessToken()));

Links und weitere Informationen

• zum Artikel: Anmeldung einer Desktop-App mit Keycloak: Authorization Code mit PKCE über den Systembrowser

• zum Board: Kanban-Projektstart für die Desktop-App

• als Standard: RFC 8252: OAuth 2.0 for Native Apps

• als Standard: RFC 7636: Proof Key for Code Exchange (PKCE)

• für den Einstieg: Szenario Mitfahrlabor mit Personas und Regeln

Hinweis zur Nachnutzung als Open Educational Resource (OER)

Dieser Artikel und seine Texte, Bilder, Grafiken, Code und sonstiger Inhalt sind - sofern nicht anders angegeben - lizenziert unter CC BY 4.0. Nennung gemäß TULLU-Regel bitte wie folgt: “Übungsaufgaben zur Anmeldung mit Keycloak: Mitfahrgesuche nach Rolle” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/javafx-anmeldung-keycloak-uebungsaufgaben veröffentlicht, die Quelltexte sind in weiterverarbeitbarer Form verfügbar im Repository unter https://gitlab.com/oer-informatik/javafx/javafx-einstieg. Erstellt mit KI-Assistenz; von mir umfassend redaktionell überarbeitet, geprüft und freigegeben. Stand: 11.11.2026.

[Kommentare zum Artikel lesen, schreiben] / [Artikel teilen] / [gitlab-Issue zum Artikel schreiben]