Skip to content

4. Routing

4.1. Beispiel 17: Der Router

Eine [React] -Anwendung ist eine Single-Page-Anwendung: Der Browser lädt nur EINE HTML-Seite. Wenn Sie auf einen internen Link klicken, wird keine Anfrage an den Server gesendet: Der Router ändert die vom Browser angezeigte Adresse und ersetzt die angezeigte Komponente. [React] hat keinen eigenen Router: Stattdessen wird die Bibliothek [React Router] (Paket [react-router]) verwendet, die am weitesten verbreitet ist.

[React Router] lässt sich auf drei Arten verwenden (seine „Modi“): deklarativ (mit den Komponenten [<Routes>] und [<Route>], der einfachste Modus), „Data“ (Routen, die durch Objekte beschrieben werden, mit Funktionen, die vor dem Rendern ausgeführt werden: [loader], [middleware] ...) und „Framework“ (eine vollständige Anwendung mit serverseitigem Rendering, ähnlich wie [Next.js]). Wir verwenden den Data-Modus, der die Navigationssteuerung bietet, die wir benötigen.

4.1.1. Die Daten

// „hartkodierte“ Daten, um in diesem Beispiel nicht von einem Server abzuhängen
export interface Doctor {
  id: number;
  title: string;
  firstName: string;
  lastName: string;
  specialty: string;
}

