Kurs Next.js · Moduł 1: Konfiguracja Next.js

Renderowanie w Next.js - przegląd strategii

6 min czytania ·
W tej lekcji8

W Metropolii Quantum informacje docierają do mieszkańców na różne sposoby - holograficzne ekrany na ulicach wyświetlają treści w czasie rzeczywistym, tablice informacyjne generują zawartość z wyprzedzeniem, a osobiste terminale pobierają dane na żądanie. Podobnie, Next.js oferuje kilka strategii renderowania stron, z których każda ma swoje zastosowanie.

W tym rozdziale poznasz cztery główne strategie renderowania w Next.js. Nie będziemy wchodzić w głębokie szczegóły techniczne - to temat na moduł 5. Na razie chcemy, żebyś rozumiał, że te strategie istnieją i wiedział, kiedy każda z nich ma sens.

Czym jest renderowanie?

Renderowanie to proces zamiany kodu React (JSX) na HTML, który przeglądarka może wyświetlić użytkownikowi. Kluczowe pytanie brzmi: gdzie i kiedy ten proces się odbywa?

// Ten komponent React...
export default function Hello() {
  return <h1>Witaj w Metropolii Quantum!</h1>;
}

// ...zostaje zamieniony na HTML:
// <h1>Witaj w Metropolii Quantum!</h1>

W zależności od wybranej strategii ta zamiana może nastąpić:

  • Na serwerze - zanim strona dotrze do przeglądarki
  • W przeglądarce - po pobraniu kodu JavaScript
  • Podczas budowania - jeszcze przed uruchomieniem serwera

SSR - Server-Side Rendering (renderowanie po stronie serwera)

Wyobraź sobie, że w Metropolii Quantum holograficzny ekran generuje obraz w centrum sterowania i przesyła gotowy hologram do wyświetlenia. Użytkownik widzi kompletny obraz natychmiast po otwarciu transmisji.

SSR oznacza, że serwer renderuje stronę HTML przy każdym żądaniu użytkownika. Gdy ktoś wchodzi na stronę, serwer:

  1. Pobiera potrzebne dane (z bazy danych, API)
  2. Generuje kompletny HTML
  3. Wysyła gotową stronę do przeglądarki
// Server Component w Next.js - domyślnie renderowany na serwerze
export default async function DashboardPage() {
  // Dane pobierane przy KAŻDYM żądaniu
  const stats = await fetch('https://api.quantum.com/stats', { cache: 'no-store' });
  const data = await stats.json();

  return (
    <div>
      <h1>Panel Quantum</h1>
      <p>Aktywni użytkownicy: {data.activeUsers}</p>
      <p>Ostatnia aktualizacja: {data.timestamp}</p>
    </div>
  );
}

Opcja cache: 'no-store' jest tu konieczna: bez niej (i bez API zależnych od żądania, takich jak cookies()) Next.js wyrenderuje stronę raz, podczas next build.

Kiedy używać SSR?

  • Gdy dane zmieniają się często (np. panel użytkownika, koszyk zakupów)
  • Gdy treść musi być aktualna przy każdym odświeżeniu
  • Gdy potrzebujesz SEO dla dynamicznych treści

SSG - Static Site Generation (generowanie statycznych stron)

W Metropolii Quantum tablice informacyjne z rozkładem jazdy są drukowane raz dziennie i wywieszane na przystankach. Nie zmieniają się co sekundę - są przygotowane z wyprzedzeniem.

SSG oznacza, że strony HTML są generowane podczas budowania aplikacji (next build), a nie przy każdym żądaniu. Gotowe strony są serwowane natychmiast z CDN.

// Strona generowana statycznie podczas build
export default function AboutPage() {
  return (
    <div>
      <h1>O Metropolii Quantum</h1>
      <p>Założona w 2150 roku jako centrum technologii przyszłości.</p>
      <p>Populacja: 12 milionów mieszkańców.</p>
    </div>
  );
}
// Ta strona nie wymaga danych dynamicznych
// Next.js wygeneruje ją raz podczas 'next build'

Kiedy używać SSG?

  • Blog, dokumentacja, strona "O nas"
  • Treści, które rzadko się zmieniają
  • Gdy priorytetem jest maksymalna szybkość ładowania

CSR - Client-Side Rendering (renderowanie po stronie klienta)

Osobiste terminale mieszkańców Metropolii Quantum pobierają surowe dane i renderują interfejs lokalnie - każdy terminal sam tworzy obraz na swoim ekranie.

CSR oznacza, że dane (a w klasycznej aplikacji SPA cały interfejs) są pobierane i renderowane w przeglądarce. W Next.js nawet komponent z "use client" jest przy pierwszym wejściu prerenderowany na serwerze do HTML, a potem hydratowany: w przykładzie niżej serwer wyśle nagłówek czatu, a wiadomości pobierze już przeglądarka.

