4. Enrutamiento
4.1. Ejemplo 17: el enrutador
Una aplicación [Angular] es una aplicación de página única: el navegador carga una sola página HTML. Sin embargo, la aplicación [RdvMedecins] tiene varias páginas (/login, /schedule, /doctors...), cada una con su propia URL, que se puede guardar como marcador o recargar. Este es el papel del enrutador de [Angular]: asocia cada URL con un componente (la “página”) y muestra ese componente cuando cambia la URL, sin hacer ninguna solicitud al servidor.
| 17-router/src/
├── app/
│ ├── pages/
│ │ ├── home.ts
│ │ ├── doctor-list.ts
│ │ ├── doctor-detail.ts
│ │ ├── search.ts
│ │ ├── about.ts
│ │ └── not-found-page.ts
│ ├── data.ts three "hard-coded" doctors
│ ├── app.routes.ts the routes
│ ├── app.config.ts the configuration of the application
│ ├── app.ts
│ └── app.html
├── index.html
└── main.ts
|
4.1.1. Las rutas
| // =========================================================================
// 17-router/src/app/app.routes.ts - las RUTAS de la aplicación
// -------------------------------------------------------------------------
// Una aplicación Angular es una aplicación de página única (SPA: Single
// Page Application): el navegador carga solo UNA página HTML. Cuando se hace
// clic en un enlace interno, no se envía ninguna petición al servidor: el
// enrutador cambia la dirección mostrada por el navegador y reemplaza el
// componente mostrado en <router-outlet>.
//
// Una ruta asocia un PATH con un COMPONENTE (una "página"):
// 'doctors/:id' :id es un parámetro (/doctors/2 -> id = "2");
// '**' cualquier path: la página "no encontrado". Las
// rutas se prueban en orden: esta va AL FINAL.
// title: el título de la pestaña del navegador cuando se muestra la página.
// =========================================================================
import { Routes } from '@angular/router';
import { Home } from './pages/home';
import { DoctorList } from './pages/doctor-list';
import { DoctorDetail } from './pages/doctor-detail';
import { Search } from './pages/search';
import { NotFoundPage } from './pages/not-found-page';
export const routes: Routes = [
{ path: '', component: Home, title: 'Home' },
{ path: 'doctors', component: DoctorList, title: 'Doctors' },
{ path: 'doctors/:id', component: DoctorDetail, title: 'A doctor' },
{ path: 'search', component: Search, title: 'Search' },
// Carga DIFERIDA: el código de esta página solo se descarga en la
// primera visita (el compilador lo convierte en un archivo aparte)
{ path: 'about', loadComponent: () => import('./pages/about'), title: 'About' },
// una redirección: la dirección antigua lleva a la nueva
{ path: 'physicians', redirectTo: 'doctors' },
{ path: '**', component: NotFoundPage, title: 'Page not found' },
];
|
- línea 24: las rutas forman un arreglo de objetos de tipo [Routes];
- línea 25: la ruta vacía: la página de inicio, en la dirección /. Nunca se coloca un / al principio de una ruta;
- línea 27: [:id] es un parámetro: /doctors/1, /doctors/2... muestran todas el componente [DoctorDetail], que recibe el valor de [id];
- línea 31: [loadComponent] reemplaza a [component]: el componente se carga solo en la primera visita a la página. El compilador guarda su código en un archivo aparte, que se descarga en ese momento; esto acelera el tiempo de carga de la aplicación. Haremos esto para todas las páginas del caso de estudio;
- línea 33: una redirección: /physicians conduce a /doctors;
- línea 34: [**]: cualquier ruta. Como las rutas se prueban en orden, esta solo se usa si ninguna de las otras coincide: es la página de “página no encontrada”;
- [title]: el título de la pestaña del navegador cuando se muestra la página.
4.1.2. Configuración de la aplicación
| // =========================================================================
// 17-router/src/app/app.config.ts
// -------------------------------------------------------------------------
// provideRouter(routes): agregamos el enrutador a la aplicación, con sus
// rutas (app.routes.ts). withComponentInputBinding(): los parámetros de
// la dirección (/doctors/:id, ?q=...) se pasan a los componentes de las páginas
// como INPUTS (input()) - ver pages/doctor-detail.ts.
// =========================================================================
import { ApplicationConfig } from '@angular/core';
import { provideRouter, withComponentInputBinding } from '@angular/router';
import { routes } from './app.routes';
export const appConfig: ApplicationConfig = {
providers: [provideRouter(routes, withComponentInputBinding())],
};
|
Hasta ahora, la configuración de la aplicación estaba contenida en el archivo [main.ts]. Ahora se almacena por separado en [app.config.ts], como en los proyectos creados por el comando [ng new]:
- Línea 15: [provideRouter] agrega el enrutador a la aplicación, junto con sus rutas. [withComponentInputBinding()] pasa los parámetros de la dirección a los componentes de página como entradas ([input()], ejemplo 10): esta es la forma más sencilla de leerlos.
| // =========================================================================
// 17-router/src/main.ts
// -------------------------------------------------------------------------
// La configuración de la aplicación (sus "providers") se guarda por separado,
// en app.config.ts: es la organización habitual de un proyecto Angular.
// =========================================================================
import { bootstrapApplication } from '@angular/platform-browser';
import { appConfig } from './app/app.config';
import { App } from './app/app';
bootstrapApplication(App, appConfig).catch((error) => console.error(error));
|
- Línea 12: [bootstrapApplication] recibe la configuración.
| <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Example 17 - the router</title>
<base href="/">
<meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body>
<app-root></app-root>
</body>
</html>
|
- línea 6: [<base href="/">]: la dirección a partir de la cual el enrutador calcula las rutas. Sin ella, las direcciones de varios niveles (/doctors/2) no funcionarían.
4.1.3. La estructura base de la aplicación
El componente raíz se convierte en un shell: contiene los elementos comunes a todas las páginas (en este caso, el título y los enlaces) y un espacio donde se muestra la página actual.
| // =========================================================================
// 17-router/src/app/app.ts - el "shell" de la aplicación
// -------------------------------------------------------------------------
// - routerLink="...": un enlace interno. En una etiqueta <a>, produce un
// href real, pero un clic no recarga la página: el enrutador
// actúa. routerLinkActive="active" establece la clase "active" (la de
// Bootstrap) en el enlace de la página mostrada;
// - <router-outlet />: el lugar donde se muestra el componente de la
// ruta actual.
// =========================================================================
import { Component, inject } from '@angular/core';
import { toSignal } from '@angular/core/rxjs-interop';
import { NavigationEnd, Router, RouterLink, RouterLinkActive, RouterOutlet } from '@angular/router';
import { filter, map } from 'rxjs';
@Component({
selector: 'app-root',
imports: [RouterLink, RouterLinkActive, RouterOutlet],
templateUrl: './app.html',
})
export class App {
private readonly router = inject(Router);
// la dirección actual, como signal: router.events es un flujo
// (Observable, ver ejemplo 19) de eventos de navegación; conservamos el
// final de cada navegación, y toSignal lo convierte en un signal
protected readonly address = toSignal(
this.router.events.pipe(
filter((e) => e instanceof NavigationEnd),
// decodeURIComponent: %20 vuelve a ser un espacio
map((e) => decodeURIComponent(e.urlAfterRedirects)),
),
{ initialValue: '' },
);
}
|
- línea 19: las directivas del enrutador utilizadas por la plantilla;
- líneas 28–35: la URL actual, mostrada debajo de los enlaces. [router.events] es un observable (un flujo de eventos, como se mostró en el ejemplo 19) que señala cada etapa de la navegación. Conservamos solo los finales de navegación (línea 30), extraemos de ellos la dirección, incluidas las redirecciones eventuales (línea 32), y [toSignal] transforma el flujo en un signal que se puede usar en la plantilla.
| <div class="container py-4">
<h1 class="h3 mb-3">Example 17 - the router</h1>
<nav class="nav nav-pills mb-3">
<!-- routerLinkActiveOptions exact: "/" no debe estar activo en /doctors -->
<a class="nav-link" routerLink="/" routerLinkActive="active" [routerLinkActiveOptions]="{ exact: true }">Home</a>
<a class="nav-link" routerLink="/doctors" routerLinkActive="active">Doctors</a>
<!-- [queryParams]: los parámetros después del ? (/search?q=general practitioner);
queryParams: 'ignored': el enlace permanece activo sea cual sea la búsqueda -->
<a class="nav-link" routerLink="/search" [queryParams]="{ q: 'general practitioner' }" routerLinkActive="active"
[routerLinkActiveOptions]="{ paths: 'exact', queryParams: 'ignored', fragment: 'ignored', matrixParams: 'ignored' }">Search</a>
<a class="nav-link" routerLink="/about" routerLinkActive="active">About</a>
<a class="nav-link" routerLink="/physicians">/physicians (redirection)</a>
<a class="nav-link" routerLink="/unknown-page">Broken link</a>
</nav>
<p class="small text-muted">current address: <code>{{ address() }}</code></p>
<div class="card p-3">
<router-outlet />
</div>
</div>
|
- Línea 5: [routerLink]: un enlace interno. Para una etiqueta [<a>], genera un atributo [href] válido (el enlace se puede abrir en una pestaña nueva), pero al hacer clic no se recarga la página: el enrutador es quien cambia la dirección y la visualización. [routerLinkActive="active"] aplica la clase [active] (derivada de [Bootstrap]) al enlace de la página mostrada. Sin la opción [exact], el enlace / estaría activo en todas las páginas, ya que todas las direcciones comienzan con /;
- líneas 9–10: [[queryParams]]: los parámetros colocados después del [?] en la URL (/search?q=general practitioner). La opción [queryParams: 'ignored'] mantiene el enlace activo sea cual sea la búsqueda;
- líneas 12–13: un enlace a la redirección y un enlace a una dirección que no existe;
- línea 17: [<router-outlet />]: el lugar donde se muestra el componente de la ruta actual.
4.1.4. Las páginas
| // datos "escritos a mano", para no depender de un servidor en este ejemplo
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' },
];
|
| import { Component } from '@angular/core';
@Component({
selector: 'app-home',
template: `
<p class="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 reloading (F5) any page.</p>
`,
})
export class Home {}
|
Una página es un componente normal. No tiene nada de especial.
| // 17-router/src/app/pages/doctor-list.ts - enlaces con un parámetro
import { Component } from '@angular/core';
import { RouterLink } from '@angular/router';
import { DOCTORS } from '../data';
@Component({
selector: 'app-doctor-list',
imports: [RouterLink],
template: `
<ul class="mb-0">
@for (m of doctors; track m.id) {
<!-- [routerLink] con un arreglo: el enrutador ensambla la dirección /doctors/2 -->
<li><a [routerLink]="['/doctors', m.id]">{{ m.title }} {{ m.firstName }} {{ m.lastName }}</a></li>
}
</ul>
`,
})
export class DoctorList {
protected readonly doctors = DOCTORS;
}
|
- Línea 13: [[routerLink]] recibe aquí un arreglo: el enrutador ensambla la dirección a partir de sus elementos (/doctors/2).
| // =========================================================================
// 17-router/src/app/pages/doctor-detail.ts - una página con un parámetro
// -------------------------------------------------------------------------
// El parámetro :id llega como un INPUT (gracias a withComponentInputBinding,
// ver app.config.ts), como cadena: basta con declarar un
// input que tenga el mismo nombre. El componente ya no depende entonces del
// enrutador: también podría usarse como <app-doctor-detail id="2">.
// Router.navigate(...): navegar POR CÓDIGO; Location.back(): volver
// a la página anterior, como el botón Atrás del navegador.
// =========================================================================
import { Component, computed, inject, input } from '@angular/core';
import { Location } from '@angular/common';
import { Router } from '@angular/router';
import { DOCTORS } from '../data';
@Component({
selector: 'app-doctor-detail',
template: `
@if (doctor(); as m) {
<h2 class="h5">{{ m.title }} {{ m.firstName }} {{ m.lastName }}</h2>
<p>Specialty: {{ m.specialty }}</p>
<div class="d-flex gap-2">
<button class="btn btn-sm btn-outline-secondary" (click)="back()">Back</button>
<button class="btn btn-sm btn-outline-primary" (click)="next()">Next doctor</button>
</div>
} @else {
<p class="text-danger mb-0">Doctor no. {{ id() }} does not exist.</p>
}
`,
})
export class DoctorDetail {
readonly id = input.required<string>();
private readonly router = inject(Router);
private readonly location = inject(Location);
// computed: al pasar de /doctors/1 a /doctors/2, Angular REUTILIZA
// el mismo componente y solo cambia el input id - el computed lo sigue
protected readonly doctor = computed(() => DOCTORS.find((m) => m.id === Number(this.id())) ?? null);
protected back(): void {
this.location.back();
}
protected next(): void {
const id = (Number(this.id()) % DOCTORS.length) + 1;
this.router.navigate(['/doctors', id]);
}
}
|
- línea 33: el parámetro de ruta [:id] se pasa a la entrada del mismo nombre. Como todo lo que proviene de una dirección, es una cadena;
- línea 39: el médico mostrado se calcula a partir de la entrada. Al pasar de /doctors/1 a /doctors/2, [Angular] no vuelve a crear el componente: solo cambia el valor de la entrada, y [computed] lo sigue;
- líneas 27–29: se informa de un identificador desconocido (/doctors/9);
- línea 42: [Location.back()]: volver a la página anterior, como con el botón Atrás del navegador;
- línea 47: [Router.navigate]: navegación activada desde el código, con el mismo arreglo que [[routerLink]].
| // =========================================================================
// 17-router/src/app/pages/search.ts - una página controlada por la URL
// -------------------------------------------------------------------------
// /search?q=pediatrician: como con el formulario GET del curso de NestJS, la
// página queda descrita por completo por su dirección: se puede guardar como favorito,
// recargar, volver a ella. El parámetro q también llega
// como un input del componente.
// =========================================================================
import { Component, computed, inject, input, linkedSignal } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { Router } from '@angular/router';
import { DOCTORS } from '../data';
@Component({
selector: 'app-search',
imports: [FormsModule],
template: `
<form class="d-flex gap-2 mb-3" (ngSubmit)="search()">
<input name="input" class="form-control" placeholder="name or specialty" [(ngModel)]="input">
<button class="btn btn-primary">Search</button>
</form>
<ul class="mb-0">
@for (m of results(); track m.id) {
<li>{{ m.firstName }} {{ m.lastName }} ({{ m.specialty }})</li>
} @empty {
<li class="text-muted">No result.</li>
}
</ul>
`,
})
export class Search {
readonly q = input<string>(); // ?q=... (undefined si no está)
private readonly router = inject(Router);
// el campo parte con el valor de la URL, y la sigue si cambia
// (botón Atrás), sin dejar de ser editable: un linkedSignal
protected readonly input = linkedSignal(() => this.q() ?? '');
protected readonly results = computed(() => {
const q = (this.q() ?? '').toLowerCase();
return DOCTORS.filter((m) => `${m.firstName} ${m.lastName} ${m.specialty}`.toLowerCase().includes(q));
});
protected search(): void {
// cambiamos la URL; la visualización sigue a la URL (input q)
this.router.navigate(['/search'], { queryParams: { q: this.input() } });
}
}
|
Esta página queda completamente descrita por su dirección, igual que la de un formulario GET: se puede guardar como marcador, recargar o volver a ella con el botón Atrás.
- Línea 33: el parámetro [q] de la dirección también se pasa como una entrada; si falta, su valor es [undefined];
- línea 38: el campo de entrada es un [linkedSignal]: toma el valor de la dirección, se actualiza en consecuencia cuando la dirección cambia (con el botón Atrás), pero sigue siendo editable por el usuario;
- Líneas 40–43: los resultados dependen de la dirección, no de la entrada: solo cambian cuando se envía el formulario;
- línea 47: el envío del formulario cambia la dirección, lo que cambia la entrada [q], lo que cambia los resultados.
| // 17-router/src/app/pages/about.ts - una página cargada a demanda
// "export default": loadComponent: () => import('./pages/about') encuentra
// el componente sin tener que nombrarlo
import { Component } from '@angular/core';
@Component({
selector: 'app-about',
template: `<p class="mb-0">This page was downloaded on the first visit (Network tab: a file
chunk-XXXX.js). Its tab title comes from the route.</p>`,
})
export default class About {}
|
- línea 11: [export default]: la función [loadComponent] de la ruta ([import('./pages/about')]) encuentra el componente sin tener que especificar su nombre.
| import { Component, inject } from '@angular/core';
import { Router } from '@angular/router';
@Component({
selector: 'app-not-found-page',
template: `<p class="text-danger mb-0">No page at the address <code>{{ address }}</code>.</p>`,
})
export class NotFoundPage {
protected readonly address = inject(Router).url;
}
|
- Línea 9: [Router.url]: la dirección solicitada.
4.1.5. Ejecución
[npm start 17-router]; haga clic en “Doctors” y luego en “Paul” TATOU:

Haga clic en “Search”, escriba “pediatrician” y presione Enter: la dirección cambia.

El enlace roto conduce a un error de "página no encontrada":

Puede verificar en la pestaña Network de las herramientas de desarrollo del navegador que no se solicita ninguna página al servidor al hacer clic, salvo en la primera visita a la página “About” (un archivo llamado [chunk-XXXX.js]). También puede recargar cualquier página (F5): el servidor de desarrollo siempre devuelve [index.html], y el enrutador muestra la página correspondiente a la dirección. Un servidor de producción debe hacer lo mismo: esto es lo que hará el servidor JSON durante el despliegue.
4.2. Ejemplo 18: guardias de navegación para páginas
Algunas páginas de la aplicación [RdvMedecins] son de acceso restringido: la agenda requiere iniciar sesión, y la gestión de médicos requiere el rol ADMIN. Del lado del servidor, el curso de [NestJS] usaba controles de acceso ([JwtAuthGuard], [RolesGuard]). El enrutador de [Angular] tiene los suyos: funciones llamadas antes de mostrar una ruta, que pueden permitir la navegación o redirigirla a otra dirección.
Este ejemplo simula la conexión sin servidor: tres cuentas están escritas directamente en el código.
| 18-guards/src/app/
├── pages/
│ ├── home.ts public page
│ ├── login.ts public page
│ ├── schedule.ts requires being logged in
│ └── administration.ts requires the ADMIN role
├── session.service.ts the logged-in user
├── guards.ts the guards
├── app.routes.ts
├── app.config.ts
├── app.ts
└── app.html
|
4.2.1. La sesión
| // =========================================================================
// 18-guards/src/app/session.service.ts - una sesión SIMULADA (sin servidor)
// -------------------------------------------------------------------------
// El usuario conectado, en un servicio raíz: todos los componentes y
// todos los guards que lo inyectan comparten el mismo. (El ejemplo 23 hará
// lo mismo con un servidor real.)
// =========================================================================
import { Injectable, signal } from '@angular/core';
export type Role = 'ADMIN' | 'DOCTOR' | 'USER';
export interface User {
login: string;
role: Role;
}
// tres cuentas "escritas a mano" (contraseña = login)
const ACCOUNTS: Record<string, Role> = { admin: 'ADMIN', pelissier: 'DOCTOR', martin: 'USER' };
@Injectable({ providedIn: 'root' })
export class SessionService {
private readonly _user = signal<User | null>(null);
readonly user = this._user.asReadonly();
logIn(login: string, password: string): boolean {
const role = Object.hasOwn(ACCOUNTS, login) ? ACCOUNTS[login] : undefined;
if (role === undefined || password !== login) {
return false;
}
this._user.set({ login, role });
return true;
}
logOut(): void {
this._user.set(null);
}
}
|
- Línea 11: los tres roles de la aplicación [RdvMedecins];
- línea 19: tres cuentas, cada una con una contraseña igual al nombre de usuario;
- líneas 23–24: el usuario conectado ([null] si no hay ninguno), en un signal que solo el servicio puede modificar. Como hay un único servicio, los componentes y guardias que lo inyectan ven todos al mismo usuario;
- línea 27: [Object.hasOwn]: solo se retienen las claves propias del objeto [ACCOUNTS]. Sin esta precaución, el login “constructor” encontraría una propiedad heredada de todos los objetos [JavaScript];
- Líneas 26–33: el inicio de sesión tiene éxito si la cuenta existe y la contraseña es correcta.
4.2.2. Los guardias
| // =========================================================================
// 18-guards/src/app/guards.ts - GUARDS de navegación
// -------------------------------------------------------------------------
// Un guard (CanActivateFn) es una función que el enrutador llama ANTES de
// mostrar una ruta que lo declara (canActivate: [...]). Devuelve:
// - true : la navegación continúa;
// - un UrlTree (una dirección, construida con router.createUrlTree): la
// navegación se reemplaza por una redirección a esta dirección.
// Un guard puede inyectar servicios (inject): se ejecuta en el
// contexto de inyección de la aplicación.
//
// Es el equivalente del lado cliente de los guards de NestJS (JwtAuthGuard,
// RolesGuard) - con una diferencia FUNDAMENTAL: un guard del cliente es
// solo una comodidad. El código del cliente está en manos del usuario, que
// puede modificarlo a voluntad. La verdadera protección de los datos sigue siendo la
// del SERVIDOR (ver el capítulo sobre la caja negra).
// =========================================================================
import { inject } from '@angular/core';
import { CanActivateFn, Router } from '@angular/router';
import { Role, SessionService } from './session.service';
// la página requiere haber iniciado sesión
export const loginRequired: CanActivateFn = (_route, state) => {
if (inject(SessionService).user() !== null) {
return true;
}
// sin sesión iniciada: a la página de inicio de sesión, recordando adónde queríamos ir
return inject(Router).createUrlTree(['/login'], { queryParams: { redirect: state.url } });
};
// la página requiere uno de los roles listados en los datos de la ruta (data.roles)
export const roleRequired: CanActivateFn = (route, state) => {
const roles = route.data['roles'] as Role[];
const user = inject(SessionService).user();
if (user !== null && roles.includes(user.role)) {
return true;
}
// sesión iniciada, pero sin el rol adecuado: de regreso a la página de inicio, con un motivo
return inject(Router).createUrlTree(['/'], { queryParams: { denied: state.url } });
};
|
- línea 24: un guardia es una función de tipo [CanActivateFn]. El enrutador le pasa la ruta que se va a activar y el estado de la navegación (que contiene la dirección solicitada, [state.url]);
- línea 25: un guardia puede inyectar servicios, mediante [inject], como un componente;
- línea 26: [true]: la navegación continúa;
- línea 29: en caso contrario, el guardia devuelve otra dirección, generada por [createUrlTree]: la navegación se reemplaza por una redirección a la página de inicio de sesión. El parámetro [redirect] conserva la página solicitada, para volver a ella después de iniciar sesión;
- línea 34: [route.data]: los datos libres declarados por la ruta (aquí, los roles autorizados). Así, el mismo guardia sirve para todas las páginas restringidas, sea cual sea su rol;
- línea 40: un usuario conectado cuyo rol no es el adecuado se redirige a la página de inicio, junto con el motivo de la denegación.
Los comentarios de las líneas 12–16 son esenciales: un guardia del lado del cliente es solo una comodidad para el usuario, que le evita abrir una página que podría no funcionar. El código del lado del cliente se ejecuta en el navegador; el usuario puede leerlo y modificarlo. La protección de los datos sigue siendo responsabilidad del servidor, que verifica los permisos en cada solicitud.
4.2.3. Rutas protegidas
| // =========================================================================
// 18-guards/src/app/app.routes.ts - rutas PROTEGIDAS
// -------------------------------------------------------------------------
// - canActivate: los guards que hay que pasar, en orden;
// - data : información libre asociada a la ruta (aquí, los
// roles autorizados), que el guard lee.
// =========================================================================
import { Routes } from '@angular/router';
import { loginRequired, roleRequired } from './guards';
import { Home } from './pages/home';
import { Login } from './pages/login';
import { Schedule } from './pages/schedule';
export const routes: Routes = [
{ path: '', component: Home },
{ path: 'login', component: Login },
{ path: 'schedule', component: Schedule, canActivate: [loginRequired] },
{
path: 'administration',
// carga diferida: el código solo se descarga una vez superados los guards
loadComponent: () => import('./pages/administration'),
canActivate: [loginRequired, roleRequired],
data: { roles: ['ADMIN'] },
},
{ path: '**', redirectTo: '' },
];
|
- línea 18: [canActivate]: la lista de guardias de la ruta;
- línea 22: la página de administración se carga bajo demanda: su código solo se descarga si los guardias lo autorizan;
- línea 23: dos guardias, llamados en orden: primero, haber iniciado sesión; segundo, tener el rol correcto;
- línea 24: los roles autorizados, leídos por el guardia [roleRequired];
- línea 26: cualquier dirección desconocida redirige a la página de inicio.
| import { ApplicationConfig } from '@angular/core';
import { provideRouter, withComponentInputBinding } from '@angular/router';
import { routes } from './app.routes';
export const appConfig: ApplicationConfig = {
providers: [provideRouter(routes, withComponentInputBinding())],
};
|
La configuración es la misma que en el ejemplo anterior.
4.2.4. Las páginas
| // =========================================================================
// 18-guards/src/app/pages/login.ts
// -------------------------------------------------------------------------
// Después de iniciar sesión, se envía al usuario de vuelta a la página que quería
// abrir (parámetro ?redirect=... establecido por el guard), o a la página de inicio.
// router.navigateByUrl: navegar a una dirección completa (/schedule?x=1).
// =========================================================================
import { Component, inject, input, signal } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { Router } from '@angular/router';
import { SessionService } from '../session.service';
@Component({
selector: 'app-login',
imports: [FormsModule],
template: `
@if (redirect()) {
<p class="alert alert-warning">Log in to open {{ redirect() }}.</p>
}
<form class="d-flex flex-wrap gap-2" (ngSubmit)="submit()">
<input name="login" class="form-control w-auto" placeholder="login" autocomplete="username" [(ngModel)]="login">
<input name="password" type="password" class="form-control w-auto" placeholder="password"
autocomplete="current-password" [(ngModel)]="password">
<button class="btn btn-primary">Log in</button>
</form>
@if (error()) {
<p class="text-danger mt-2 mb-0">Incorrect login or password.</p>
}
`,
})
export class Login {
readonly redirect = input<string>();
private readonly session = inject(SessionService);
private readonly router = inject(Router);
protected readonly login = signal('');
protected readonly password = signal('');
protected readonly error = signal(false);
protected submit(): void {
this.error.set(!this.session.logIn(this.login().trim(), this.password()));
if (!this.error()) {
const redirect = this.redirect();
// solo aceptamos un path INTERNO: empieza con /, pero no con //
// (//site.com/... designa OTRO sitio) - ninguna redirección a otro sitio
const internal = redirect !== undefined && redirect.startsWith('/') && !redirect.startsWith('//');
this.router.navigateByUrl(internal ? redirect : '/');
}
}
}
|
- Línea 33: se recibe el parámetro [redirect], colocado en la dirección por el guardia;
- líneas 18–20: se muestra al usuario;
- línea 41: la conexión;
- líneas 43–47: si tiene éxito, el usuario es redirigido a la página solicitada ([navigateByUrl] acepta una URL completa, incluidos los parámetros) o a la página de inicio. El parámetro [redirect] proviene de la URL: cualquiera puede crear un enlace a /login?redirect=//malicious-site.com. Por lo tanto, la línea 46 solo acepta una ruta interna a la aplicación.
| import { Component, input } from '@angular/core';
@Component({
selector: 'app-home',
template: `
<!-- ?denied=...: establecido por el guard roleRequired cuando el rol no corresponde -->
@if (denied()) {
<p class="alert alert-danger">Your role does not allow you to open {{ denied() }}.</p>
}
<p class="mb-0">Public page. Try the two other links, logged in or not (admin, pelissier, martin -
password = login).</p>
`,
})
export class Home {
readonly denied = input<string>();
}
|
- Línea 15: el motivo de una denegación, enviado por el guardia [roleRequired].
| import { Component, inject } from '@angular/core';
import { SessionService } from '../session.service';
@Component({
selector: 'app-schedule',
template: `<p class="mb-0">The schedule of <strong>{{ session.user()?.login }}</strong>: this page requires being logged in.</p>`,
})
export class Schedule {
protected readonly session = inject(SessionService);
}
|
| import { Component } from '@angular/core';
@Component({
selector: 'app-administration',
template: `<p class="mb-0">Administration: page reserved for the ADMIN role, loaded on demand (Network tab:
its chunk-XXXX.js file is only downloaded on the first visit).</p>`,
})
export default class Administration {}
|
4.2.5. El shell
| import { Component, inject } from '@angular/core';
import { Router, RouterLink, RouterLinkActive, RouterOutlet } from '@angular/router';
import { SessionService } from './session.service';
@Component({
selector: 'app-root',
imports: [RouterLink, RouterLinkActive, RouterOutlet],
templateUrl: './app.html',
})
export class App {
protected readonly session = inject(SessionService);
private readonly router = inject(Router);
protected onLogOut(): void {
this.session.logOut();
this.router.navigate(['/']);
}
}
|
| <div class="container py-4" style="max-width: 720px">
<h1 class="h3 mb-3">Example 18 - navigation guards</h1>
<nav class="d-flex gap-3 align-items-center mb-3">
<a routerLink="/" routerLinkActive="fw-bold" [routerLinkActiveOptions]="{ exact: true }">Home</a>
<a routerLink="/schedule" routerLinkActive="fw-bold">Schedule (logged in)</a>
<a routerLink="/administration" routerLinkActive="fw-bold">Administration (ADMIN)</a>
<span class="ms-auto">
@if (session.user(); as u) {
{{ u.login }} <span class="badge text-bg-primary">{{ u.role }}</span>
<button class="btn btn-sm btn-link" (click)="onLogOut()">log out</button>
} @else {
<a routerLink="/login">log in</a>
}
</span>
</nav>
<div class="card p-3"><router-outlet /></div>
</div>
|
- Líneas 8–13: el usuario conectado y su rol, o un enlace a la página de inicio de sesión;
- línea 10: cerrar sesión devuelve al usuario a la página de inicio (app.ts, líneas 14–17).
4.2.6. Ejecución
[npm start 18-guards]; sin haber iniciado sesión, haga clic en Administration: el guardia [loginRequired] redirige a la página de inicio de sesión, conservando la página solicitada.

Inicie sesión como martin, que tiene el rol USER: después de iniciar sesión, se le redirige a /administration; esta vez, el guardia [roleRequired] deniega la navegación.

Al iniciar sesión como admin, el mismo enlace abre la página de administración.