Kurs JavaScript i React · Moduł 6: React Router

Kompletna architektura routingu - Centrum Dowodzenia Nawigacją

5 min czytania ·
W tej lekcji9

Nawigatorze, dotarliśmy do ostatniego etapu naszej podróży przez Pas Asteroid! Czas zebrać wszystkie techniki nawigacyjne, które poznaliśmy, i zbudować kompletny system routingu - prawdziwe Centrum Dowodzenia Nawigacją dla naszej kosmicznej floty.

W tej lekcji zobaczymy, jak wszystkie elementy React Router współpracują ze sobą w jednej, spójnej aplikacji.

Architektura kompletnej aplikacji z routingiem

Budując aplikację z pełnym routingiem, musimy zaplanować kilka warstw:

  1. Warstwa uwierzytelniania - AuthContext + ProtectedRoute
  2. Warstwa nawigacji - NavLink z aktywnymi stylami
  3. Warstwa tras - zagnieżdżone Routes z Outlet
  4. Warstwa parametrów - dynamiczne ścieżki z useParams
  5. Warstwa przekierowań - obsługa 404 i zabezpieczeń

Struktura folderów

W większych aplikacjach warto zorganizować pliki związane z routingiem w logiczną strukturę:

src/
├── App.jsx              // Główny komponent z BrowserRouter
├── routes/
│   ├── AppRoutes.jsx    // Definicja wszystkich tras
│   └── ProtectedRoute.jsx
├── context/
│   └── AuthContext.jsx  // Kontekst uwierzytelniania
├── layouts/
│   ├── MainLayout.jsx   // Layout z nawigacją i Outlet
│   └── DashboardLayout.jsx
├── pages/
│   ├── HomePage.jsx
│   ├── LoginPage.jsx
│   ├── MissionDetail.jsx
│   └── NotFound.jsx
└── components/
    └── Navigation.jsx   // NavLink menu

Taka organizacja pozwala łatwo zarządzać nawet rozbudowanymi aplikacjami z dziesiątkami tras.

Łączenie AuthContext z routingiem

Centralnym elementem jest AuthProvider owijający całą aplikację:

function AuthProvider({ children }) {
  const [user, setUser] = useState(null);

  const login = (name) => setUser({ name });
  const logout = () => setUser(null);

  return (
    <AuthContext.Provider value={{ user, login, logout }}>
      {children}
    </AuthContext.Provider>
  );
}

// W App.jsx:
function App() {
  return (
    <AuthProvider>
      <BrowserRouter>
        <Navigation />
        <Routes>
          {/* trasy publiczne i chronione */}
        </Routes>
      </BrowserRouter>
    </AuthProvider>
  );
}

AuthProvider musi być na zewnątrz BrowserRouter, aby kontekst uwierzytelniania był dostępny we wszystkich komponentach tras.

Komponent nawigacji łączy NavLink (z aktywnymi stylami) z AuthContext (warunkowe wyświetlanie opcji):

function Navigation() {
  const { user, logout } = useAuth();

  return (
    <nav>
      <NavLink to="/" className={({isActive}) => isActive ? 'active' : ''}>
        Home
      </NavLink>
      <NavLink to="/missions" className={({isActive}) => isActive ? 'active' : ''}>
        Missions
      </NavLink>

      {user ? (
        <>
          <NavLink to="/dashboard" className={({isActive}) => isActive ? 'active' : ''}>
            Dashboard
          </NavLink>
          <span>Zalogowany: {user.name}</span>
          <button onClick={logout}>Wyloguj</button>
        </>
      ) : (
        <NavLink to="/login">Logowanie</NavLink>
      )}
    </nav>
  );
}

Dzięki temu nawigacja automatycznie reaguje na stan uwierzytelniania - zalogowany użytkownik widzi Dashboard i przycisk wylogowania, niezalogowany widzi link do logowania.

Zagnieżdżone trasy z layoutem

Sekcja misji wykorzystuje zagnieżdżone trasy z Outlet:

function MissionsLayout() {
  return (
    <div className="missions-layout">
      <aside>
        <h3>Misje</h3>
        <NavLink to="/missions/apollo">Apollo</NavLink>
        <NavLink to="/missions/artemis">Artemis</NavLink>
        <NavLink to="/missions/voyager">Voyager</NavLink>
      </aside>
      <main>
        <Outlet />
      </main>
    </div>
  );
}

// W konfiguracji tras:
<Route path="/missions" element={<MissionsLayout />}>
  <Route index element={<MissionsList />} />
  <Route path=":missionId" element={<MissionDetail />} />
</Route>

Index route (<Route index />) renderuje domyślną zawartość (listę misji), gdy użytkownik jest na /missions. Dynamiczny parametr :missionId obsługuje szczegóły konkretnej misji.

Kompletna konfiguracja tras

Oto jak wygląda pełna konfiguracja tras łącząca wszystkie poznane techniki:

function App() {
  return (
    <AuthProvider>
      <BrowserRouter>
        <Navigation />
        <Routes>
          {/* Strona główna */}
          <Route path="/" element={<HomePage />} />

          {/* Logowanie */}
          <Route path="/login" element={<LoginPage />} />

          {/* Zagnieżdżone trasy z layoutem */}
          <Route path="/missions" element={<MissionsLayout />}>
            <Route index element={<MissionsList />} />
            <Route path=":missionId" element={<MissionDetail />} />
          </Route>

          {/* Chroniona trasa */}
          <Route path="/dashboard" element={
            <ProtectedRoute>
              <DashboardPage />
            </ProtectedRoute>
          } />

          {/* Obsługa 404 */}
          <Route path="*" element={<NotFound />} />
        </Routes>
      </BrowserRouter>
    </AuthProvider>
  );
}

Kolejność elementów ma znaczenie:

  • Konkretne ścieżki (/, /login, /missions) są dopasowywane jako pierwsze
  • Trasa path="*" musi być ostatnia - przechwytuje wszystko, co nie pasuje do żadnej zdefiniowanej trasy

Logowanie z zapamiętaniem ścieżki

Strona logowania wykorzystuje useNavigate i useLocation do przekierowania użytkownika z powrotem na stronę, z której został przekierowany:

function LoginPage() {
  const [name, setName] = useState('');
  const { login } = useAuth();
  const navigate = useNavigate();
  const location = useLocation();

  // Ścieżka, z której użytkownik został przekierowany
  const from = location.state?.from?.pathname || '/dashboard';

  const handleSubmit = (e) => {
    e.preventDefault();
    if (name.trim()) {
      login(name);
      navigate(from, { replace: true }); // replace: true usuwa /login z historii
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <input value={name} onChange={(e) => setName(e.target.value)} />
      <button type="submit">Zaloguj</button>
    </form>
  );
}

Opcja replace: true w navigate jest kluczowa - dzięki niej użytkownik po zalogowaniu nie wróci na stronę logowania po kliknięciu "Wstecz" w przeglądarce.

Obsługa strony 404

Strona Not Found zawiera link powrotny do strony głównej:

function NotFound() {
  return (
    <div className="not-found">
      <h1>404</h1>
      <p>Strona nie została odnaleziona</p>
      <Link to="/">Wróć na stronę główną</Link>
    </div>
  );
}

Podsumowanie architektury

Kompletna aplikacja z routingiem w React łączy następujące elementy:

ElementRolaHook / Komponent
Kontener trasWłącza routingBrowserRouter
Definicja trasMapuje URL na komponentyRoutes, Route
NawigacjaLinki z aktywnymi stylamiNavLink
ZagnieżdżanieWspółdzielony layoutOutlet, Route children
Parametry dynamiczneSzczegóły elementówuseParams
Nawigacja programowaPrzekierowanie po akcjiuseNavigate
Stan lokalizacjiPrzekazywanie ukrytych danychuseLocation
Ochrona trasWymuszanie logowaniaProtectedRoute + Navigate
Obsługa błędówStrony nieistniejąceRoute path="*"
Kontekst authGlobalne dane użytkownikacreateContext + useContext

Wypróbuj kompletną aplikację w edytorze poniżej - zaloguj się, przejdź między misjami, sprawdź Dashboard i przetestuj stronę 404!

Kod do tej lekcji: App.jsx
import React, { useState, createContext, useContext, Suspense, lazy } from 'react';
import {
  BrowserRouter, Routes, Route, Link, NavLink,
  useParams, useNavigate, useLocation, Navigate, Outlet
} from 'react-router-dom';

// Auth Context
const AuthContext = createContext();
function useAuth() { return useContext(AuthContext); }

function AuthProvider({ children }) {
  const [user, setUser] = useState(null);
  const login = (name) => setUser({ name });
  const logout = () => setUser(null);
  return (
    <AuthContext.Provider value={{ user, login, logout }}>
      {children}
    </AuthContext.Provider>
  );
}

// Protected Route
function ProtectedRoute({ children }) {
  const { user } = useAuth();
  const location = useLocation();
  if (!user) return <Navigate to="/login" state={{ from: location }} replace />;
  return children;
}

// Components
function Navigation() {
  const { user, logout } = useAuth();
  return (
    <nav>
      <div className="nav-brand">SpaceApp</div>
      <div className="nav-links">
        <NavLink to="/" className={({isActive}) => isActive ? 'active' : ''}>Home</NavLink>
        <NavLink to="/missions" className={({isActive}) => isActive ? 'active' : ''}>Missions</NavLink>
        {user ? (
          <>
            <NavLink to="/dashboard" className={({isActive}) => isActive ? 'active' : ''}>Dashboard</NavLink>
            <span className="user-badge">{user.name}</span>
            <button onClick={logout}>Logout</button>
          </>
        ) : (
          <NavLink to="/login" className={({isActive}) => isActive ? 'active' : ''}>Login</NavLink>
        )}
      </div>
    </nav>
  );
}

function HomePage() {
  return (
    <div className="page home">
      <h1>Welcome to SpaceApp</h1>
      <p>Your gateway to space exploration</p>
      <div className="features">
        <div className="feature">Track Missions</div>
        <div className="feature">View Analytics</div>
        <div className="feature">Manage Crew</div>
      </div>
    </div>
  );
}

function LoginPage() {
  const [name, setName] = useState('');
  const { login } = useAuth();
  const navigate = useNavigate();
  const location = useLocation();
  const from = location.state?.from?.pathname || '/dashboard';

  const handleSubmit = (e) => {
    e.preventDefault();
    if (name.trim()) {
      login(name);
      navigate(from, { replace: true });
    }
  };

  return (
    <div className="page login">
      <h1>Login</h1>
      <form onSubmit={handleSubmit}>
        <input value={name} onChange={(e) => setName(e.target.value)} placeholder="Username" />
        <button type="submit">Login</button>
      </form>
    </div>
  );
}

function MissionsLayout() {
  return (
    <div className="missions-layout">
      <aside>
        <h3>Missions</h3>
        <NavLink to="/missions/apollo">Apollo</NavLink>
        <NavLink to="/missions/artemis">Artemis</NavLink>
        <NavLink to="/missions/voyager">Voyager</NavLink>
      </aside>
      <main><Outlet /></main>
    </div>
  );
}

function MissionsList() {
  return <div className="content"><h2>Select a mission</h2></div>;
}

function MissionDetail() {
  const { missionId } = useParams();
  return (
    <div className="content">
      <h2>Mission: {missionId?.toUpperCase()}</h2>
      <p>Details for {missionId} mission</p>
    </div>
  );
}

function DashboardPage() {
  const { user } = useAuth();
  return (
    <div className="page dashboard">
      <h1>Dashboard</h1>
      <p>Welcome back, {user?.name}!</p>
      <div className="stats">
        <div className="stat"><span>Missions</span>12</div>
        <div className="stat"><span>Crew</span>48</div>
        <div className="stat"><span>Ships</span>8</div>
      </div>
    </div>
  );
}

function NotFound() {
  return (
    <div className="page not-found">
      <h1>404</h1>
      <p>Page not found</p>
      <Link to="/">Go Home</Link>
    </div>
  );
}

function App() {
  return (
    <AuthProvider>
      <BrowserRouter>
        <div className="app">
          <Navigation />
          <Routes>
            <Route path="/" element={<HomePage />} />
            <Route path="/login" element={<LoginPage />} />
            <Route path="/missions" element={<MissionsLayout />}>
              <Route index element={<MissionsList />} />
              <Route path=":missionId" element={<MissionDetail />} />
            </Route>
            <Route path="/dashboard" element={
              <ProtectedRoute><DashboardPage /></ProtectedRoute>
            } />
            <Route path="*" element={<NotFound />} />
          </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. 1. Jak zaimplementować Protected Route w React Router?

  2. 2. Gdzie w komponencie nadrzędnym umieszczamy <Outlet />, aby renderować zagnieżdżone trasy?

To 2 z 7 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Zaimplementuj obsługę błędów 404 z Route path='*' i komponentem NotFound. Dodaj nawigację z linkami do istniejących i nieistniejących stron, aby przetestować obsługę błędów.

  • Klikanie w kolejności

    Uporządkuj programową nawigację z state:

  • Układanie w pionie

    Uporządkuj kroki programatycznej nawigacji za pomocą useNavigate:

  • Układanie w pionie

    Uporządkuj kroki przekazywania i odczytywania danych między trasami:

  • Układanie w pionie

    Uporządkuj kroki implementacji Protected Route z komponentem Navigate:

  • Klikanie w kolejności

    Uporządkuj zarządzanie search params:

  • Układanie w pionie

    Uporządkuj kroki nawigacji w React Router od kliknięcia linku do wyświetlenia strony:

  • Układanie w pionie

    Uporządkuj kroki obsługi nieautoryzowanego dostępu do chronionej trasy:

  • Układanie w poziomie

    Ułóż elementy trasy obsługującej stronę 404:

  • Układanie w poziomie

    Ułóż składnię Route z dynamicznym parametrem id:

  • Edytor kodu

    Zbuduj kompleksowy Navigation System zawierający: React Router setup z BrowserRouter, nested routes dla struktury /fleet/:id/missions/:missionId, dynamic routing z params, Link i NavLink components z active styles, useNavigate dla programmatic navigation, useParams i useLocation hooks, protected routes z authentication, lazy loading z React.lazy i Suspense, search params z useSearchParams, oraz 404 error handling. Stwórz system nawigacyjny godny najbardziej zaawansowanej floty przemierzającej Pas Asteroid!

  1. PytanieProtected Routes
  2. Zadanie z kodemPraktyka: Routing - ćwiczenie
  3. Kliknij w kolejnościProgramowa nawigacja
  4. Ułóż w kolejnościProgramatyczna nawigacja w React Router
  5. Ułóż w kolejnościPrzekazywanie danych przez location state
  6. PytanieKomponent Outlet w zagnieżdżonych trasach
  7. PytanieObsługa błędów w routingu
  8. Ułóż w kolejnościKomponent Navigate do przekierowań
  9. Kliknij w kolejnościZarządzanie parametrami wyszukiwania
  10. Ułóż w kolejnościProces nawigacji w React Router
  11. Ułóż w kolejnościPrzepływ autoryzacji w ProtectedRoute
  12. Ułóż w kolejnościObsługa strony 404 w React Router
  13. PytanieTestowanie komponentów z routingiem
  14. PytaniePrzekazywanie state przez nawigację
  15. Ułóż w kolejnościDefinicja trasy z parametrem
  16. PytanieIndex Route w React Router
  17. PytanieLazy loading tras w React Router
  18. Zadanie z kodemProjekt: System nawigacji
  19. Projekt do wysłaniaProjekt do mentora: Centrum Nawigacji Galaktycznej
  20. WideoVideo: Podsumowanie modułu

Przydatne artykuły