"use client";

import { useState, useEffect } from 'react';

export default function LiveChat() {
  const [messages, setMessages] = useState([]);

  useEffect(() => {
    // Dane pobierane w przeglądarce po załadowaniu komponentu
    fetch('/api/messages')
      .then(res => res.json())
      .then(data => setMessages(data));
  }, []);

  return (
    <div>
      <h2>Quantum Chat</h2>
      {messages.map(msg => (
        <p key={msg.id}>{msg.text}</p>
      ))}
    </div>
  );
}

Kiedy używać CSR?

  • Interaktywne elementy (czat, formularze, dashboardy real-time)
  • Gdy SEO nie jest potrzebne dla danej sekcji
  • Gdy komponent wymaga dostępu do API przeglądarki (localStorage, geolokalizacja)

ISR - Incremental Static Regeneration (przyrostowa regeneracja statyczna)

W Metropolii Quantum tablice informacyjne mają tryb automatycznej aktualizacji - są statyczne, ale co określony czas (np. co godzinę) system sprawdza, czy nie ma nowych danych i generuje zaktualizowaną wersję.

ISR łączy zalety SSG (szybkość) z SSR (aktualność). Strona jest generowana statycznie, a gdy minie określony czas, pierwsze żądanie uruchamia w tle jej regenerację (samo dostaje jeszcze poprzednią wersję).

// Strona z ISR - statyczna, regenerowana w tle najwyżej raz na 60 sekund
export default async function ProductsPage() {
  const res = await fetch('https://api.quantum.com/products', {
    next: { revalidate: 60 } // Regeneracja w tle najwyżej raz na 60 sekund
  });
  const products = await res.json();

  return (
    <div>
      <h1>Produkty Quantum Store</h1>
      {products.map(p => (
        <div key={p.id}>
          <h3>{p.name}</h3>
          <p>{p.price} kredytów</p>
        </div>
      ))}
    </div>
  );
}

Kiedy używać ISR?

  • Sklep internetowy (produkty zmieniają się, ale nie co sekundę)
  • Strona z artykułami/newsami
  • Gdy chcesz szybkość SSG, ale z aktualizacjami

Prosty schemat decyzyjny - którą strategię wybrać?

Oto prosty schemat decyzyjny, który pomoże ci wybrać odpowiednią strategię:

Czy treść zmienia się przy każdym żądaniu?
  TAK → Czy potrzebujesz SEO?
          TAK → SSR (renderowanie na serwerze)
          NIE → CSR (renderowanie w przeglądarce)
  NIE → Czy treść zmienia się co jakiś czas?
          TAK → ISR (statyczna z regeneracją)
          NIE → SSG (w pełni statyczna)
StrategiaSzybkośćAktualność danychSEOPrzykład użycia
SSGNajszybszaDane z momentu budowaniaTakBlog, dokumentacja
ISRBardzo szybkaOdświeżane najwyżej co X sekundTakSklep, newsy
SSRSzybkaZawsze aktualneTakDashboard, profil
CSRZależy od klientaPobierane na żywoNieCzat, formularze

Co dalej?

W module 5 tego kursu zagłębimy się w szczegóły techniczne każdej strategii renderowania. Nauczysz się:

  • Jak dokładnie konfigurować SSR i ISR w App Routerze
  • Jak optymalizować wydajność renderowania
  • Jak łączyć różne strategie w jednej aplikacji
  • Zaawansowane wzorce z React Server Components

Na razie najważniejsze jest, żebyś zapamiętał, że Next.js daje ci wybór - nie musisz renderować wszystkiego w jeden sposób. Każda strona, a nawet każdy komponent, może używać innej strategii.

Podsumowanie

Metropolia Quantum pokazuje nam, że różne systemy dostarczania informacji mają różne zastosowania. Podobnie w Next.js:

  1. SSR - serwer renderuje stronę przy każdym żądaniu (dane zawsze aktualne)
  2. SSG - strona generowana raz podczas budowania (najszybsza)
  3. CSR - przeglądarka renderuje stronę po pobraniu JS (interaktywność)
  4. ISR - statyczna strona z automatyczną regeneracją (kompromis szybkości i aktualności)

Zrozumienie tych strategii to fundament pracy z Next.js. W kolejnych modułach będziesz je stosować w praktyce, budując coraz bardziej zaawansowane aplikacje w Metropolii Quantum.

Kod do tej lekcji: App.tsx
import React, { useState } from 'react';

// Interaktywny przegląd strategii renderowania Next.js
const RenderingOverview = () => {
  const [selected, setSelected] = useState<string | null>(null);

  const strategies = [
    {
      id: 'ssr',
      name: 'SSR',
      fullName: 'Server-Side Rendering',
      icon: '',
      color: '#7c4dff',
      speed: 'Szybka',
      freshness: 'Zawsze aktualne',
      seo: true,
      description: 'Serwer renderuje stronę przy KAŻDYM żądaniu. Dane są zawsze świeże.',
      useCase: 'Dashboard, profil użytkownika, koszyk zakupów',
      code: 'export default async function Page() {\n  const data = await fetch(url);\n  return <div>{data.title}</div>;\n}',
    },
    {
      id: 'ssg',
      name: 'SSG',
      fullName: 'Static Site Generation',
      icon: '',
      color: '#4caf50',
      speed: 'Najszybsza',
      freshness: 'Z momentu budowania',
      seo: true,
      description: 'Strony generowane RAZ podczas budowania. Serwowane z CDN.',
      useCase: 'Blog, dokumentacja, strona O nas',
      code: 'export default function About() {\n  return <div>Statyczna treść</div>;\n}',
    },
    {
      id: 'csr',
      name: 'CSR',
      fullName: 'Client-Side Rendering',
      icon: '',
      color: '#ff9800',
      speed: 'Zależy od klienta',
      freshness: 'Pobierane na żywo',
      seo: false,
      description: 'Przeglądarka pobiera JS i sama renderuje stronę.',
      useCase: 'Czat, formularze, interaktywne dashboardy',
      code: '"use client";\nimport { useState } from "react";\n// Renderowanie w przeglądarce',
    },
    {
      id: 'isr',
      name: 'ISR',
      fullName: 'Incremental Static Regeneration',
      icon: '',
      color: '#e91e63',
      speed: 'Bardzo szybka',
      freshness: 'Co X sekund',
      seo: true,
      description: 'Statyczna strona z automatyczną regeneracją co określony czas.',
      useCase: 'Sklep, artykuły, newsy',
      code: 'const res = await fetch(url, {\n  next: { revalidate: 60 }\n});',
    },
  ];

  const active = strategies.find(s => s.id === selected);

  return (
    <div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#fff', fontFamily: 'sans-serif' }}>
      <h1 style={{ color: '#64ffda', textAlign: 'center', marginBottom: '8px' }}>
        Strategie Renderowania Next.js
      </h1>
      <p style={{ textAlign: 'center', color: '#888', marginBottom: '24px' }}>
        Kliknij strategię, aby poznać szczegóły
      </p>

      <div style={{ display: 'grid', gridTemplateColumns: 'repeat(4, 1fr)', gap: '12px', maxWidth: '800px', margin: '0 auto 24px' }}>
        {strategies.map(s => (
          <button key={s.id} onClick={() => setSelected(s.id)}
            style={{ padding: '16px', background: selected === s.id ? s.color : 'rgba(255,255,255,0.05)',
              border: selected === s.id ? 'none' : '1px solid #333', borderRadius: '10px',
              color: '#fff', cursor: 'pointer', textAlign: 'center', transition: 'all 0.2s' }}>
            <div style={{ fontSize: '2rem' }}>{s.icon}</div>
            <div style={{ fontWeight: 'bold', marginTop: '4px' }}>{s.name}</div>
            <div style={{ fontSize: '0.7rem', color: selected === s.id ? '#fff' : '#888' }}>{s.fullName}</div>
          </button>
        ))}
      </div>

      {active && (
        <div style={{ maxWidth: '800px', margin: '0 auto', background: 'rgba(255,255,255,0.05)',
          borderRadius: '12px', padding: '24px', border: '1px solid ' + active.color }}>
          <h2 style={{ color: active.color, marginBottom: '12px' }}>{active.icon} {active.fullName}</h2>
          <p style={{ color: '#b0bec5', marginBottom: '16px' }}>{active.description}</p>

          <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr 1fr', gap: '12px', marginBottom: '16px' }}>
            <div style={{ background: 'rgba(0,0,0,0.3)', padding: '12px', borderRadius: '8px', textAlign: 'center' }}>
              <div style={{ color: '#888', fontSize: '0.8rem' }}>Szybkość</div>
              <div style={{ color: '#64ffda', fontWeight: 'bold' }}>{active.speed}</div>
            </div>
            <div style={{ background: 'rgba(0,0,0,0.3)', padding: '12px', borderRadius: '8px', textAlign: 'center' }}>
              <div style={{ color: '#888', fontSize: '0.8rem' }}>Aktualność</div>
              <div style={{ color: '#64ffda', fontWeight: 'bold' }}>{active.freshness}</div>
            </div>
            <div style={{ background: 'rgba(0,0,0,0.3)', padding: '12px', borderRadius: '8px', textAlign: 'center' }}>
              <div style={{ color: '#888', fontSize: '0.8rem' }}>SEO</div>
              <div style={{ color: active.seo ? '#4caf50' : '#f44336', fontWeight: 'bold' }}>{active.seo ? 'Tak' : 'Nie'}</div>
            </div>
          </div>

          <div style={{ background: '#0d1117', padding: '12px', borderRadius: '8px', marginBottom: '12px' }}>
            <pre style={{ color: '#64ffda', margin: 0, fontSize: '13px', whiteSpace: 'pre-wrap' }}>{active.code}</pre>
          </div>

          <p style={{ color: '#888', fontSize: '0.9rem' }}>
            <strong style={{ color: '#7c4dff' }}>Użyj gdy:</strong> {active.useCase}
          </p>
        </div>
      )}

      {!active && (
        <div style={{ textAlign: 'center', color: '#555', paddingTop: '40px' }}>
          Wybierz strategię renderowania powyżej
        </div>
      )}
    </div>
  );
};

export default RenderingOverview;

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. Która strategia renderowania generuje strony HTML podczas budowania aplikacji (next build)?

  2. 2. Czym charakteryzuje się ISR (Incremental Static Regeneration) w Next.js?

  3. 3. Jak definiuje się zmienne środowiskowe dostępne po stronie klienta w Next.js?

  4. 4. Co oznacza dyrektywa 'use client' na początku pliku w Next.js?

  5. 5. Które narzędzie NIE jest częścią typowego środowiska deweloperskiego Next.js?

  6. 6. Który katalog w Next.js (App Router) zawiera definicje stron i ścieżek?

  7. 7. Która cecha Next.js automatycznie dzieli kod JavaScript na mniejsze paczki ładowane na żądanie?

Zadania praktyczne w grze

  • Klikanie w kolejności

    Ułóż prawidłową ścieżkę do pliku layoutu w App Routerze

  • Układanie w pionie

    Ułóż kolejność cyklu życia komponentów w App Routerze

  • Układanie w pionie

    Ułóż składnię użycia komponentu Image z Next.js

  • Układanie w pionie

    Ułóż kolejność pipeline'u optymalizacji obrazów w Next.js

  • Klikanie w kolejności

    Ułóż poprawną strukturę JSX z elementem div i nagłówkiem h1

  • Układanie w pionie

    Ułóż składnię funkcji getStaticProps w Pages Routerze (katalog pages/)

  • Układanie w pionie

    Ułóż kolejność obsługi żądania HTTP w Next.js

  • Układanie w pionie

    Ułóż składnię funkcji getServerSideProps w Pages Routerze (katalog pages/)

  • Układanie w pionie

    Ułóż kolejność przepływu żądania API przez proxy (dawniej middleware)

  • Edytor kodu

    Zbuduj w App Routerze stronę główną portfolio (plik app/page.jsx) jako domyślnie eksportowany komponent Portfolio. Wykonaj kolejno te kroki: 1. Główny element ma className="portfolio". 2. Na górze umieść <nav> z trzema linkami <Link> z next/link: „Start” (/), „Projekty” (/projects) i „Kontakt” (/contact). 3. Dodaj nagłówek <h1> ze swoim imieniem lub pseudonimem. 4. Utwórz tablicę projects z co najmniej 2 obiektami { id, title } i wyświetl ją w <ul> przez map: każdy projekt jako <li key={project.id}> z tytułem. 5. W styles.css dodaj regułę dla klasy .portfolio (np. tło i odstępy).

  1. PytanieStrategia SSG w Next.js
  2. PytanieZastosowanie ISR
  3. PytanieZmienne środowiskowe klienta w Next.js
  4. Kliknij w kolejnościŚcieżka pliku layout w App Routerze
  5. Ułóż w kolejnościCykl życia w App Routerze
  6. Ułóż w kolejnościUżycie komponentu Image
  7. PytanieDyrektywa 'use client' w Next.js
  8. Ułóż w kolejnościPipeline optymalizacji obrazów
  9. Kliknij w kolejnościStruktura JSX z div i h1
  10. Ułóż w kolejnościSkładnia getStaticProps
  11. PytanieŚrodowisko deweloperskie Next.js
  12. Ułóż w kolejnościObsługa żądania HTTP
  13. PytanieKatalog stron w App Routerze
  14. Ułóż w kolejnościSkładnia getServerSideProps
  15. Ułóż w kolejnościPrzepływ żądania API
  16. PytaniePaczki JavaScript ładowane na żądanie
  17. Zadanie z kodemPortfolio z App Routerem - krok po kroku
  18. Projekt do wysłaniaLink
  19. WideoVideo: Podsumowanie modułu

Przydatne artykuły