Kurs Angular · Moduł 12: Bezpieczeństwo i wydajność
Trzej strażnicy bramy - autentykacja
W tej lekcji3
Forteca samuraja ma jedną bramę i trzech strażników, którzy razem pilnują, kto wchodzi. W aplikacji Angular jest tak samo, a te trzy role poznasz w tej lekcji: service trzyma klucz (token), interceptor stempluje nim każde żądanie do serwera, a guard nie wpuszcza nikogo bez klucza na chronioną trasę. Idą po kolei.
Strażnik pierwszy: service trzyma klucz
Po zalogowaniu serwer wydaje token - cyfrowy klucz potwierdzający, kim jesteś. AuthService przechowuje go i wie, czy jesteś zalogowany.
@Injectable({ providedIn: 'root' })
export class AuthService {
private http = inject(HttpClient);
private currentUser = signal<User | null>(null);
readonly isLoggedIn = computed(() => !!this.currentUser());
readonly user = this.currentUser.asReadonly();
login(credentials: LoginCredentials): Observable<AuthResponse> {
return this.http.post<AuthResponse>('/api/auth/login', credentials).pipe(
tap(response => {
localStorage.setItem('access_token', response.accessToken);
this.currentUser.set(response.user);
})
);
}
getToken(): string | null {
return localStorage.getItem('access_token');
}
}Zwróć uwagę na dwie rzeczy. Token trafia do localStorage, żeby przetrwał odświeżenie strony - inaczej po każdym F5 użytkownik byłby wylogowany. A isLoggedIn to computed z sygnału currentUser - dzięki temu cała aplikacja reaguje na logowanie automatycznie: zmieni się użytkownik, zmieni się isLoggedIn, odświeży się każdy widok, który go czyta.
Strażnik drugi: interceptor stempluje żądania
Serwer przy każdym żądaniu pyta "pokaż klucz". Zamiast dopisywać token ręcznie w stu miejscach, interceptor przechwytuje każde wychodzące żądanie i dokłada nagłówek z tokenem.
export const authInterceptor: HttpInterceptorFn = (req, next) => {
const authService = inject(AuthService);
const token = authService.getToken();
if (token) {
req = req.clone({
headers: req.headers.set('Authorization', `Bearer ${token}`)
});
}
return next(req);
};Kluczowe jest req.clone - żądania w Angularze są niezmienne, więc nie dopisujesz nagłówka do oryginału, tylko tworzysz jego kopię z dodanym Authorization. Jedno miejsce, a token trafia automatycznie do każdego żądania w całej aplikacji. To dlatego interceptor jest lepszy niż ręczne dopisywanie.
Prawdziwa siła interceptora ujawnia się, gdy token wygasa. Zamiast wylogować użytkownika, możesz po cichu odświeżyć klucz i ponowić żądanie.
return next(req).pipe(
catchError((error: HttpErrorResponse) => {
if (error.status === 401) { // token wygasł
return authService.refreshToken().pipe(
switchMap(response => {
const newReq = req.clone({
headers: req.headers.set('Authorization', `Bearer ${response.accessToken}`)
});
return next(newReq); // ponów z nowym kluczem
}),
catchError(() => {
authService.logout(); // odświeżenie też padło - wyloguj
return throwError(() => error);
})
);
}
return throwError(() => error);
})
);Prześledź logikę: status 401 znaczy "klucz nieważny". Wtedy refreshToken prosi serwer o nowy, a switchMap ponawia pierwotne żądanie z nowym tokenem - użytkownik niczego nie zauważa. Dopiero gdy i odświeżenie zawiedzie, wewnętrzny catchError wylogowuje. To różnica między aplikacją, która co godzinę wyrzuca cię do logowania, a taką, która działa płynnie.
Strażnik trzeci: guard pilnuje trasy
Interceptor chroni żądania, ale samą trasę (np. panel admina) pilnuje guard - funkcja, która musi zwrócić true, żeby wpuścić na stronę.
export const authGuard: CanActivateFn = (route, state) => {
const authService = inject(AuthService);
const router = inject(Router);
if (authService.isLoggedIn()) {
return true;
}
return router.createUrlTree(['/login'], { queryParams: { returnUrl: state.url } });
};
export const roleGuard: CanActivateFn = (route) => {
const authService = inject(AuthService);
const requiredRoles = route.data['roles'] as string[];
const user = authService.user();
return !!user && requiredRoles.some(role => user.roles.includes(role));
};Dwa guardy pełnią różne role. authGuard sprawdza, czy jesteś zalogowany, a jeśli nie - przekierowuje do logowania, zapisując returnUrl, byś po zalogowaniu wrócił tam, gdzie chciałeś. roleGuard idzie dalej i pyta, kim jesteś: czy masz odpowiednią rolę. Zamiast false strażnik może zwrócić UrlTree: router.createUrlTree(['/access-denied']) buduje taki adres, a Angular czyta go jako "nie wpuszczam, idź tutaj" i sam przekierowuje - tak robi authGuard powyżej. Nie wołaj w strażniku navigate(): jak pamiętasz z modułu o szlakach, uruchamia ono drugą nawigację, zanim skończy się pierwsza. Wpinasz je do trasy razem:
const routes: Routes = [
{
path: 'admin',
canActivate: [authGuard, roleGuard],
data: { roles: ['admin', 'moderator'] },
loadComponent: () => import('./admin.component')
}
];Angular uruchomi oba guardy po kolei i wpuści na /admin dopiero, gdy oba zwrócą true - najpierw "czy zalogowany", potem "czy admin lub moderator". Pole data przekazuje guardowi listę dozwolonych ról, więc ten sam roleGuard obsłuży każdą trasę, zmieniasz tylko listę.
Pamiętaj z tej lekcji trzech strażników: service trzyma klucz, interceptor stempluje nim żądania (i po cichu go odświeża), a guard pilnuje wejścia na trasę. Razem tworzą jedną, szczelną bramę fortecy.
Kod do tej lekcji: src/app/app.component.ts
import { Component, signal, computed, ChangeDetectionStrategy } from '@angular/core';
import { CommonModule } from '@angular/common';
@Component({
selector: 'app-root',
standalone: true,
imports: [CommonModule],
changeDetection: ChangeDetectionStrategy.OnPush,
template: `
<div class="performance-dojo">
<h1>Optymalizacja Wydajności Angular</h1>
<section class="strategies">
<h2>Strategie Change Detection</h2>
<div class="strategy-comparison">
<div class="strategy default">
<h3>Default</h3>
<p>Sprawdza całe drzewo komponentów przy każdej zmianie</p>
<code>changeDetection: ChangeDetectionStrategy.Default</code>
</div>
<div class="strategy onpush">
<h3>OnPush Rekomendowane</h3>
<p>Sprawdza tylko gdy zmieni się @Input reference, event lub async pipe</p>
<code>changeDetection: ChangeDetectionStrategy.OnPush</code>
</div>
</div>
</section>
<section class="demo">
<h2>Demo: Wydajność listy</h2>
<div class="controls">
<button (click)="addItems(100)">Dodaj 100 elementów</button>
<button (click)="addItems(1000)">Dodaj 1000 elementów</button>
<button (click)="clearItems()">Wyczyść</button>
</div>
<div class="stats">
<div class="stat">
<span class="value">{{ items().length }}</span>
<span class="label">Elementów</span>
</div>
<div class="stat">
<span class="value">{{ renderCount() }}</span>
<span class="label">Renderowań</span>
</div>
</div>
<div class="list-container">
@for (item of items(); track item.id) {
<div class="list-item">
{{ item.name }} - {{ item.skill }}
</div>
}
</div>
</section>
<section class="tips">
<h2>Wskazówki optymalizacji</h2>
<div class="tip-grid">
<div class="tip">
<h3>trackBy w @for</h3>
<code>@for (item of items(); track item.id)</code>
<p>Unikaj renderowania całej listy</p>
</div>
<div class="tip">
<h3>OnPush + Signals</h3>
<code>count = signal(0)</code>
<p>Signals automatycznie powiadamiają o zmianach</p>
</div>
<div class="tip">
<h3>Lazy Loading</h3>
<code>loadComponent: () => import(...)</code>
<p>Ładuj moduły na żądanie</p>
</div>
<div class="tip">
<h3>@defer</h3>
<code>@defer (on viewport) ...</code>
<p>Opóźnij ładowanie komponentów</p>
</div>
<div class="tip">
<h3>Pure Pipes</h3>
<code>@Pipe({ pure: true })</code>
<p>Cache'uj wyniki transformacji</p>
</div>
<div class="tip">
<h3>Virtual Scrolling</h3>
<code><cdk-virtual-scroll-viewport></code>
<p>Renderuj tylko widoczne elementy</p>
</div>
</div>
</section>
<section class="code-example">
<h2>Przykłady optymalizacji</h2>
<pre><code>{{ optimizationCode }}</code></pre>
</section>
</div>
`,
styles: [`
.performance-dojo {
font-family: 'Segoe UI', sans-serif;
padding: 20px;
background: linear-gradient(135deg, #0f2027 0%, #203a43 50%, #2c5364 100%);
min-height: 100vh;
color: #ecf0f1;
}
h1 {
text-align: center;
color: #f39c12;
}
h2 {
color: #f39c12;
border-bottom: 2px solid #f39c12;
padding-bottom: 10px;
}
section {
background: rgba(255,255,255,0.05);
border-radius: 10px;
padding: 20px;
margin: 20px 0;
}
.strategy-comparison {
display: grid;
grid-template-columns: 1fr 1fr;
gap: 20px;
}
@media (max-width: 600px) {
.strategy-comparison {
grid-template-columns: 1fr;
}
}
.strategy {
padding: 20px;
border-radius: 10px;
}
.strategy.default {
background: rgba(231, 76, 60, 0.2);
border: 2px solid #e74c3c;
}
.strategy.onpush {
background: rgba(46, 204, 113, 0.2);
border: 2px solid #2ecc71;
}
.strategy h3 {
margin-top: 0;
}
.strategy code {
display: block;
background: rgba(0,0,0,0.3);
padding: 10px;
border-radius: 5px;
font-size: 0.85em;
}
.controls {
display: flex;
gap: 10px;
margin-bottom: 20px;
flex-wrap: wrap;
}
button {
padding: 10px 20px;
background: #f39c12;
color: #0f2027;
border: none;
border-radius: 5px;
font-weight: bold;
cursor: pointer;
}
button:hover {
background: #f1c40f;
}
.stats {
display: flex;
gap: 30px;
margin-bottom: 20px;
}
.stat {
text-align: center;
}
.stat .value {
display: block;
font-size: 2em;
font-weight: bold;
color: #f39c12;
}
.stat .label {
color: #888;
}
.list-container {
max-height: 200px;
overflow-y: auto;
background: rgba(0,0,0,0.3);
border-radius: 5px;
padding: 10px;
}
.list-item {
padding: 8px;
margin: 2px 0;
background: rgba(243, 156, 18, 0.1);
border-radius: 3px;
font-size: 0.9em;
}
.tip-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
gap: 15px;
}
.tip {
background: rgba(0,0,0,0.3);
padding: 15px;
border-radius: 8px;
}
.tip h3 {
margin-top: 0;
color: #f39c12;
font-size: 1em;
}
.tip code {
display: block;
background: rgba(243, 156, 18, 0.2);
padding: 8px;
border-radius: 4px;
font-size: 0.8em;
margin-bottom: 8px;
}
.tip p {
margin: 0;
color: #aaa;
font-size: 0.9em;
}
pre {
background: #0f2027;
padding: 15px;
border-radius: 8px;
overflow-x: auto;
border-left: 4px solid #f39c12;
}
pre code {
color: #ecf0f1;
font-family: 'Fira Code', monospace;
font-size: 0.85em;
}
`]
})
export class AppComponent {
items = signal<SamuraiItem[]>([]);
renderCount = signal(0);
optimizationCode = `// 1. OnPush Change Detection
@Component({
changeDetection: ChangeDetectionStrategy.OnPush,
// ...
})
// 2. trackBy w @for
@for (item of items(); track item.id) {
<div>{{ item.name }}</div>
}
// 3. @defer dla lazy loading komponentów
@defer (on viewport) {
<app-heavy-component />
} @placeholder {
<div>Ładowanie...</div>
}
// 4. Virtual Scrolling dla długich list
<cdk-virtual-scroll-viewport itemSize="50" class="list">
<div *cdkVirtualFor="let item of items">
{{ item.name }}
</div>
</cdk-virtual-scroll-viewport>
// 5. Signals zamiast Subject dla stanu
count = signal(0);
doubleCount = computed(() => this.count() * 2);
// 6. Pure Pipe dla transformacji
@Pipe({ name: 'filter', pure: true })
export class FilterPipe implements PipeTransform {
transform(items: any[], predicate: (item: any) => boolean) {
return items.filter(predicate);
}
}`;
addItems(count: number): void {
const newItems: SamuraiItem[] = [];
const startId = this.items().length;
for (let i = 0; i < count; i++) {
newItems.push({
id: startId + i,
name: `Samuraj #${startId + i}`,
skill: Math.floor(Math.random() * 100)
});
}
this.items.update(items => [...items, ...newItems]);
this.renderCount.update(c => c + 1);
}
clearItems(): void {
this.items.set([]);
this.renderCount.update(c => c + 1);
}
}
interface SamuraiItem {
id: number;
name: string;
skill: number;
}Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Kiedy używamy DomSanitizer.bypassSecurityTrustHtml()?
2. Jaki typ ma nowoczesny functional guard chroniący trasę w Angular 19?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Uzupełnij guard sprawdzający rolę administratora.
- Układanie w pionie
Uporządkuj linie definiujące reaktywny stan zalogowania w AuthService (kolejność od góry):
- Układanie w pionie
Uporządkuj pola obiektu trasy chronionej guardem (kolejność od góry):