Skip to content

4. Routing

Eine [Vue.js]-Anwendung lädt nur eine einzige HTML-Seite. Die Anwendung [RdvMedecins] hat jedoch eine Login-Seite, eine Terminkalender-Seite, eine Seite „Mein Bereich“... Jede hat ihre eigene URL ([/login], [/schedule], [/my-area]), die sich als Lesezeichen speichern lässt, und die Schaltflächen „Zurück“ und „Vorwärts“ des Browsers funktionieren. Dafür sorgt der Router, die Bibliothek [vue-router].

4.1. Beispiel 13: Der Router

Der Router wird der Anwendung in [main.ts] hinzugefügt:

// =========================================================================
// 13-router/src/main.ts
// -------------------------------------------------------------------------
// app.use(router): Der Router wird zur Anwendung hinzugefügt. Die Komponenten
// <RouterLink> und <RouterView> sind dann überall verwendbar.
// =========================================================================

import { createApp } from 'vue';
import 'bootstrap/dist/css/bootstrap.min.css';
import App from './App.vue';
import { router } from './router';

createApp(App).use(router).mount('#app');
  • Zeile 13: [app.use(...)] installiert eine Erweiterung ([plugin]): Die Komponenten [<RouterLink>] und [<RouterView>] sowie die Funktionen [useRoute()] und [useRouter()] stehen dann überall zur Verfügung.

Die Beispieldaten, „fest codiert“:

// "fest codierte" 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' },
];

Die Routen:

// =========================================================================
// 13-router/src/router.ts - die ROUTES der Anwendung
// -------------------------------------------------------------------------
// Eine Vue.js-Anwendung ist eine Single-Page-Anwendung (SPA: Single
// Page Application): Der Browser lädt nur EINE HTML-Seite. Wird ein
// interner Link angeklickt, wird keine Anfrage an den Server gesendet:
// Der Router ändert die vom Browser angezeigte Adresse und ersetzt die
// in <RouterView> angezeigte Komponente.
//
// Eine Route verknüpft einen PFAD mit einer KOMPONENTE (im Sinne eines Screens der Anwendung
// "View" genannt):
//   '/doctors/:id'        :id ist ein Parameter (/doctors/2 -> id = "2");
//   '/:pathMatch(.*)*'    jeder Pfad: die Seite "nicht gefunden"
//                         (die genaueste Route gewinnt immer).
//
// createWebHashHistory: Die Adressen sehen aus wie /13-router/#/doctors/2.
// Alles nach dem # bleibt im Browser: Ein Neuladen der Seite (F5)
// fordert immer wieder /13-router/ an, das existiert. Es ist der einfachste Modus,
// wenn der Server vom Router nichts weiß - hier der Vite-Server, der
// zwanzig Beispiele gleichzeitig bereitstellt. Die Fallstudie verwendet "saubere"
// Adressen (createWebHistory: /schedule, /doctors ...).
// =========================================================================

import { createRouter, createWebHashHistory } from 'vue-router';
import Home from './views/Home.vue';
import DoctorList from './views/DoctorList.vue';
import DoctorDetail from './views/DoctorDetail.vue';
import Search from './views/Search.vue';
import NotFoundPage from './views/NotFoundPage.vue';

