Kurs JavaScript i React · Moduł 6: React Router
Zabezpieczanie ścieżek w kosmicznej stacji
W tej lekcji9
W różnych sektorach naszej kosmicznej stacji potrzebujemy różnych poziomów dostępu. Nie każdy członek załogi powinien mieć dostęp do wszystkich obszarów - podobnie w aplikacjach internetowych, gdzie niektóre strony powinny być dostępne tylko dla zalogowanych użytkowników lub osób z określonymi uprawnieniami.
Czym są chronione ścieżki?
Chronione ścieżki (protected routes) to mechanizm, który pozwala na ograniczenie dostępu do określonych części aplikacji tylko dla uprawnionych użytkowników. Zwykle implementuje się je sprawdzając, czy użytkownik jest zalogowany lub czy posiada odpowiednie uprawnienia.
Podstawowa implementacja chronionej ścieżki
Najprostszym sposobem na zabezpieczenie ścieżki jest wykorzystanie komponentu wyższego rzędu (HOC), który sprawdza stan uwierzytelnienia:
import { Navigate, useLocation } from 'react-router-dom';
import { useAuth } from './AuthContext';
function ProtectedRoute({ children }) {
const { user, isLoading } = useAuth();
const location = useLocation();
// Pokazujemy wskaźnik ładowania podczas sprawdzania stanu uwierzytelnienia
if (isLoading) {
return <div className="loading">Sprawdzanie uprawnień do sekcji...</div>;
}
// Jeśli użytkownik nie jest zalogowany, przekieruj do strony logowania
if (!user) {
// Zapisujemy ścieżkę, z której użytkownik przyszedł, aby móc wrócić po zalogowaniu
return <Navigate to="/login" state={{ from: location.pathname }} replace />;
}
// Jeśli użytkownik jest zalogowany, renderuj chronioną zawartość
return children;
}Następnie możemy użyć tego komponentu w naszych ścieżkach:
<Routes>
<Route path="/" element={<HomePage />} />
<Route path="/login" element={<LoginPage />} />
{/* Chronione ścieżki */}
<Route path="/command-center" element={
<ProtectedRoute>
<CommandCenter />
</ProtectedRoute>
} />
<Route path="/restricted-area" element={
<ProtectedRoute>
<RestrictedArea />
</ProtectedRoute>
} />
</Routes>Kontekst uwierzytelniania
Aby powyższy kod działał, potrzebujemy kontekstu uwierzytelniania, który będzie przechowywał informacje o zalogowanym użytkowniku:
import { createContext, useContext, useState, useEffect } from 'react';
const AuthContext = createContext(null);
export function AuthProvider({ children }) {
const [user, setUser] = useState(null);
const [isLoading, setIsLoading] = useState(true);
useEffect(() => {
// Sprawdzamy, czy użytkownik jest już zalogowany (np. przez token w localStorage)
const checkAuthStatus = async () => {
try {
setIsLoading(true);
const token = localStorage.getItem('authToken');
if (token) {
// Walidacja tokenu na serwerze lub dekodowanie JWT
const userData = await validateToken(token); // funkcja implementowana oddzielnie
setUser(userData);
}
} catch (error) {
console.error('Błąd uwierzytelniania:', error);
// W przypadku błędu, wylogowujemy użytkownika
localStorage.removeItem('authToken');
setUser(null);
} finally {
setIsLoading(false);
}
};
checkAuthStatus();
}, []);
// Funkcje logowania i wylogowywania
const login = async (credentials) => {
setIsLoading(true);
try {
// Wywołanie API logowania
const response = await apiLogin(credentials);
const { token, user: userData } = response;
// Zapisanie tokenu
localStorage.setItem('authToken', token);
setUser(userData);
return true;
} catch (error) {
console.error('Błąd logowania:', error);
return false;
} finally {
setIsLoading(false);
}
};
const logout = () => {
localStorage.removeItem('authToken');
setUser(null);
};
return (
<AuthContext.Provider value={{ user, isLoading, login, logout }}>
{children}
</AuthContext.Provider>
);
}
// Hook do łatwego dostępu do kontekstu uwierzytelniania
export function useAuth() {
return useContext(AuthContext);
}Przekierowanie po logowaniu
Na stronie logowania możemy wykorzystać informacje o poprzedniej ścieżce, aby przekierować użytkownika z powrotem po zalogowaniu:
import { useLocation, useNavigate } from 'react-router-dom';
import { useAuth } from './AuthContext';
import { useState } from 'react';
function LoginPage() {
const { login } = useAuth();
const navigate = useNavigate();
const location = useLocation();
// Pobieramy ścieżkę, z której użytkownik został przekierowany (jeśli istnieje)
const from = location.state?.from || '/command-center';
const [credentials, setCredentials] = useState({
username: '',
password: ''
});
const handleChange = (e) => {
const { name, value } = e.target;
setCredentials(prev => ({
...prev,
[name]: value
}));
};
const handleSubmit = async (e) => {
e.preventDefault();
const success = await login(credentials);
if (success) {
// Przekierowanie z powrotem do chronionej ścieżki
navigate(from, { replace: true });
}
};
return (
<div className="login-container">
<h1>Centrum Dostępu Kosmicznej Stacji</h1>
<form onSubmit={handleSubmit}>
<div className="form-group">
<label htmlFor="username">ID Astronauty:</label>
<input
id="username"
name="username"
type="text"
value={credentials.username}
onChange={handleChange}
required
/>
</div>
<div className="form-group">
<label htmlFor="password">Kod Dostępu:</label>
<input
id="password"
name="password"
type="password"
value={credentials.password}
onChange={handleChange}
required
/>
</div>
<button type="submit" className="login-button">
Uzyskaj Dostęp
</button>
</form>
</div>
);
}Zabezpieczanie ścieżek na podstawie ról
Często potrzebujemy bardziej skomplikowanej logiki niż tylko sprawdzenie, czy użytkownik jest zalogowany. Na przykład, może być konieczne sprawdzenie, czy użytkownik ma odpowiednią rolę:
function RoleProtectedRoute({ children, requiredRoles = [] }) {
const { user, isLoading } = useAuth();
const location = useLocation();
if (isLoading) {
return <div className="loading">Sprawdzanie uprawnień...</div>;
}
// Sprawdź, czy użytkownik jest zalogowany
if (!user) {
return <Navigate to="/login" state={{ from: location.pathname }} replace />;
}
// Sprawdź, czy użytkownik ma wymaganą rolę
const hasRequiredRole = requiredRoles.length === 0 ||
requiredRoles.some(role => user.roles.includes(role));
if (!hasRequiredRole) {
return <Navigate to="/unauthorized" replace />;
}
return children;
}
// Użycie:
<Route
path="/engine-room"
element={
<RoleProtectedRoute requiredRoles={['engineer', 'captain']}>
<EngineRoom />
</RoleProtectedRoute>
}
/>Organizacja chronionej sekcji aplikacji
Dobrą praktyką jest zgrupowanie wszystkich chronionych tras w jednym miejscu, co ułatwia zarządzanie nimi:
function AppRoutes() {
return (
<Routes>
{/* Publiczne ścieżki */}
<Route path="/" element={<HomePage />} />
<Route path="/login" element={<LoginPage />} />
<Route path="/register" element={<RegisterPage />} />
<Route path="/about" element={<AboutPage />} />
{/* Chroniona sekcja */}
<Route path="/dashboard" element={<ProtectedRoute><DashboardLayout /></ProtectedRoute>}>
<Route index element={<Overview />} />
<Route path="profile" element={<Profile />} />
<Route path="settings" element={<Settings />} />
{/* Trasy dla inżynierów */}
<Route path="maintenance" element={
<RoleProtectedRoute requiredRoles={['engineer']}>
<MaintenancePanel />
</RoleProtectedRoute>
} />
{/* Trasy dla kapitanów */}
<Route path="command" element={
<RoleProtectedRoute requiredRoles={['captain']}>
<CommandCenter />
</RoleProtectedRoute>
} />
</Route>
{/* Obsługa błędów */}
<Route path="/unauthorized" element={<UnauthorizedPage />} />
<Route path="*" element={<NotFoundPage />} />
</Routes>
);
}W powyższym przykładzie używamy zagnieżdżonych tras, gdzie główny komponent DashboardLayout jest chroniony, a wszystkie zagnieżdżone w nim trasy są automatycznie chronione. Dodatkowo, niektóre trasy mają dodatkowe zabezpieczenia oparte na rolach.
Zaawansowane techniki
Lazy Loading dla chronionych tras
Możemy połączyć ochronę tras z leniowym ładowaniem, aby poprawić wydajność aplikacji:
import { lazy, Suspense } from 'react';
// Leniwe ładowanie komponentów
const CommandCenter = lazy(() => import('./CommandCenter'));
const MaintenancePanel = lazy(() => import('./MaintenancePanel'));
// W routingu:
<Route path="command" element={
<RoleProtectedRoute requiredRoles={['captain']}>
<Suspense fallback={<Loading />}>
<CommandCenter />
</Suspense>
</RoleProtectedRoute>
} />Zapamiętywanie wielu tras
Czasami użytkownik może próbować uzyskać dostęp do wielu chronionych tras przed zalogowaniem. Możemy zapamiętać więcej niż jedną trasę:
function useRedirectHistory() {
const [history, setHistory] = useState([]);
const addToHistory = (path) => {
setHistory(prev => {
// Unikaj duplikatów
if (!prev.includes(path)) {
return [...prev, path].slice(-5); // Zachowaj tylko 5 ostatnich ścieżek
}
return prev;
});
};
const getLastPath = () => history[history.length - 1] || '/dashboard';
return { addToHistory, getLastPath };
}Obsługa wygaśnięcia sesji
Ważnym aspektem zabezpieczania ścieżek jest obsługa wygaśnięcia sesji:
function useSessionExpiration() {
const { logout } = useAuth();
const navigate = useNavigate();
useEffect(() => {
// Obsługa wygaśnięcia tokena JWT
const checkTokenExpiration = () => {
const token = localStorage.getItem('authToken');
if (token) {
try {
const payload = JSON.parse(atob(token.split('.')[1]));
const expirationTime = payload.exp * 1000; // Konwersja na milisekundy
if (Date.now() >= expirationTime) {
logout();
navigate('/login', {
state: {
message: 'Twoja sesja wygasła. Proszę zalogować się ponownie.'
}
});
}
} catch (e) {
console.error('Błąd walidacji tokenu:', e);
logout();
}
}
};
const interval = setInterval(checkTokenExpiration, 60000); // Sprawdzaj co minutę
return () => clearInterval(interval);
}, [logout, navigate]);
}Podsumowanie
Zabezpieczanie ścieżek w React Router jest kluczowym aspektem tworzenia bezpiecznych aplikacji. Główne techniki obejmują:
- Tworzenie komponentów wyższego rzędu (HOC) do ochrony tras
- Wykorzystanie kontekstu React do zarządzania stanem uwierzytelniania
- Przekierowywanie użytkowników na stronę logowania z zapamiętaniem oryginalnej ścieżki
- Implementacja kontroli dostępu na podstawie ról
- Organizacja struktury aplikacji z wyraźnym podziałem na publiczne i chronione sekcje
- Obsługa wygaśnięcia sesji i automatyczne wylogowanie
Pamiętaj, że zabezpieczenia po stronie klienta (w przeglądarce) nigdy nie powinny być jedyną warstwą ochrony. Zawsze powinny być uzupełnione o odpowiednie zabezpieczenia na serwerze, który powinien niezależnie weryfikować uprawnienia użytkownika przed udostępnieniem chronionych zasobów.
Kod do tej lekcji: App.jsx
import React, { useState, createContext, useContext } from 'react';
import { BrowserRouter, Routes, Route, Link, Navigate, useNavigate, useLocation } from 'react-router-dom';
// Kontekst autoryzacji
const AuthContext = createContext();
function AuthProvider({ children }) {
const [user, setUser] = useState(null);
const login = (username) => {
setUser({ name: username, role: 'astronaut' });
};
const logout = () => {
setUser(null);
};
return (
<AuthContext.Provider value={{ user, login, logout }}>
{children}
</AuthContext.Provider>
);
}
function useAuth() {
return useContext(AuthContext);
}
// Komponent Protected Route
function ProtectedRoute({ children }) {
const { user } = useAuth();
const location = useLocation();
if (!user) {
// Przekieruj do logowania z zapisaniem lokalizacji
return <Navigate to="/login" state={{ from: location }} replace />;
}
return children;
}
// Strona logowania
function LoginPage() {
const [username, setUsername] = useState('');
const { login } = useAuth();
const navigate = useNavigate();
const location = useLocation();
const from = location.state?.from?.pathname || '/dashboard';
const handleSubmit = (e) => {
e.preventDefault();
if (username.trim()) {
login(username);
navigate(from, { replace: true });
}
};
return (
<div className="page login">
<h1>Logowanie</h1>
<form onSubmit={handleSubmit}>
<input
value={username}
onChange={(e) => setUsername(e.target.value)}
placeholder="Nazwa użytkownika"
/>
<button type="submit">Zaloguj</button>
</form>
<p className="info">Zaloguj się, aby uzyskać dostęp do chronionych sekcji.</p>
</div>
);
}
// Strona publiczna
function HomePage() {
return (
<div className="page">
<h1>Strona publiczna</h1>
<p>Ta strona jest dostępna dla wszystkich.</p>
</div>
);
}
// Strona chroniona
function DashboardPage() {
const { user, logout } = useAuth();
const navigate = useNavigate();
const handleLogout = () => {
logout();
navigate('/');
};
return (
<div className="page dashboard">
<h1>Dashboard</h1>
<p>Witaj, {user?.name}! To jest strona chroniona.</p>
<button onClick={handleLogout} className="logout">Wyloguj</button>
</div>
);
}
// Strona sekretna
function SecretPage() {
return (
<div className="page secret">
<h1>Strona tajne</h1>
<p>Gratulacje! Masz dostęp do tajnych danych.</p>
</div>
);
}
// Nawigacja
function Navigation() {
const { user } = useAuth();
return (
<nav>
<Link to="/">Home</Link>
{user ? (
<>
<Link to="/dashboard">Dashboard</Link>
<Link to="/secret">Tajne</Link>
<span className="user-info">{user.name}</span>
</>
) : (
<Link to="/login">Zaloguj</Link>
)}
</nav>
);
}
function App() {
return (
<AuthProvider>
<BrowserRouter>
<div className="app">
<Navigation />
<Routes>
<Route path="/" element={<HomePage />} />
<Route path="/login" element={<LoginPage />} />
<Route
path="/dashboard"
element={
<ProtectedRoute>
<DashboardPage />
</ProtectedRoute>
}
/>
<Route
path="/secret"
element={
<ProtectedRoute>
<SecretPage />
</ProtectedRoute>
}
/>
</Routes>
</div>
</BrowserRouter>
</AuthProvider>
);
}
export default App;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. Jak NavLink w React Router pozwala dynamicznie ustawić klasę CSS na podstawie aktywnego stanu?
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż elementy składni komponentu Link:
- Klikanie w kolejności
Uporządkuj NavLink z dynamiczną klasą: