Kurs JavaScript i React · Moduł 6: React Router

Konfiguracja routingu w aplikacjach kosmicznych

7 min czytania ·
W tej lekcji8

W poprzednim module poznaliśmy podstawy React Router jako systemu nawigacji międzyplanetarnej. Teraz zagłębimy się w szczegóły konfiguracji routingu w różnych rodzajach aplikacji kosmicznych, zarówno tych małych jak i złożonych wielomodułowych systemach.

Różne typy routerów w React Router

React Router dostarcza kilka typów routerów, które możemy wykorzystać w zależności od środowiska, w którym działa nasza aplikacja:

1. BrowserRouter

BrowserRouter wykorzystuje HTML5 History API i jest najczęściej używanym routerem w nowoczesnych aplikacjach internetowych. Tworzy czyste, ładne URL-e bez hashtagu (#):

import { BrowserRouter } from 'react-router-dom';

function App() {
  return (
    <BrowserRouter>
      {/* Komponenty routingu */}
    </BrowserRouter>
  );
}

Ważne: BrowserRouter wymaga odpowiedniej konfiguracji serwera, który musi przekierowywać wszystkie żądania do pliku index.html (aby obsłużyć odświeżanie strony i bezpośrednie wejście na podstrony).

2. HashRouter

HashRouter używa funkcji hash w URL (część po #). Jest to prostsze rozwiązanie, które nie wymaga konfiguracji serwera, ale tworzy mniej eleganckie URL-e:

import { HashRouter } from 'react-router-dom';

function App() {
  return (
    <HashRouter>
      {/* Komponenty routingu */}
    </HashRouter>
  );
}

Przykładowe URL-e przy użyciu HashRouter: /#/mars, /#/jupiter

3. MemoryRouter

MemoryRouter przechowuje historię nawigacji w pamięci (nie używa URL przeglądarki). Jest przydatny do testów i aplikacji działających w środowiskach bez przeglądarki:

import { MemoryRouter } from 'react-router-dom';

function App() {
  return (
    <MemoryRouter initialEntries={['/mars', '/jupiter']} initialIndex={1}>
      {/* Komponenty routingu */}
    </MemoryRouter>
  );
}

Zaawansowana konfiguracja Route

Komponent Route oferuje więcej opcji niż tylko podstawowe mapowanie ścieżki do elementu:

1. Ścieżki dynamiczne z parametrami

<Route path="/planet/:planetId" element={<PlanetDetails />} />

Ta ścieżka pasuje do URL-i jak /planet/mars, /planet/jupiter, itd. Parametr :planetId jest dynamiczny i może być odczytany w komponencie.

2. Ścieżki opcjonalne

<Route path="/missions/:year?/:month?" element={<MissionsList />} />

Znaki zapytania oznaczają parametry opcjonalne. Ta ścieżka pasuje do URL-i:

  • /missions (bez parametrów)
  • /missions/2150 (tylko rok)
  • /missions/2150/06 (rok i miesiąc)

3. Parametry z gwiazdką (catch-all)

<Route path="/files/*" element={<FileExplorer />} />

Gwiazdka łapie wszystko po /files/, np. /files/documents/reports/annual.pdf.

Struktura routingu dla większych aplikacji kosmicznych

W obszernych aplikacjach kosmicznych, routing może stać się skomplikowany. Oto jak można go zorganizować:

1. Zagnieżdżone trasy

Możemy zagnieżdżać trasy, aby stworzyć hierarchiczną strukturę:

function AppRoutes() {
  return (
    <Routes>
      <Route path="/" element={<SpaceLayout />}>
        <Route index element={<Dashboard />} />
        <Route path="planets" element={<PlanetLayout />}>
          <Route index element={<PlanetsList />} />
          <Route path=":planetId" element={<PlanetDetails />} />
        </Route>
        <Route path="missions" element={<MissionLayout />}>
          <Route index element={<MissionsDashboard />} />
          <Route path="scheduled" element={<ScheduledMissions />} />
          <Route path="completed" element={<CompletedMissions />} />
        </Route>
      </Route>
      <Route path="/auth" element={<AuthLayout />}>
        <Route path="login" element={<Login />} />
        <Route path="register" element={<Register />} />
      </Route>
      <Route path="*" element={<NotFound />} />
    </Routes>
  );
}

W powyższym przykładzie:

  • SpaceLayout jest głównym layoutem dla ścieżek zaczynających się od "/"
  • PlanetLayout jest layoutem dla wszystkich ścieżek z sekcji "planets"
  • Element index określa, co ma być renderowane dla ścieżki nadrzędnej (np. "/planets")

2. Route element vs. component

Od React Router v6 używamy propsa element zamiast component z wcześniejszych wersji:

// React Router v6 i nowsze (v7, v8)
<Route path="/mars" element={<MarsBase />} />

// React Router v5 (starszy)
<Route path="/mars" component={MarsBase} />

Dlaczego to ważne? Syntax element pozwala na przekazanie wyrenderowanego elementu, co daje większą elastyczność:

<Route
  path="/mars"
  element={
    <MarsBase
      temperature={-60}
      oxygenLevel="low"
      waterAvailable={true}
    />
  }
/>

3. Outlet - wyświetlanie komponentów podścieżek

Komponent Outlet określa, gdzie w komponencie nadrzędnym mają być renderowane komponenty podścieżek:

import { Outlet } from 'react-router-dom';

function SpaceLayout() {
  return (
    <div className="space-layout">
      <header>
        <h1>Międzyplanetarny System Nawigacji</h1>
        <nav>{/* Linki nawigacyjne */}</nav>
      </header>

      <main>
        {/* Tutaj będą renderowane komponenty podścieżek */}
        <Outlet />
      </main>

      <footer>
        <p>Kosmiczne Centrum Dowodzenia &copy; 2150</p>
      </footer>
    </div>
  );
}

Konfiguracja z uwzględnieniem obsługi błędów

Dobrą praktyką jest dodanie globalnej obsługi błędów w naszym systemie routingu:

function AppRoutes() {
  return (
    <Routes>
      <Route path="/" element={<SpaceLayout />} errorElement={<GlobalError />}>
        {/* Inne trasy */}
      </Route>
    </Routes>
  );
}

function GlobalError() {
  const error = useRouteError();

  return (
    <div className="error-container">
      <h1>Houston, mamy problem!</h1>
      <p>Wystąpił błąd w systemie nawigacji:</p>
      <pre>{error.message || "Nieznany błąd"}</pre>
      <button onClick={() => window.location.href = "/"}>
        Powrót do Centrum Dowodzenia
      </button>
    </div>
  );
}

Pełny przykład konfiguracji dla złożonej aplikacji kosmicznej

Poniżej znajduje się kompleksowy przykład konfiguracji routingu dla zaawansowanej aplikacji:

import {
  BrowserRouter,
  Routes,
  Route,
  Outlet,
  Navigate,
  useRouteError
} from 'react-router-dom';

// Layouts
function MainLayout() {
  return (
    <div className="main-layout">
      <MainNavigation />
      <div className="content">
        <Outlet />
      </div>
      <Footer />
    </div>
  );
}

function AuthLayout() {
  return (
    <div className="auth-layout">
      <div className="auth-container">
        <Outlet />
      </div>
    </div>
  );
}

// Error Components
function GlobalError() {
  const error = useRouteError();
  return (
    <div className="error-screen">
      <h1>Błąd systemu nawigacji</h1>
      <p>{error.message || "Nieznany błąd"}</p>
    </div>
  );
}

function NotFound() {
  return (
    <div className="not-found">
      <h1>Zgubiony w przestrzeni kosmicznej</h1>
      <p>Statek nie odnalazł żądanej lokalizacji.</p>
    </div>
  );
}

// Protected Route Component
function ProtectedRoute({ children }) {
  const isAuthenticated = useAuth();

  if (!isAuthenticated) {
    return <Navigate to="/auth/login" replace />;
  }

  return children;
}

// Main App
function App() {
  return (
    <BrowserRouter>
      <Routes>
        {/* Główna sekcja z layoutem */}
        <Route path="/" element={<MainLayout />} errorElement={<GlobalError />}>
          <Route index element={<Dashboard />} />

          {/* Planety */}
          <Route path="planets">
            <Route index element={<PlanetsList />} />
            <Route path=":planetId" element={<PlanetDetails />} />
          </Route>

          {/* Misje - wymagają uwierzytelnienia */}
          <Route path="missions" element={
            <ProtectedRoute>
              <MissionsLayout />
            </ProtectedRoute>
          }>
            <Route index element={<MissionsDashboard />} />
            <Route path="new" element={<NewMission />} />
            <Route path=":missionId" element={<MissionDetails />} />
            <Route path=":missionId/edit" element={<EditMission />} />
          </Route>

          {/* Załoga */}
          <Route path="crew">
            <Route index element={<CrewList />} />
            <Route path=":memberId" element={<CrewMemberProfile />} />
          </Route>

          {/* Ustawienia - wymagają uwierzytelnienia */}
          <Route path="settings" element={
            <ProtectedRoute>
              <Settings />
            </ProtectedRoute>
          } />
        </Route>

        {/* Sekcja uwierzytelniania */}
        <Route path="/auth" element={<AuthLayout />}>
          <Route path="login" element={<Login />} />
          <Route path="register" element={<Register />} />
          <Route path="forgot-password" element={<ForgotPassword />} />
          <Route path="reset-password/:token" element={<ResetPassword />} />
        </Route>

        {/* Dokumentacja publiczna */}
        <Route path="/docs/*" element={<DocsLayout />} />

        {/* Przekierowanie ze starej ścieżki na nową */}
        <Route path="/old-missions" element={<Navigate to="/missions" replace />} />

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

Konfiguracja z React Router w środowisku developerskim

Podczas rozwijania aplikacji kosmicznej, warto skonfigurować narzędzia developerskie do pracy z React Router:

1. React Router DevTools

// Tylko w trybie deweloperskim
if (process.env.NODE_ENV === 'development') {
  const ReactRouterDevTools = React.lazy(() =>
    import('react-router-devtools').then(module => ({
      default: module.ReactRouterDevTools
    }))
  );

  // Użycie w aplikacji
  <React.Suspense fallback={null}>
    <ReactRouterDevTools />
  </React.Suspense>
}

2. Konfiguracja webpack-dev-server dla BrowserRouter

Aby obsługiwać odświeżanie stron w środowisku developerskim z BrowserRouter, należy skonfigurować webpack-dev-server:

// webpack.config.js
module.exports = {
  // inne ustawienia...
  devServer: {
    historyApiFallback: true, // Przekierowanie 404 do index.html
    // inne ustawienia...
  }
};

Konfiguracja serwera produkcyjnego dla React Router

W środowisku produkcyjnym, serwer musi być skonfigurowany do obsługi wszystkich ścieżek React Router:

1. Dla serwera Node.js/Express:

const express = require('express');
const path = require('path');
const app = express();

// Serwowanie statycznych plików
app.use(express.static(path.join(__dirname, 'build')));

// Wszystkie żądania, które nie są do statycznych plików, przekierowane do index.html
app.get('*', (req, res) => {
  res.sendFile(path.join(__dirname, 'build', 'index.html'));
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Serwer nasłuchuje na porcie ${PORT}`);
});

2. Dla serwera Apache (.htaccess):

<IfModule mod_rewrite.c>
  RewriteEngine On
  RewriteBase /
  RewriteRule ^index\.html$ - [L]
  RewriteCond %{REQUEST_FILENAME} !-f
  RewriteCond %{REQUEST_FILENAME} !-d
  RewriteRule . /index.html [L]
</IfModule>

3. Dla serwera Nginx:

server {
  listen 80;
  server_name kosmiczna-aplikacja.pl;

  root /var/www/html;
  index index.html;

  location / {
    try_files $uri $uri/ /index.html;
  }
}

Podsumowanie

Prawidłowa konfiguracja routingu jest kluczowa dla funkcjonowania aplikacji kosmicznej (React). Kluczowe punkty:

  1. Wybierz odpowiedni typ routera - zwykle BrowserRouter dla nowoczesnych aplikacji
  2. Twórz hierarchiczną strukturę tras - używaj zagnieżdżonych tras z Outlet dla lepszej organizacji
  3. Zaimplementuj obsługę błędów - używaj errorElement dla obsługi błędów
  4. Zabezpiecz prywatne trasy - stwórz komponent ProtectedRoute do ochrony dostępu
  5. Skonfiguruj serwer produkcyjny - upewnij się, że serwer przekierowuje wszystkie żądania do index.html

Z dobrze skonfigurowanym systemem nawigacji, użytkownicy twojej kosmicznej aplikacji będą mogli swobodnie podróżować między różnymi jej częściami, bez obaw o zagubienie się w przestrzeni kosmicznej (błędy 404).

Kod do tej lekcji: App.jsx
import React from 'react';
import { BrowserRouter, Routes, Route, Link } from 'react-router-dom';

// Strona główna
function Home() {
  return (
    <div className="page home">
      <h1>Strona główna</h1>
      <p>Witaj w kosmicznym centrum nawigacji!</p>
      <p>Użyj menu powyżej, aby nawigować między stronami.</p>
    </div>
  );
}

// Strona "O nas"
function About() {
  return (
    <div className="page about">
      <h1>O nas</h1>
      <p>Jesteśmy zespołem badaczy kosmosu.</p>
      <p>Nasza misja: eksploracja galaktyki przez React Router!</p>
    </div>
  );
}

// Strona kontaktowa
function Contact() {
  return (
    <div className="page contact">
      <h1>Kontakt</h1>
      <p>Email: mission-control@space.com</p>
      <p>Telefon: +48 123 456 789</p>
    </div>
  );
}

// Nawigacja
function Navigation() {
  return (
    <nav className="navigation">
      <Link to="/" className="nav-link">Home</Link>
      <Link to="/about" className="nav-link">O nas</Link>
      <Link to="/contact" className="nav-link">Kontakt</Link>
    </nav>
  );
}

function App() {
  return (
    <BrowserRouter>
      <div className="app">
        <header>
          <h2>Space Navigator</h2>
          <Navigation />
        </header>

        <main>
          <Routes>
            <Route path="/" element={<Home />} />
            <Route path="/about" element={<About />} />
            <Route path="/contact" element={<Contact />} />
          </Routes>
        </main>
      </div>
    </BrowserRouter>
  );
}

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. Jaka jest główna różnica między BrowserRouter a HashRouter?

Zadania praktyczne w grze

  • Klikanie w kolejności

    Ułóż komendę instalacji React Router:

  • Edytor kodu

    Stwórz: <BrowserRouter><Routes><Route path='/' element={<Dashboard />} /><Route path='/planets' element={<Planets />} /><Route path='/missions' element={<Missions />} /></Routes></BrowserRouter>. Dodaj <Link to='/planets'>Planety</Link>!

  • Klikanie w kolejności

    Uporządkuj podstawową strukturę aplikacji React Router:

  • Edytor kodu

    Stwórz nawigację: <nav><NavLink to='/' className={({isActive}) => isActive ? 'active' : ''}>Home</NavLink><NavLink to='/asteroids'>Asteroidy</NavLink></nav>. Dodaj CSS: .active { color: gold; border-bottom: 2px solid gold }

  1. Kliknij w kolejnościInstalacja i setup
  2. Zadanie z kodemPraktyka: Konfiguracja BrowserRouter
  3. PytanieBrowserRouter vs HashRouter
  4. Kliknij w kolejnościStruktura aplikacji kosmicznej
  5. Zadanie z kodemPraktyka: Konfiguracja tras

Przydatne artykuły