export const router = createRouter({
  history: createWebHashHistory(),
  routes: [
    { path: '/', name: 'home', component: Home },
    { path: '/doctors', name: 'doctors', component: DoctorList },
    // props: true -> der Parameter :id wird der Komponente als PROP übergeben
    // (die Komponente hängt dann nicht mehr vom Router ab: leichter wiederzuverwenden)
    { path: '/doctors/:id', name: 'doctor', component: DoctorDetail, props: true },
    { path: '/search', name: 'search', component: Search },
    // eine Weiterleitung: Die alte Adresse führt zur neuen
    { path: '/physicians', redirect: '/doctors' },
    { path: '/:pathMatch(.*)*', name: 'not-found', component: NotFoundPage },
  ],
});
  • Zeilen 33–43: Eine Route ordnet einem Pfad eine Komponente zu, die als „View“ bezeichnet wird (im Sinne eines Anwendungsbildschirms; das hat nichts mit den [Handlebars]-Views aus dem Kurs [NestJS] zu tun, abgesehen von ihrer Rolle);
  • Zeile 34: Eine Route kann einen Namen haben, der zum Erstellen von Links stabiler ist als ihr Pfad;
  • Zeile 38: [:id] ist ein Parameter: [/doctors/2] zeigt [DoctorDetail] zusammen mit [id = "2"] an. Die Option [props: true] übergibt ihn als Prop an die Komponente: Die Komponente ist dann nicht mehr vom Router abhängig;
  • Zeile 41: eine Weiterleitung: Die Adresse [/physicians] zu [/doctors] führt;
  • Zeile 42: ein beliebiger Pfad: die Seite „Seite nicht gefunden“. Sie erhält nur Adressen, die keine andere Route erkennt: [vue-router] sortiert die Routen nach der Genauigkeit ihres Pfads; die genaueste hat Vorrang (sie steht der Lesbarkeit halber dennoch am Ende);
  • Zeile 32: der History-Modus. Mit [createWebHashHistory] haben die Adressen die Form [/13-router/#/doctors/2]: Alles, was auf [#] folgt, wird nie an den Server gesendet, und das Neuladen der Seite (F5) fordert immer [/13-router/] an, das existiert. Dies ist der einfachste Ansatz, wenn der Server die Routen des Clients nicht kennt, was beim Server von [Vite] der Fall ist, der zwanzig Beispiele gleichzeitig ausliefert. Die Fallstudie verwendet [createWebHistory] und „saubere“ Adressen ([/schedule]), was von Seiten des Servers einen kleinen Zusatzaufwand erfordert.

Die „Hülle“ der Anwendung:

<!--
  =========================================================================
  13-router/src/App.vue - the "shell" of the application
  -------------------------------------------------------------------------
    - <RouterLink to="...">: an internal link. It produces an <a> tag,
      but a click does not reload the page: it is the router that acts.
      The link of the displayed page receives the class "router-link-active"
      (here replaced by "active", the Bootstrap one);
    - <RouterView />: the place where the component of the current route
      is displayed.
  =========================================================================
-->
<script setup lang="ts">
import { RouterLink, RouterView, useRoute } from 'vue-router';

// useRoute(): die aktuelle Route (Pfad, Parameter, Query ...), reaktiv
const route = useRoute();
</script>

<template>
  <div class="container py-4">
    <h1 class="h3 mb-3">Example 13 - the router</h1>
    <nav class="nav nav-pills mb-3">
      <RouterLink class="nav-link" active-class="active" to="/">Home</RouterLink>
      <!-- to kann ein Objekt sein: der NAME der Route statt ihres Pfads -->
      <RouterLink class="nav-link" active-class="active" :to="{ name: 'doctors' }">Doctors</RouterLink>
      <RouterLink class="nav-link" active-class="active" :to="{ name: 'search', query: { q: 'general practitioner' } }">Search</RouterLink>
      <RouterLink class="nav-link" to="/physicians">/physicians (redirection)</RouterLink>
      <RouterLink class="nav-link" to="/unknown-page">Broken link</RouterLink>
    </nav>
    <p class="small text-muted">current route: <code>{{ route.fullPath }}</code> (name: {{ String(route.name) }})</p>
    <div class="card p-3">
      <RouterView />
    </div>
  </div>
</template>
  • Zeile 17: die aktuelle Route (Pfad, Parameter, [query]...), die dynamisch ist: Das Template aktualisiert sich, wenn sie sich ändert;
  • Zeile 24: [<RouterLink>] erzeugt ein [<a>]-Tag, aber ein Klick lädt die Seite nicht neu: Der Router ändert die Adresse und die angezeigte Komponente. Dem Link der aktuellen Seite wird die Klasse zugewiesen, die durch [active-class] angegeben ist (hier [active], die Klasse von [Bootstrap]);
  • Zeile 26: Das Ziel kann ein Objekt sein: der Routenname statt seines Pfads;
  • Zeile 27: ein Link mit Query-Parametern: [/search?q=general practitioner];
  • Zeile 33: der Ort, an dem die Komponente der aktuellen Route angezeigt wird.

Die Seiten. Die Liste der Ärzte erzeugt Links mit Parametern:

<!-- 13-router/src/views/DoctorList.vue - Links mit Parameter -->
<script setup lang="ts">
import { RouterLink } from 'vue-router';
import { DOCTORS } from '../data';
</script>

<template>
  <ul class="mb-0">
    <li v-for="m in DOCTORS" :key="m.id">
      <!-- { name, params }: Der Router baut die Adresse /doctors/2 selbst -->
      <RouterLink :to="{ name: 'doctor', params: { id: m.id } }">{{ m.title }} {{ m.firstName }} {{ m.lastName }}</RouterLink>
    </li>
  </ul>
</template>
  • Zeile 11: Der Router selbst konstruiert die Adresse [/doctors/2] aus dem Routennamen und seinen Parametern.

Die Seite eines Arztes:

<!--
  13-router/src/views/DoctorDetail.vue - a page with a parameter
  The id arrives as a PROP (props: true in router.ts), as a string.
  useRouter() gives the router itself, to navigate BY CODE.
-->
<script setup lang="ts">
import { computed } from 'vue';
import { useRouter } from 'vue-router';
import { DOCTORS } from '../data';

const props = defineProps<{ id: string }>();
const router = useRouter();

// computed: Beim Wechsel von /doctors/1 zu /doctors/2 VERWENDET Vue dieselbe
// Komponente WIEDER und ändert nur die Prop - das Computed folgt
const doctor = computed(() => DOCTORS.find((m) => m.id === Number(props.id)) ?? null);
const next = computed(() => (Number(props.id) % DOCTORS.length) + 1);
</script>

<template>
  <div v-if="doctor">
    <h2 class="h5">{{ doctor.title }} {{ doctor.firstName }} {{ doctor.lastName }}</h2>
    <p>Specialty: {{ doctor.specialty }}</p>
    <div class="d-flex gap-2">
      <!-- Navigation per Code: router.push(...) oder router.back() -->
      <button class="btn btn-sm btn-outline-secondary" @click="router.back()">Back</button>
      <button class="btn btn-sm btn-outline-primary" @click="router.push({ name: 'doctor', params: { id: next } })">Next doctor</button>
    </div>
  </div>
  <p v-else class="text-danger mb-0">Doctor no. {{ id }} does not exist.</p>
</template>
  • Zeile 11: Der Parameter [:id] wird als Prop in Form einer Zeichenkette übergeben;
  • Zeile 12: der Router selbst, um per Code zu navigieren;
  • Zeile 16: Der Wechsel von [/doctors/1] zu [/doctors/2] erstellt die Komponente nicht neu: [Vue.js] verwendet die angezeigte wieder und ändert nur ihre Prop. Ein [computed] folgt dieser Änderung; in [onMounted] platzierter Code würde dagegen nur einmal ausgeführt;
  • Zeilen 26 und 27: zur vorherigen Seite zurückkehren, zu einer anderen Seite gehen.

Image

Die Suche ist eine Seite, die vollständig durch ihre URL beschrieben wird, genau wie das GET-Formular aus dem Kurs [NestJS]:

<!--
  13-router/src/views/Search.vue - a page driven by the QUERY of the URL
  (/search?q=pediatrician). As with the GET form of the NestJS course, the
  page is entirely described by its address: it can be
  bookmarked, reloaded, navigated back to.
-->
<script setup lang="ts">
import { computed, ref, watch } from 'vue';
import { useRoute, useRouter } from 'vue-router';
import { DOCTORS } from '../data';

const route = useRoute();
const router = useRouter();

// das Eingabefeld startet mit dem Wert der URL ...
const input = ref(String(route.query.q ?? ''));
// ... und folgt der URL, wenn sie sich ändert (z. B. Zurück-Button)
watch(() => route.query.q, (q) => (input.value = String(q ?? '')));

const results = computed(() => {
  const q = String(route.query.q ?? '').toLowerCase();
  return DOCTORS.filter((m) => `${m.firstName} ${m.lastName} ${m.specialty}`.toLowerCase().includes(q));
});

function search(): void {
  // wir ändern die URL; die Anzeige folgt der URL (Computed oben)
  router.push({ name: 'search', query: { q: input.value } });
}
</script>

<template>
  <form class="d-flex gap-2 mb-3" @submit.prevent="search">
    <input v-model="input" class="form-control" placeholder="name or specialty">
    <button class="btn btn-primary">Search</button>
  </form>
  <ul class="mb-0">
    <li v-for="m in results" :key="m.id">{{ m.firstName }} {{ m.lastName }} ({{ m.specialty }})</li>
  </ul>
</template>
  • Zeile 16: [route.query] enthält die Parameter der URL ([?q=...]);
  • Zeile 18: Wenn sich die URL ändert (Schaltfläche „Zurück“), folgt das Feld;
  • Zeile 20: Die Ergebnisse hängen von der URL ab, nicht vom Feld;
  • Zeile 27: Eine Suche ändert die URL; die Anzeige aktualisiert sich entsprechend. Sie können die Suche als Lesezeichen speichern, neu laden oder zurückgehen.

Image

4.2. Beispiel 14: Navigationsbeschränkungen

Manche Seiten erfordern eine Anmeldung, andere eine bestimmte Rolle. Dieses Beispiel simuliert eine Anmeldung ohne Server:

// =========================================================================
// 14-guards/src/session.ts - eine SIMULIERTE Sitzung (ohne Server)
// -------------------------------------------------------------------------
// Der angemeldete Benutzer in einem Ref, der auf MODUL-Ebene deklariert ist: Alle
// Dateien, die dieses Modul importieren, teilen sich denselben. (Beispiel 15 macht
// dasselbe besser mit Pinia; Beispiel 18 mit einem echten Server.)
// =========================================================================

import { ref } from 'vue';

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

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

export const user = ref<User | null>(null);

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

export function logIn(login: string, password: string): boolean {
  const role = ACCOUNTS[login];
  if (role === undefined || password !== login) {
    return false;
  }
  user.value = { login, role };
  return true;
}

export function logOut(): void {
  user.value = null;
}
  • Zeile 18: ein auf [ref] -Ebene des Moduls deklariertes [session.ts] : Alle Dateien, die es importieren, teilen sich dasselbe.

Die Routen und ihre Guards:

// =========================================================================
// 14-guards/src/router.ts - GESCHÜTZTE Routen
// -------------------------------------------------------------------------
// meta: freie Informationen, die an eine Route angehängt werden. Hier:
//   - meta.requiresLogin: Die Seite erfordert eine Anmeldung;
//   - meta.roles        : die berechtigten Rollen (fehlt = alle).
//
// router.beforeEach(...): ein NAVIGATION GUARD, der vor JEDEM
// Seitenwechsel ausgeführt wird. Er gibt zurück:
//   - true                : Die Navigation wird fortgesetzt;
//   - eine andere Adresse    : Weiterleitung;
// Er ist das clientseitige Pendant zu den NestJS-Guards (JwtAuthGuard,
// RolesGuard) - mit einem GRUNDLEGENDEN Unterschied: Ein Client-Guard
// ist nur eine Bequemlichkeit. Der Client-Code liegt in der Hand des Benutzers, der
// ihn nach Belieben ändern kann. Der eigentliche Schutz der Daten bleibt
// der des SERVERS (siehe das Kapitel zur Blackbox).
// =========================================================================

import { createRouter, createWebHashHistory } from 'vue-router';
import { user, type Role } from './session';
import Home from './views/Home.vue';
import Login from './views/Login.vue';
import Schedule from './views/Schedule.vue';

// wir deklarieren TypeScript die von uns verwendeten meta-Eigenschaften
declare module 'vue-router' {
  interface RouteMeta {
    requiresLogin?: boolean;
    roles?: Role[];
  }
}

export const router = createRouter({
  history: createWebHashHistory(),
  routes: [
    { path: '/', component: Home },
    { path: '/login', component: Login },
    { path: '/schedule', component: Schedule, meta: { requiresLogin: true } },
    {
      path: '/administration',
      // LAZY Loading: Der Code dieser Komponente wird erst beim ersten Besuch der Seite
      // heruntergeladen (Vite erzeugt daraus eine eigene Datei)
      component: () => import('./views/Administration.vue'),
      meta: { requiresLogin: true, roles: ['ADMIN'] },
    },
  ],
});

router.beforeEach((to) => {
  if (to.meta.requiresLogin && user.value === null) {
    // nicht angemeldet: zur Login-Seite, wobei das ursprüngliche Ziel gemerkt wird
    return { path: '/login', query: { redirect: to.fullPath } };
  }
  if (to.meta.roles && user.value && !to.meta.roles.includes(user.value.role)) {
    // angemeldet, aber nicht mit der richtigen Rolle: zurück zur Startseite, mit Begründung
    return { path: '/', query: { denied: to.fullPath } };
  }
  return true;
});
  • Zeilen 26–31: Wir deklarieren in [TypeScript] die Eigenschaften, die wir im Feld [meta] der Routen speichern. [meta] akzeptiert beliebige Daten; die Deklaration dieser Eigenschaften erlaubt ihre Verwendung ohne Typumwandlung;
  • Zeile 38: Die Seite erfordert, dass der Benutzer angemeldet ist;
  • Zeile 43: verzögertes Laden: Der Code dieser Komponente wird erst beim ersten Besuch der Seite heruntergeladen. [Vite] legt ihn in einer separaten Datei ab. So lädt eine Anwendung beim Start nur das, was sie benötigt;
  • Zeilen 49–59: ein Navigations-Guard, der vor JEDEM Seitenwechsel ausgeführt wird. Er gibt [true] zurück, um den Zugriff zu erlauben, oder eine andere Adresse, zu der umgeleitet wird:
    • nicht angemeldet: Umleitung zu [/login], wobei die angeforderte Seite im Parameter [redirect] erhalten bleibt;
    • angemeldet, aber ohne die richtige Rolle: Rückkehr zur Startseite, mit dem Grund der Ablehnung.

Die Login-Seite leitet den Benutzer dorthin weiter, wohin er wollte:

<!--
  14-guards/src/views/Login.vue
  After logging in, the user is sent back to the page they wanted to
  open (parameter ?redirect=... set by the guard), or to the home page.
-->
<script setup lang="ts">
import { ref } from 'vue';
import { useRoute, useRouter } from 'vue-router';
import { logIn } from '../session';

const route = useRoute();
const router = useRouter();
const login = ref('');
const password = ref('');
const error = ref(false);

function submit(): void {
  error.value = !logIn(login.value.trim(), password.value);
  if (!error.value) {
    const redirect = route.query.redirect;
    // nur ein INTERNER Pfad wird akzeptiert: Er beginnt mit /, aber nicht mit //
    // (//site.com/... bezeichnet eine ANDERE Site) - keine Weiterleitung auf eine andere Site
    const internal = typeof redirect === 'string' && redirect.startsWith('/') && !redirect.startsWith('//');
    router.push(internal ? redirect : '/');
  }
}
</script>

<template>
  <p v-if="route.query.redirect" class="alert alert-warning">Log in to open {{ route.query.redirect }}.</p>
  <form class="d-flex flex-wrap gap-2" @submit.prevent="submit">
    <input v-model="login" class="form-control w-auto" placeholder="login" autocomplete="username">
    <input v-model="password" type="password" class="form-control w-auto" placeholder="password" autocomplete="current-password">
    <button class="btn btn-primary">Log in</button>
  </form>
  <p v-if="error" class="text-danger mt-2 mb-0">Incorrect login or password.</p>
</template>
  • Zeile 23: Nur ein INTERNER Pfad wird akzeptiert: Er beginnt mit [/], aber nicht mit [//] ([//site.com/...] verweist auf eine ANDERE Website). Eine Weiterleitung zu einer in der URL empfangenen vollständigen URL würde es einem bösartigen Link erlauben, den Benutzer unmittelbar nach der Anmeldung auf eine andere Website zu schicken, die unsere nachahmt (eine Schwachstelle, bekannt als [open redirect]).

Die anderen Dateien sind sehr kurz:

<script setup lang="ts">
import { RouterLink, RouterView, useRouter } from 'vue-router';
import { logOut, user } from './session';

const router = useRouter();

function onLogOut(): void {
  logOut();
  router.push('/');
}
</script>

<template>
  <div class="container py-4" style="max-width: 720px">
    <h1 class="h3 mb-3">Example 14 - navigation guards</h1>
    <nav class="d-flex gap-3 align-items-center mb-3">
      <RouterLink to="/">Home</RouterLink>
      <RouterLink to="/schedule">Schedule (logged in)</RouterLink>
      <RouterLink to="/administration">Administration (ADMIN)</RouterLink>
      <span class="ms-auto">
        <template v-if="user">
          {{ user.login }} <span class="badge text-bg-primary">{{ user.role }}</span>
          <button class="btn btn-sm btn-link" @click="onLogOut">log out</button>
        </template>
        <RouterLink v-else to="/login">log in</RouterLink>
      </span>
    </nav>
    <div class="card p-3"><RouterView /></div>
  </div>
</template>
<script setup lang="ts">
import { useRoute } from 'vue-router';
const route = useRoute();
</script>

<template>
  <!-- ?denied=...: vom Guard gesetzt, wenn die Rolle nicht passt -->
  <p v-if="route.query.denied" class="alert alert-danger">Your role does not allow you to open {{ route.query.denied }}.</p>
  <p class="mb-0">Public page. Try the two other links, logged in or not (admin, pelissier, martin - password = login).</p>
</template>

Ein Klick auf „Administration (ADMIN)“ ohne Anmeldung führt zur Login-Seite:

Image

Bei Anmeldung mit dem Konto [martin] (Rolle [USER]) verweigert der Guard den Zugriff auf die Administrationsseite:

Image

Ein GRUNDLEGENDER Hinweis: Ein Navigations-Guard ist lediglich eine Annehmlichkeit (um die Anzeige einer unnötigen Seite zu vermeiden). Der clientseitige Code liegt in den Händen des Benutzers; er kann ihn in seinem Browser lesen und ändern. Der wahre Schutz der Daten kommt vom Server, der bei jeder Anfrage die Identität und die Rolle des Benutzers prüft. Das sehen wir mit dem Server [RdvMedecins].