export const DOCTORS: Doctor[] = [
  { id: 1, title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER', specialty: 'general practitioner' },
  { id: 2, title: 'Mr', firstName: 'Paul', lastName: 'TATOU', specialty: 'pediatrician' },
  { id: 3, title: 'Melle', firstName: 'Sophie', lastName: 'DUPONT', specialty: 'general practitioner' },
];

Fest im Code verankerte Daten, damit dieses Beispiel nicht von einem Server abhängt.

4.1.2. Die Routen

// =========================================================================
// 17-router/src/routes.tsx - die ROUTES der Anwendung
// -------------------------------------------------------------------------
// Eine React-Anwendung ist eine Single-Page-Anwendung (SPA: Single
// Page Application): Der Browser lädt nur EINE HTML-Seite. Wenn man
// auf einen internen Link klickt, wird keine Anfrage an den Server gesendet: Der
// Router ändert die vom Browser angezeigte Adresse und ersetzt die
// in <Outlet /> angezeigte Komponente.
//
// React hat keinen Router: Es wird die Bibliothek React Router verwendet. Eine
// Route ordnet einen PFAD einer KOMPONENTE (einer „Seite“) zu:
//   'doctors/:id'   :id ist ein Parameter (/doctors/2 -> id = "2");
//   '*'             jeder Pfad: die Seite „nicht gefunden“ (der
//                   Router wählt immer die spezifischste Route).
// Die Routen sind VERSCHACHTELT: Die Wurzelroute zeigt die Hülle der
// Anwendung (Shell) an, und ihre Kinder werden darin angezeigt, an der
// Stelle ihres <Outlet />.
// =========================================================================

import { redirect, type RouteObject } from 'react-router';
import Shell from './Shell';
import Home from './pages/Home';
import DoctorList from './pages/DoctorList';
import DoctorDetail from './pages/DoctorDetail';
import Search from './pages/Search';
import NotFoundPage from './pages/NotFoundPage';

export const routes: RouteObject[] = [
  {
    path: '/',
    Component: Shell,
    children: [
      // index: die Route der Adresse des Elternteils selbst ("/")
      { index: true, Component: Home },
      { path: 'doctors', Component: DoctorList },
      { path: 'doctors/:id', Component: DoctorDetail },
      { path: 'search', Component: Search },
      // VERZÖGERTES Laden: Der Code dieser Seite wird erst beim
      // ersten Besuch heruntergeladen (Vite macht daraus eine eigene Datei)
      { path: 'about', lazy: async () => ({ Component: (await import('./pages/About')).default }) },
      // eine Weiterleitung: Die alte Adresse führt zur neuen. Ein LOADER
      // ist eine Funktion, die der Router VOR der Anzeige der Route aufruft;
      // wirft er eine Weiterleitung, ändert die Navigation ihr Ziel
      {
        path: 'physicians',
        loader: () => {
          throw redirect('/doctors');
        },
      },
      { path: '*', Component: NotFoundPage },
    ],
  },
];
  • Zeile 20: [RouteObject] ist der Typ einer Route; [redirect] erzeugt eine Weiterleitung;
  • Zeilen 28–53: Routen sind Objekte: ein Pfad ([path]) und eine Komponente ([Component], großgeschrieben – angegeben wird die Komponente selbst, nicht [<Home />]);
  • Zeilen 30–32: Routen sind verschachtelt: Die Wurzelroute zeigt die „Hülle“ der Anwendung an ([Shell]) und ihre Kinder ([children]) werden INNERHALB der Hülle an der Stelle ihres [<Outlet />] angezeigt. Die Pfade der Kinder sind relativ zu dem des Elternteils;
  • Zeile 34: eine Index-Route: die der Adresse des Elternteils selbst („/“);
  • Zeile 36: [:id] ist ein Parameter: [/doctors/2] zeigt [DoctorDetail] an, wobei [id] = „2“ ist;
  • Zeile 40: verzögertes Laden: Die Funktion [lazy] wird erst beim ersten Besuch der Seite aufgerufen. [import('./pages/About')] (ein „dynamischer“ Import in Form einer Funktion) lädt dann das Modul herunter, das [Vite] in einer separaten Datei abgelegt hat. [lazy] liefert die fehlenden Eigenschaften der Route: hier ihre Komponente, die vom Modul als Default exportiert wird;
  • Zeilen 45–49: eine Weiterleitung: Die alte Adresse führt zur neuen. Ein Loader ist eine Funktion, die der Router VOR der Anzeige der Route aufruft (um deren Daten zu laden); löst er ([throw]) eine Weiterleitung aus, ändert die Navigation ihr Ziel;
  • Zeile 50: [*] entspricht jedem beliebigen Pfad: der Seite „Seite nicht gefunden“. Der Router wählt immer die spezifischste Route: Die Reihenfolge der Routen spielt keine Rolle.

4.1.3. Start

// =========================================================================
// 17-router/src/main.tsx
// -------------------------------------------------------------------------
// createBrowserRouter(routes) baut den Router, der der Adresse des
// Browsers folgt; <RouterProvider> zeigt die Route an, die zur aktuellen
// Adresse passt. Die Wurzelkomponente ist nicht mehr App: Es sind die Routen.
// =========================================================================

import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';
import { createBrowserRouter } from 'react-router';
import { RouterProvider } from 'react-router/dom';
import 'bootstrap/dist/css/bootstrap.min.css';
import { routes } from './routes';

const router = createBrowserRouter(routes);

createRoot(document.getElementById('root')!).render(
  <StrictMode>
    <RouterProvider router={router} />
  </StrictMode>,
);
  • Zeile 16: der Router, aus den Routen erstellt. [Browser]: Er folgt der Adresse des Browsers über die API [history];
  • Zeile 20: die Komponente, die die Route anzeigt, die der aktuellen Adresse entspricht. Die Wurzelkomponente ist nicht mehr [App], sondern es sind die Routen. [RouterProvider] wird aus [react-router/dom] importiert, dem browserspezifischen Teil der Bibliothek.

4.1.4. Die Hülle der Anwendung

// =========================================================================
// 17-router/src/Shell.tsx - die „Shell“ der Anwendung
// -------------------------------------------------------------------------
//   - <Link to="...">, <NavLink to="...">: ein interner Link. Er erzeugt ein
//     echtes <a href>, aber ein Klick lädt die Seite nicht neu: Der Router
//     übernimmt. NavLink weiß außerdem, ob er auf die angezeigte Seite zeigt: Er
//     setzt dann die Klasse "active" (die von Bootstrap);
//   - <Outlet />: der Platzhalter, an dem die aktuelle KIND-Route angezeigt wird;
//   - useLocation(): die aktuelle Adresse (pathname, search...).
// =========================================================================

import { NavLink, Outlet, useLocation } from 'react-router';

export default function Shell() {
  const location = useLocation();
  // decodeURIComponent: %20 wird wieder zu einem Leerzeichen
  const address = decodeURIComponent(location.pathname + location.search);

  return (
    <div className="container py-4">
      <h1 className="h3 mb-3">Example 17 - the router</h1>
      <nav className="nav nav-pills mb-3">
        {/* end: "/" ist nur bei genau "/" aktiv und nicht bei /doctors */}
        <NavLink className="nav-link" to="/" end>Home</NavLink>
        <NavLink className="nav-link" to="/doctors">Doctors</NavLink>
        {/* die Parameter nach dem ?: NavLink vergleicht nur den Pfad */}
        <NavLink className="nav-link" to="/search?q=general practitioner">Search</NavLink>
        <NavLink className="nav-link" to="/about">About</NavLink>
        <NavLink className="nav-link" to="/physicians">/physicians (redirect)</NavLink>
        <NavLink className="nav-link" to="/unknown-page">Broken link</NavLink>
      </nav>
      <p className="small text-muted">current address: <code>{address}</code></p>
      <div className="card p-3">
        <Outlet />
      </div>
    </div>
  );
}
  • Zeile 15: [useLocation()] liefert die aktuelle Adresse: [pathname] (den Pfad), [search] (den Teil nach dem „?“) ... Die Komponente wird bei jeder Navigation des Benutzers aufgerufen;
  • Zeile 24: [<NavLink to="...">] ist ein interner Link. Er erzeugt ein gültiges [<a href>] (das in einem neuen Tab geöffnet werden kann), aber ein Klick darauf lädt die Seite nicht neu: Das übernimmt der Router. [NavLink] weiß außerdem, ob er auf die aktuell angezeigte Seite verweist: In diesem Fall fügt er die Klasse [active] hinzu (dieselbe wie bei [Bootstrap]). [end]: Die Startseite „/“ ist nur bei exakt „/“ aktiv und nicht bei [/doctors]; [<Link>] ist die einfache Version ohne aktive Klasse;
  • Zeile 27: eine Adresse mit Parametern. [NavLink] vergleicht nur den Pfad: Der Link bleibt unabhängig von der Suche aktiv;
  • Zeile 34: die Stelle, an der die aktuelle KIND-Route angezeigt wird.

4.1.5. Die Seiten

Die Startseite:

// React 19: Ein in einer Komponente geschriebenes Element <title> wird von React
// im <head> der Seite platziert; es ändert den Titel des Tabs, solange die
// Komponente angezeigt wird
export default function Home() {
  return (
    <>
      <title>Home</title>
      <p className="mb-0">
        Welcome. Click on the links: the address of the browser changes, the page is never reloaded (open
        the Network tab of the developer tools to check it). The Back and Forward buttons of the browser
        work, as well as the reloading (F5) of any page.
      </p>
    </>
  );
}
  • Zeile 7: [React] platziert jedes in einer Komponente geschriebene Element im [<head>] der Seite, solange die Komponente angezeigt wird: So legt jede Seite den Titel des Tabs fest (dasselbe gilt für [<meta>] und [<link>]).

Die Liste der Ärzte, mit parametrisierten Links:

// 17-router/src/pages/DoctorList.tsx - Links mit Parameter
import { Link } from 'react-router';
import { DOCTORS } from '../data';

export default function DoctorList() {
  return (
    <>
      <title>Doctors</title>
      <ul className="mb-0">
        {DOCTORS.map((m) => (
          // ein Template-String baut die Adresse /doctors/2
          <li key={m.id}>
            <Link to={`/doctors/${m.id}`}>{m.title} {m.firstName} {m.lastName}</Link>
          </li>
        ))}
      </ul>
    </>
  );
}

Ein String-Template erzeugt die Adresse [/doctors/2].

Das Profil eines Arztes:

// =========================================================================
// 17-router/src/pages/DoctorDetail.tsx - eine Seite mit Parameter
// -------------------------------------------------------------------------
// useParams(): die Parameter des Pfads, hier { id: "2" } - immer
// STRINGS. useNavigate(): eine Funktion, um PER CODE zu navigieren;
// navigate(-1) geht zur vorherigen Seite zurück, wie die Zurück-Schaltfläche.
// Wechselt man von /doctors/1 zu /doctors/2, VERWENDET React dieselbe
// Komponente WIEDER: Sie wird einfach mit einer anderen id erneut aufgerufen.
// =========================================================================

import { useNavigate, useParams } from 'react-router';
import { DOCTORS } from '../data';

export default function DoctorDetail() {
  const { id } = useParams();
  const navigate = useNavigate();
  const doctor = DOCTORS.find((m) => m.id === Number(id));

  if (!doctor) {
    return <p className="text-danger mb-0">Doctor no. {id} does not exist.</p>;
  }

  const next = (doctor.id % DOCTORS.length) + 1;
  return (
    <>
      <title>{`${doctor.firstName} ${doctor.lastName}`}</title>
      <h2 className="h5">{doctor.title} {doctor.firstName} {doctor.lastName}</h2>
      <p>Specialty: {doctor.specialty}</p>
      <div className="d-flex gap-2">
        <button className="btn btn-sm btn-outline-secondary" onClick={() => navigate(-1)}>Back</button>
        <button className="btn btn-sm btn-outline-primary" onClick={() => navigate(`/doctors/${next}`)}>Next doctor</button>
      </div>
    </>
  );
}
  • Zeile 15: [useParams()] liefert die Pfadparameter – hier [{ id: "2" }] – immer als String;
  • Zeile 16: eine Funktion zum Navigieren per Code;
  • Zeilen 19–21: ein unbekannter Arzt ([/doctors/9]): eine Meldung;
  • Zeile 26: ein berechneter Titel: [<title>] akzeptiert nur EINEN String, daher das Template;
  • Zeile 30: [navigate(-1)] kehrt zur vorherigen Seite zurück, wie die Zurück-Schaltfläche des Browsers;
  • Zeile 31: zu einer Adresse navigieren. Der Wechsel von [/doctors/1] zu [/doctors/2] erstellt die Komponente nicht neu: [React] rendert sie einfach erneut, mit einer anderen [id].

Die Suche:

// =========================================================================
// 17-router/src/pages/Search.tsx - eine von der URL gesteuerte Seite
// -------------------------------------------------------------------------
// /search?q=pediatrician: Wie beim GET-Formular des NestJS-Kurses wird die
// Seite vollständig durch ihre Adresse beschrieben: Sie lässt sich als Lesezeichen speichern,
// neu laden und per „Zurück“ erreichen. useSearchParams() liefert die
// Parameter nach dem ?.
// <Form> (von React Router) ist ein GET-Formular... ohne Neuladen: Der
// Router navigiert zu /search?q=<input>. Die Seite zeigt an, was die
// URL sagt, und sonst nichts.
// =========================================================================

import { Form, useSearchParams } from 'react-router';
import { DOCTORS } from '../data';

export default function Search() {
  const [params] = useSearchParams();
  const q = params.get('q') ?? ''; // null, wenn er fehlt
  const results = DOCTORS.filter((m) => `${m.firstName} ${m.lastName} ${m.specialty}`.toLowerCase().includes(q.toLowerCase()));

  return (
    <>
      <title>Search</title>
      <Form className="d-flex gap-2 mb-3" action="/search">
        {/* ein UNkontrolliertes Feld, das mit dem Wert der URL beginnt;
            key={q}: ändert sich die URL (Zurück-Button), erstellt React das
            Feld neu, das dann den neuen Wert der URL übernimmt */}
        <input key={q} name="q" className="form-control" placeholder="name or specialty" defaultValue={q} />
        <button className="btn btn-primary">Search</button>
      </Form>
      <ul className="mb-0">
        {results.map((m) => (
          <li key={m.id}>{m.firstName} {m.lastName} ({m.specialty})</li>
        ))}
        {results.length === 0 && <li className="text-muted">No result.</li>}
      </ul>
    </>
  );
}
  • Zeile 17: die Parameter nach dem „?“ in Form eines Objekts [URLSearchParams]: [params.get('q')] ist gleich [null], wenn [q] fehlt. [useSearchParams] liefert außerdem (als zweites Element) eine Funktion, um sie zu ändern;
  • Zeile 24: [<Form>] (aus [React Router]) ist ein GET-Formular ... ohne Neuladen: Beim Absenden navigiert der Router zu [/search?q=<input>] (wobei [q] der [name] des Feldes ist). Wie beim GET-Formular aus dem [NestJS]-Kurs wird die Seite vollständig durch ihre Adresse beschrieben: Sie können ein Lesezeichen setzen, sie neu laden oder zurückgehen;
  • Zeile 28: Das Feld wird nicht kontrolliert; es beginnt mit dem Wert der URL ([defaultValue]). Ändert sich die URL, ohne dass die Seite neu geladen wird (über die Zurück-Schaltfläche), würde das Feld seinen vorherigen Text behalten; [key={q}] löst dieses Problem. Wenn sich der Schlüssel eines Elements ändert, behandelt [React] es als ein ANDERES Element: Es zerstört das alte und erstellt ein neues, das mit dem neuen Standardwert beginnt. Das ist ein gängiger Trick, um eine Komponente „zurückzusetzen“.

Die Seite, die bei Bedarf geladen wird, und die Seite „Seite nicht gefunden“:

// 17-router/src/pages/About.tsx - eine bei Bedarf geladene Seite
// „export default“: Die Route findet sie über (await import(...)).default
export default function About() {
  return (
    <>
      <title>About</title>
      <p className="mb-0">
        This page was downloaded on the first visit (Network tab: a file About-XXXX.js in production).
        Its tab title comes from the title element it contains.
      </p>
    </>
  );
}
import { useLocation } from 'react-router';

export default function NotFoundPage() {
  const { pathname } = useLocation();
  return (
    <>
      <title>Page not found</title>
      <p className="text-danger mb-0">No page at the address <code>{pathname}</code>.</p>
    </>
  );
}

4.1.6. Ausführung

Klicken Sie auf „Doctors“ und dann auf „Mr Paul TATOU“: Die Adresse ändert sich zu [/doctors/2] und der Titel des Tabs wird zu „Paul TATOU“:

Image

Eine Suche: Die Adresse wird zu [/search?q=pediatrician]:

Image

„About“: In der Entwicklung wird das Modul [About.tsx] nur beim ersten Besuch heruntergeladen (Registerkarte Network der Entwicklerwerkzeuge); in der Produktion ([npm run build 17-router]) liegt es in einer separaten Datei:

1
2
3
4
17-router/dist/index.html                   0.38 kB │ gzip:   0.26 kB
17-router/dist/assets/index-CqLr8KVv.css  230.06 kB │ gzip:  30.68 kB
17-router/dist/assets/About-DBg63tlb.js     0.36 kB │ gzip:   0.26 kB
17-router/dist/assets/index-evhjxpxc.js   317.05 kB │ gzip: 100.09 kB

Image

„/physicians“ führt zu [/doctors]; ein defekter Link:

Image

Sie können jede Seite neu laden (F5): Der Entwicklungsserver [Vite] liefert für jede unbekannte Adresse [index.html] zurück und der Router zeigt die richtige Seite an. In der Produktion muss der Server dasselbe tun (siehe Kapitel „Deployment“).

4.2. Beispiel 18: Navigationssteuerung

Einige Seiten setzen voraus, dass der Benutzer angemeldet ist oder eine bestimmte Rolle hat. Der Router kann dies vor der Anzeige mithilfe von Middleware überprüfen.

4.2.1. Die Sitzung

// =========================================================================
// 18-guards/src/session.ts - eine SIMULIERTE Sitzung (ohne Server)
// -------------------------------------------------------------------------
// Der angemeldete Benutzer muss den KOMPONENTEN (die obere Leiste,
// die Terminkalender-Seite) und den GUARDS (Funktionen des Routers, die
// keine Komponenten sind und daher keinen Kontext lesen können) bekannt sein. Er wird
// in einem einfachen Modul gespeichert, einem selbstgebauten „Store“:
//   - eine private Variable, der Zustand;
//   - Funktionen zum Lesen und Ändern;
//   - subscribe: die Liste der Funktionen, die bei einer Änderung benachrichtigt werden.
// Eine Komponente abonniert ihn mit useSyncExternalStore (vgl. useSession): Sie
// wird bei Änderung des Zustands erneut aufgerufen. Beispiel 20 überträgt diese Arbeit einer
// Bibliothek, Zustand (Zustand). (Beispiel 23 macht dasselbe mit einem echten
// Server.)
// =========================================================================

import { useSyncExternalStore } from 'react';

export type Role = 'ADMIN' | 'DOCTOR' | 'USER';

export interface User {
  login: string;
  role: Role;
}

// drei „hartkodierte“ Konten (Passwort = Login)
const ACCOUNTS: Record<string, Role> = { admin: 'ADMIN', pelissier: 'DOCTOR', martin: 'USER' };

let user: User | null = null; // der Zustand
const subscribers = new Set<() => void>();

function setUser(u: User | null) {
  user = u;
  subscribers.forEach((notify) => notify());
}

export const session = {
  user: () => user,
  logIn(login: string, password: string): boolean {
    const role = Object.hasOwn(ACCOUNTS, login) ? ACCOUNTS[login] : undefined;
    if (role === undefined || password !== login) {
      return false;
    }
    setUser({ login, role });
    return true;
  },
  logOut: () => setUser(null),
  subscribe(notify: () => void) {
    subscribers.add(notify);
    return () => subscribers.delete(notify); // zum Abbestellen
  },
};

// der Hook der Komponenten: der angemeldete Benutzer, immer aktuell
export function useSession(): User | null {
  return useSyncExternalStore(session.subscribe, session.user);
}

Der angemeldete Benutzer muss den Komponenten (der oberen Leiste, der Terminkalenderseite) und den Guards bekannt sein – Router-Funktionen, die keine Komponenten sind und daher keinen Kontext lesen können. Er wird in einem einfachen, von Hand geschriebenen Modul gespeichert, einem Store ([store]):

  • Zeilen 29–30: der Zustand, eine private Variable des Moduls, und die Liste der Funktionen, die bei einer Änderung benachrichtigt werden;
  • Zeilen 32–35: den Zustand ändern und die Abonnenten benachrichtigen;
  • Zeilen 37–52: die öffentlichen Funktionen: den Benutzer lesen, anmelden (drei fest codierte Konten, Passwort = Login), abmelden und abonnieren ([subscribe] liefert die Funktion zum Beenden des Abonnements);
  • Zeilen 55–57: der Komponenten-Hook. [useSyncExternalStore(subscribe, read)] ist der Hook von [React] , der genau für diesen Zweck gedacht ist: Er abonniert die Komponente beim Store und ruft sie erneut auf, wenn sich der gelesene Wert ändert.

Beispiel 20 wird diese Aufgabe an eine Bibliothek delegieren.

4.2.2. Die Guards

// =========================================================================
// 18-guards/src/guards.ts - Navigations-GUARDS
// -------------------------------------------------------------------------
// Eine MIDDLEWARE von React Router ist eine Funktion, die der Router
// VOR der Anzeige einer Route aufruft, die sie deklariert (middleware: [...]), bei JEDER
// Navigation zu ihr. Sie kann:
//   - nichts tun: Die Navigation läuft weiter;
//   - eine Weiterleitung werfen, redirect('/address'): Die
//     Navigation wird durch eine Navigation zu dieser Adresse ersetzt.
// Sie erhält die Navigationsanfrage (request.url: die angeforderte Adresse).
//
// Es ist das clientseitige Gegenstück zu den Guards von NestJS (JwtAuthGuard,
// RolesGuard) - mit einem GRUNDLEGENDEN Unterschied: Ein Guard des Clients ist
// nur eine Erleichterung. Der Code des Clients liegt in den Händen des Benutzers, der
// ihn nach Belieben ändern kann. Der eigentliche Schutz der Daten bleibt der
// des SERVERS (vgl. Kapitel über die Blackbox).
// =========================================================================

import { redirect, type MiddlewareFunction } from 'react-router';
import { session, type Role } from './session';

// die angeforderte Adresse ohne Host: "/schedule?x=1"
function address(request: Request): string {
  const url = new URL(request.url);
  return url.pathname + url.search;
}

// die Seite setzt eine Anmeldung voraus
export const requireLogin: MiddlewareFunction = ({ request }) => {
  if (session.user() === null) {
    // nicht angemeldet: zur Login-Seite, mit Merken des gewünschten Ziels
    throw redirect(`/login?redirect=${encodeURIComponent(address(request))}`);
  }
};

// die Seite setzt eine der angegebenen Rollen voraus: eine Funktion, die den Guard BAUT
export function requireRole(...roles: Role[]): MiddlewareFunction {
  return ({ request }) => {
    const u = session.user();
    if (u === null || !roles.includes(u.role)) {
      // angemeldet, aber ohne die passende Rolle: zurück zur Startseite, mit Begründung
      throw redirect(`/?denied=${encodeURIComponent(address(request))}`);
    }
  };
}

Eine [React Router]-Middleware ist eine Funktion, die der Router VOR der Anzeige einer Route aufruft, die sie deklariert, und zwar bei JEDER Navigation zu dieser Route. Sie kann nichts tun (die Navigation wird fortgesetzt) oder eine Weiterleitung auslösen, die die Navigation ersetzt.

  • Zeilen 23–26: Sie erhält die Navigationsanfrage: [request.url] ist die vollständige angeforderte Adresse ([http://localhost:5173/schedule?x=1]); nur der Pfad und die Parameter werden übernommen;
  • Zeilen 29–34: nicht angemeldet: Weiterleitung zur Anmeldeseite unter Beibehaltung des beabsichtigten Ziels ([?redirect=...]);
  • Zeilen 37–45: eine Funktion, die den Guard für die angegebenen Rollen ERZEUGT; [...roles]: beliebig viele Argumente, zu einem Array zusammengefasst. Angemeldet, aber nicht mit der richtigen Rolle: Weiterleitung zur Startseite, mit einer Begründung.

Dies ist das clientseitige Gegenstück zu den [NestJS]-Guards ([JwtAuthGuard], [RolesGuard]), mit einem Unterschied: Ein clientseitiger Guard ist lediglich eine Annehmlichkeit. Der Client-Code liegt in den Händen des Benutzers, und dieser kann ihn nach Belieben ändern. Der wirkliche Schutz der Daten bleibt der, den der SERVER bietet (siehe das Kapitel über die Blackbox).

4.2.3. Geschützte Routen

// =========================================================================
// 18-guards/src/routes.tsx - GESCHÜTZTE Routes
// -------------------------------------------------------------------------
// middleware: die zu passierenden Guards, der Reihe nach. Eine bei Bedarf
// geladene Seite (Lazy Loading) wird erst heruntergeladen, wenn die Guards passiert sind.
// =========================================================================

import { redirect, type RouteObject } from 'react-router';
import Shell from './Shell';
import Home from './pages/Home';
import Login from './pages/Login';
import Schedule from './pages/Schedule';
import { requireLogin, requireRole } from './guards';

export const routes: RouteObject[] = [
  {
    path: '/',
    Component: Shell,
    children: [
      { index: true, Component: Home },
      { path: 'login', Component: Login },
      { path: 'schedule', Component: Schedule, middleware: [requireLogin] },
      {
        path: 'administration',
        middleware: [requireLogin, requireRole('ADMIN')],
        lazy: async () => ({ Component: (await import('./pages/Administration')).default }),
      },
      // jede andere Adresse: zurück zur Startseite
      { path: '*', loader: () => redirect('/') },
    ],
  },
];
  • Zeile 22: die Schutzmechanismen der Route, der Reihe nach ausgeführt;
  • Zeilen 24–26: Eine bei Bedarf geladene Seite wird erst heruntergeladen, nachdem die Guards passiert wurden;
  • Zeile 29: jede andere Adresse: Rückkehr zur Startseite. Ein Loader kann die Weiterleitung auch ZURÜCKGEBEN.

Der Startcode ist derselbe wie in Beispiel 17:

import { StrictMode } from 'react';
import { createRoot } from 'react-dom/client';
import { createBrowserRouter } from 'react-router';
import { RouterProvider } from 'react-router/dom';
import 'bootstrap/dist/css/bootstrap.min.css';
import { routes } from './routes';

const router = createBrowserRouter(routes);

createRoot(document.getElementById('root')!).render(
  <StrictMode>
    <RouterProvider router={router} />
  </StrictMode>,
);

4.2.4. Die Hülle und die Seiten

// 18-guards/src/Shell.tsx - die Links und der angemeldete Benutzer
import { NavLink, Outlet, useNavigate } from 'react-router';
import { session, useSession } from './session';

// NavLink akzeptiert eine FUNKTION für className: Sie erhält { isActive }
const cssClass = ({ isActive }: { isActive: boolean }) => (isActive ? 'fw-bold' : '');

export default function Shell() {
  const user = useSession();
  const navigate = useNavigate();

  function onLogOut() {
    session.logOut();
    navigate('/');
  }

  return (
    <div className="container py-4" style={{ maxWidth: 720 }}>
      <h1 className="h3 mb-3">Example 18 - navigation guards</h1>
      <nav className="d-flex gap-3 align-items-center mb-3">
        <NavLink to="/" end className={cssClass}>Home</NavLink>
        <NavLink to="/schedule" className={cssClass}>Schedule (logged in)</NavLink>
        <NavLink to="/administration" className={cssClass}>Administration (ADMIN)</NavLink>
        <span className="ms-auto">
          {user ? (
            <>
              {user.login} <span className="badge text-bg-primary">{user.role}</span>
              <button className="btn btn-sm btn-link" onClick={onLogOut}>log out</button>
            </>
          ) : (
            <NavLink to="/login">log in</NavLink>
          )}
        </span>
      </nav>
      <div className="card p-3"><Outlet /></div>
    </div>
  );
}
  • Zeile 6: [className] eines [NavLink] kann eine Funktion sein, die [{ isActive }] als Eingabe erhält und die Klassen zurückgibt;
  • Zeile 9: der angemeldete Benutzer; die Leiste verfolgt seine Änderungen;
  • Zeilen 12–15: Abmelden und Rückkehr zur Startseite.
import { useSearchParams } from 'react-router';

export default function Home() {
  // ?denied=...: vom Guard requireRole gesetzt, wenn die Rolle nicht passt
  const denied = useSearchParams()[0].get('denied');
  return (
    <>
      {denied && <p className="alert alert-danger">Your role does not allow you to open {denied}.</p>}
      <p className="mb-0">
        Public page. Try the two other links, logged in or not (admin, pelissier, martin - password = login).
      </p>
    </>
  );
}
import { useSession } from '../session';

export default function Schedule() {
  const user = useSession();
  return (
    <p className="mb-0">
      The schedule of <strong>{user?.login}</strong>: this page requires being logged in.
    </p>
  );
}
1
2
3
4
5
6
7
8
export default function Administration() {
  return (
    <p className="mb-0">
      Administration: page reserved for the ADMIN role, loaded on demand (Network tab: its file is only downloaded
      on the first visit, and only if the guards allowed it).
    </p>
  );
}
// =========================================================================
// 18-guards/src/pages/Login.tsx
// -------------------------------------------------------------------------
// Nach der Anmeldung wird der Benutzer zu der Seite zurückgeleitet, die er
// öffnen wollte (Parameter ?redirect=..., vom Guard gesetzt), oder zur Startseite.
// =========================================================================

import { useState, type FormEvent } from 'react';
import { useNavigate, useSearchParams } from 'react-router';
import { session } from '../session';

export default function Login() {
  const redirection = useSearchParams()[0].get('redirect');
  const navigate = useNavigate();
  const [login, setLogin] = useState('');
  const [password, setPassword] = useState('');
  const [error, setError] = useState(false);

  function submit(e: FormEvent<HTMLFormElement>) {
    e.preventDefault();
    if (!session.logIn(login.trim(), password)) {
      setError(true);
      return;
    }
    // nur ein INTERNER Pfad wird akzeptiert: Er beginnt mit /, aber nicht mit //
    // (//site.com/... bezeichnet eine ANDERE Website) - keine Weiterleitung auf eine andere Website
    const internal = redirection !== null && redirection.startsWith('/') && !redirection.startsWith('//');
    navigate(internal ? redirection : '/');
  }

  return (
    <>
      {redirection && <p className="alert alert-warning">Log in to open {redirection}.</p>}
      <form className="d-flex flex-wrap gap-2" onSubmit={submit}>
        <input className="form-control w-auto" placeholder="login" autoComplete="username" value={login}
               onChange={(e) => setLogin(e.target.value)} />
        <input type="password" className="form-control w-auto" placeholder="password" autoComplete="current-password"
               value={password} onChange={(e) => setPassword(e.target.value)} />
        <button className="btn btn-primary">Log in</button>
      </form>
      {error && <p className="text-danger mt-2 mb-0">Incorrect login or password.</p>}
    </>
  );
}
  • Zeile 13: die Adresse, die wir öffnen wollten, vom Guard übergeben;
  • Zeilen 27–28: Nach der Anmeldung gehen wir dorthin ... vorausgesetzt, es handelt sich um einen INTERNEN Pfad (er beginnt mit „/“, aber nicht mit „//“, was auf eine andere Website verweist): Eine manipulierte Anmelde-URL ([/login?redirect=https://malicious-site.com]) darf nicht aus der Anwendung hinausführen.

4.2.5. Ausführung

Klicken Sie ohne Anmeldung auf „Administration“: Der Guard leitet zur Anmeldeseite weiter:

Image

Melden Sie sich als [martin] (Rolle [USER]) an: Die Rollenprüfung leitet zur Startseite weiter:

Image

Angemeldet als [admin]:

Image