Kurs Next.js · Moduł 5: Strategie renderowania

Strategie renderowania w Next.js App Router

9 min czytania ·
W tej lekcji9

Next.js zrewolucjonizował sposób tworzenia aplikacji React, oferując różne strategie renderowania, które można wybierać zależnie od charakterystyki strony i wymagań projektu. W tym module omówimy, jak strategie renderowania działają w kontekście App Router, wprowadzonego w Next.js 13 i rozwijanego w kolejnych wersjach.

Ewolucja renderowania w Next.js

Next.js przeszedł istotną ewolucję w podejściu do renderowania. W wersjach przed 13, używaliśmy specjalnych funkcji jak getStaticProps, getServerSideProps czy getStaticPaths, aby określić strategię renderowania dla danej strony. Każda strona musiała wybrać jedną konkretną strategię.

W App Router podejście jest inne - renderowanie jest teraz bardziej granularne i opiera się na koncepcji React Server Components. Zamiast określać strategię dla całej strony, możemy mieszać różne podejścia na poziomie poszczególnych komponentów.

React Server Components - fundament App Router

U podstaw nowego modelu renderowania leżą React Server Components (RSC), które zmieniły sposób myślenia o aplikacjach React. Główne cechy RSC to:

  1. Renderowanie na serwerze - komponenty są renderowane na serwerze, a do klienta trafia już gotowy HTML
  2. Brak wliczania do bundla JavaScript - kod RSC nie jest wysyłany do przeglądarki
  3. Bezpośredni dostęp do zasobów serwerowych - bazy danych, system plików itp.
  4. Brak dostępu do API przeglądarki - nie można używać hooks ani obsługiwać zdarzeń

Strategie renderowania w App Router

W App Router wciąż możemy korzystać z tradycyjnych strategii renderowania, ale sposób ich implementacji jest inny. Przyjrzyjmy się każdej z nich.

1. Renderowanie po stronie serwera (SSR - Server-Side Rendering)

W App Router, SSR jest domyślnym zachowaniem dla Route Handlers i Server Components.

// app/products/page.tsx
import { Product } from '@/components/Product';

async function getData() {
  // Ta funkcja uruchamia się dla każdego żądania na serwerze
  const res = await fetch('https://api.example.com/products', { cache: 'no-store' });

  if (!res.ok) {
    throw new Error('Failed to fetch data');
  }

  return res.json();
}

export default async function ProductsPage() {
  const products = await getData();

  return (
    <div>
      <h1>Nasze produkty</h1>
      <div className="grid">
        {products.map(product => (
          <Product key={product.id} data={product} />
        ))}
      </div>
    </div>
  );
}

Kluczowe cechy SSR w App Router:

  • Używamy opcji cache: 'no-store' w funkcji fetch lub revalidate: 0, aby wskazać, że dane powinny być pobierane przy każdym żądaniu
  • Komponenty są asynchroniczne (async), co pozwala na bezpośrednie użycie await w ciele komponentu
  • Każde żądanie do strony powoduje ponowne renderowanie strony na serwerze

Zalety SSR:

  • Zawsze aktualne dane
  • Lepsza wydajność SEO (wyszukiwarki widzą pełną treść strony)
  • Możliwość personalizacji treści dla każdego użytkownika

Wady SSR:

  • Wolniejsze ładowanie strony (serwer musi przetworzyć każde żądanie)
  • Większe obciążenie serwera

2. Generowanie statyczne (SSG - Static Site Generation)

W App Router, SSG osiągamy poprzez domyślne zachowanie fetch bez opcji cache: 'no-store'.

// app/blog/page.tsx
import { BlogPost } from '@/components/BlogPost';

async function getData() {
  // Ta funkcja uruchamia się tylko w czasie budowania (lub na żądanie w trybie dev)
  const res = await fetch('https://api.example.com/blog-posts');

  if (!res.ok) {
    throw new Error('Failed to fetch data');
  }

  return res.json();
}

export default async function BlogPage() {
  const posts = await getData();

  return (
    <div>
      <h1>Nasz blog</h1>
      <div className="grid">
        {posts.map(post => (
          <BlogPost key={post.id} data={post} />
        ))}
      </div>
    </div>
  );
}

Kluczowe cechy SSG w App Router:

  • Domyślnie wszystkie komponenty są renderowane statycznie, jeśli nie określono inaczej
  • Dane są pobierane w czasie budowania aplikacji i "zamrażane" w statycznym HTML
  • Nie ma potrzeby używania specjalnej funkcji jak getStaticProps - wystarczy zwykły fetch

Zalety SSG:

  • Bardzo szybkie ładowanie stron (serwowane są statyczne pliki HTML)
  • Minimalne obciążenie serwera
  • Dobra wydajność SEO

Wady SSG:

  • Dane mogą być nieaktualne (aktualizowane tylko przy przebudowie)
  • Nie nadaje się do stron z treścią spersonalizowaną dla użytkownika

3. Przyrostowa regeneracja statyczna (ISR - Incremental Static Regeneration)

W App Router, ISR osiągamy poprzez dodanie opcji revalidate do funkcji fetch lub do segmentu trasy.

// app/products/[id]/page.tsx
import { ProductDetails } from '@/components/ProductDetails';
import { notFound } from 'next/navigation';

// Opcja 1: Rewalidacja na poziomie strony
export const revalidate = 3600; // Rewalidacja co godzinę

async function getProduct(id) {
  // Opcja 2: Rewalidacja na poziomie funkcji fetch
  const res = await fetch(`https://api.example.com/products/${id}`, {
    next: { revalidate: 3600 } // Również co godzinę
  });

  if (!res.ok) {
    return null;
  }

  return res.json();
}

export default async function ProductPage({ params }) {
  const product = await getProduct((await params).id);

  if (!product) {
    notFound();
  }

  return <ProductDetails product={product} />;
}

Kluczowe cechy ISR w App Router:

  • Możemy określić czas rewalidacji na poziomie komponentu za pomocą eksportowanej zmiennej revalidate
  • Możemy określić czas rewalidacji na poziomie żądania fetch za pomocą opcji next: { revalidate: seconds }
  • Istnieje możliwość wymuszenia rewalidacji za pomocą API Route Handler

Zalety ISR:

  • Łączy zalety SSG (szybkość) i SSR (względna aktualność danych)
  • Pozwala na aktualizację treści bez przebudowy całej aplikacji
  • Dobre wsparcie dla SEO

Wady ISR:

  • Dane nie są w 100% aktualne (istnieje opóźnienie zależne od ustawionego czasu rewalidacji)
  • Złożoniejsza implementacja i debugowanie

4. Renderowanie po stronie klienta (CSR - Client-Side Rendering)

W App Router, CSR osiągamy poprzez oznaczenie komponentu jako "Client Component" przy użyciu dyrektywy 'use client' na początku pliku.

'use client';

// app/dashboard/page.tsx
import { useState, useEffect } from 'react';

export default function Dashboard() {
  const [data, setData] = useState(null);
  const [isLoading, setIsLoading] = useState(true);

  useEffect(() => {
    async function fetchData() {
      try {
        const res = await fetch('/api/dashboard-data');
        const jsonData = await res.json();
        setData(jsonData);
      } catch (error) {
        console.error('Error fetching data:', error);
      } finally {
        setIsLoading(false);
      }
    }

    fetchData();
  }, []);

  if (isLoading) return <div>Ładowanie danych...</div>;

  return (
    <div>
      <h1>Panel kontrolny</h1>
      {/* Renderowanie danych pobranych po stronie klienta */}
      {data && data.map(item => (
        <div key={item.id}>{item.name}</div>
      ))}
    </div>
  );
}

Kluczowe cechy CSR w App Router:

  • Komponent musi być oznaczony dyrektywą 'use client'
  • Możemy używać hooków React (useState, useEffect itp.)
  • Dane są pobierane po załadowaniu strony w przeglądarce

Zalety CSR:

  • Może oferować lepsze doświadczenie użytkownika dla aplikacji interaktywnych
  • Mniejsze obciążenie serwera (dane są pobierane bezpośrednio z API w przeglądarce)
  • Dobra opcja dla treści spersonalizowanych dla zalogowanego użytkownika

Wady CSR:

  • Słabsza wydajność SEO (wyszukiwarki mogą nie widzieć wszystkich treści)
  • Wolniejsze początkowe ładowanie treści (użytkownik widzi stan ładowania)
  • Większy rozmiar plików JavaScript przesyłanych do przeglądarki

Mieszane podejście - najlepsza praktyka w App Router

Jedną z największych zalet App Router jest możliwość mieszania różnych strategii renderowania w ramach jednej aplikacji, a nawet jednej strony. Dzięki temu możemy wybrać optymalną strategię dla każdego komponentu.

Przykład wykorzystania mieszanych strategii:

// app/products/[category]/page.tsx
import { ProductList } from '@/components/ProductList';
import { CategoryHeader } from '@/components/CategoryHeader';
import FilterSidebar from '@/components/FilterSidebar'; // Client Component

// Ta strona i jej dane są renderowane statycznie
// z rewalidacją co godzinę
export const revalidate = 3600;

// Określamy, które kategorie mają być generowane statycznie
export async function generateStaticParams() {
  const categories = await fetch('https://api.example.com/categories').then(res => res.json());

  return categories.map(category => ({
    category: category.slug,
  }));
}

async function getCategoryData(category) {
  const categoryData = await fetch(`https://api.example.com/categories/${category}`);
  return categoryData.json();
}

async function getProducts(category) {
  const products = await fetch(`https://api.example.com/products?category=${category}`);
  return products.json();
}

export default async function CategoryPage({ params }) {
  // Pobieramy dane równolegle
  const [categoryData, products] = await Promise.all([
    getCategoryData((await params).category),
    getProducts((await params).category),
  ]);

  return (
    <div className="grid grid-cols-4 gap-4">
      {/* Statycznie renderowany nagłówek kategorii */}
      <CategoryHeader data={categoryData} />

      {/* Interaktywny filtr renderowany po stronie klienta */}
      <div className="col-span-1">
        <FilterSidebar initialProducts={products} />
      </div>

      {/* Statycznie renderowana lista produktów */}
      <div className="col-span-3">
        <ProductList products={products} />
      </div>
    </div>
  );
}

W tym przykładzie:

  • Cała strona jest renderowana statycznie z rewalidacją co godzinę (ISR)
  • Tylko określone kategorie są generowane w czasie budowania (generateStaticParams)
  • Komponent FilterSidebar jest Client Component, umożliwiający interaktywne filtrowanie po stronie klienta
  • Komponenty CategoryHeader i ProductList są Server Components renderowane statycznie

Kiedy używać której strategii?

Wybór strategii renderowania zależy od charakterystyki danej części aplikacji:

  1. Strony statyczne (dokumentacja, landing page, strony informacyjne):

    • Użyj SSG (domyślne zachowanie)
  2. Treści dynamiczne, ale nie wymagające najnowszych danych (blog, katalog produktów):

    • Użyj ISR z odpowiednim czasem rewalidacji
  3. Treści wymagające najnowszych danych (ceny akcji, wiadomości, wyniki sportowe):

    • Użyj SSR (cache: 'no-store')
  4. Treści spersonalizowane i interaktywne elementy interfejsu (panele kontrolne, formularze):

    • Użyj CSR ('use client')
  5. Hybrydowe podejście (np. e-commerce):

    • Statyczny szkielet strony (SSG/ISR)
    • Dynamiczne dane produktów (SSR)
    • Interaktywne elementy jak koszyk, filtry (CSR)

Dynamiczne i statyczne trasy

W App Router, możemy również określić, które ścieżki dynamiczne powinny być generowane statycznie podczas budowania aplikacji:

// app/blog/[slug]/page.tsx
export async function generateStaticParams() {
  const posts = await fetch('https://api.example.com/posts').then(res => res.json());

  return posts.map((post) => ({
    slug: post.slug,
  }));
}

Dla tras, które nie są objęte przez generateStaticParams:

  • Jeśli ustawiliśmy dynamicParams = false w opcjach segmentu, Next.js zwróci 404
  • Jeśli dynamicParams = true (domyślnie) lub nie jest ustawione, Next.js wygeneruje stronę na żądanie (SSR)

Optymalizacja stron dynamicznych

Jeśli mamy wiele dynamicznych podstron (np. tysiące produktów w e-commerce), możemy zoptymalizować proces budowania poprzez:

  1. Generowanie najpopularniejszych stron statycznie podczas budowania:
export async function generateStaticParams() {
  // Pobierz tylko najpopularniejsze produkty
  const popularProducts = await fetch('https://api.example.com/products/popular').then(res => res.json());

  return popularProducts.map((product) => ({
    id: product.id,
  }));
}
  1. On-demand Revalidation - rewalidacja poszczególnych stron na żądanie, np. po aktualizacji produktu:
// app/api/revalidate/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { revalidatePath } from 'next/cache';

export async function POST(request: NextRequest) {
  const { path, secret } = await request.json();

  // Sprawdzenie tajnego klucza dla bezpieczeństwa
  if (secret !== process.env.REVALIDATION_SECRET) {
    return NextResponse.json({ message: 'Invalid secret' }, { status: 401 });
  }

  if (!path) {
    return NextResponse.json({ message: 'Path is required' }, { status: 400 });
  }

  try {
    // Rewalidacja określonej ścieżki
    revalidatePath(path);
    return NextResponse.json({ revalidated: true, message: `Revalidated ${path}` });
  } catch (err) {
    return NextResponse.json({ message: 'Error revalidating' }, { status: 500 });
  }
}

Porównanie strategii renderowania

CechaSSGISRSSRCSR
Wydajność
SEO
Aktualność danych
Obciążenie serwera
Interaktywność

Podsumowanie

App Router w Next.js oferuje zaawansowane możliwości mieszania różnych strategii renderowania na poziomie komponentów, co pozwala na tworzenie wydajnych i elastycznych aplikacji. Kluczem do sukcesu jest wybór odpowiedniej strategii dla każdej części aplikacji, biorąc pod uwagę wymagania dotyczące wydajności, SEO i aktualności danych.

W następnym module omówimy bardziej szczegółowo mechanizmy rewalidacji danych w Next.js App Router, które są kluczowe dla implementacji ISR i zapewnienia aktualności treści.

Kod do tej lekcji: App.tsx
// Demo: Strategie renderowania w Next.js App Router
// SSG (Static), SSR (Dynamic), ISR (Incremental Static Regeneration)
import React, { useState } from 'react';

// Next.js App Router domyślnie używa Static Rendering (SSG)
// Dynamiczne renderowanie włącza się automatycznie gdy:
// - Użyjesz cookies(), headers(), searchParams
// - fetch() z { cache: 'no-store' }
// - export const dynamic = 'force-dynamic'

interface RenderingStrategy {
  name: string;
  shortName: string;
  color: string;
  when: string;
  code: string;
  pros: string[];
  cons: string[];
  buildTime: boolean;
  requestTime: boolean;
}

const strategies: RenderingStrategy[] = [
  {
    name: 'Static Site Generation',
    shortName: 'SSG',
    color: '#7c4dff',
    when: 'Build time (domyślnie w App Router)',
    code: "// Domyślne zachowanie - nie trzeba nic dodawać\nexport default async function Page() {\n  const data = await fetch(url); // cached\n  return <div>{data}</div>;\n}",
    pros: ['Najszybsze - HTML gotowy z CDN', 'Najtańsze - zero obliczeń per request', 'SEO-friendly'],
    cons: ['Dane statyczne do następnego buildu', 'Nie nadaje się do personalizacji'],
    buildTime: true,
    requestTime: false,
  },
  {
    name: 'Server-Side Rendering',
    shortName: 'SSR',
    color: '#64ffda',
    when: 'Każde żądanie (on-demand)',
    code: "// Wymuś dynamiczne renderowanie\nexport const dynamic = 'force-dynamic';\n// lub użyj cookies/headers\nimport { cookies } from 'next/headers';\n\nexport default async function Page() {\n  const session = cookies().get('token');\n  const data = await fetch(url, {\n    cache: 'no-store'\n  });\n  return <div>{data}</div>;\n}",
    pros: ['Zawsze aktualne dane', 'Personalizacja per-user', 'SEO-friendly'],
    cons: ['Wolniejsze - serwer przetwarza każdy request', 'Wyższe koszty serwera'],
    buildTime: false,
    requestTime: true,
  },
  {
    name: 'Incremental Static Regeneration',
    shortName: 'ISR',
    color: '#ff9800',
    when: 'Build + odświeżanie co N sekund',
    code: "// Rewalidacja co 60 sekund\nexport const revalidate = 60;\n\nexport default async function Page() {\n  const data = await fetch(url, {\n    next: { revalidate: 60 }\n  });\n  return <div>{data}</div>;\n}\n\n// Lub on-demand:\nimport { revalidatePath } from 'next/cache';\nrevalidatePath('/products');",
    pros: ['Balans: szybkość SSG + aktualność SSR', 'Niskie koszty', 'Skalowalne'],
    cons: ['Dane mogą być nieaktualne przez N sekund', 'Bardziej złożona konfiguracja'],
    buildTime: true,
    requestTime: true,
  },
];

function StrategyCard({ strategy, isActive, onClick }: {
  strategy: RenderingStrategy; isActive: boolean; onClick: () => void;
}) {
  return (
    <div onClick={onClick} style={{
      background: isActive ? `${strategy.color}12` : 'rgba(255,255,255,0.02)',
      border: `2px solid ${isActive ? strategy.color : 'rgba(255,255,255,0.08)'}`,
      borderRadius: '12px', padding: '20px', cursor: 'pointer',
      transition: 'all 0.3s ease',
    }}>
      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '8px' }}>
        <h3 style={{ color: strategy.color, margin: 0 }}>{strategy.shortName}</h3>
        <div style={{ display: 'flex', gap: '6px' }}>
          {strategy.buildTime && (
            <span style={{ background: '#7c4dff20', color: '#7c4dff', padding: '2px 8px', borderRadius: '10px', fontSize: '0.7rem' }}>
              Build
            </span>
          )}
          {strategy.requestTime && (
            <span style={{ background: '#64ffda20', color: '#64ffda', padding: '2px 8px', borderRadius: '10px', fontSize: '0.7rem' }}>
              Request
            </span>
          )}
        </div>
      </div>
      <p style={{ color: '#b0bec5', fontSize: '0.85rem', margin: '0 0 8px' }}>{strategy.name}</p>
      <p style={{ color: '#78909c', fontSize: '0.8rem', margin: 0 }}>{strategy.when}</p>
    </div>
  );
}

export default function RenderingStrategies() {
  const [active, setActive] = useState(0);
  const s = strategies[active];

  return (
    <div style={{
      background: '#0f0f23', minHeight: '100vh', padding: '24px',
      color: '#fff', fontFamily: 'system-ui, sans-serif',
    }}>
      <h1 style={{ color: '#64ffda', marginBottom: '8px' }}>Strategie Renderowania</h1>
      <p style={{ color: '#b0bec5', marginBottom: '24px' }}>
        Next.js App Router - SSG vs SSR vs ISR
      </p>

      <div style={{ display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: '12px', marginBottom: '24px' }}>
        {strategies.map((st, i) => (
          <StrategyCard key={st.shortName} strategy={st} isActive={i === active} onClick={() => setActive(i)} />
        ))}
      </div>

      <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '16px' }}>
        <div style={{
          background: 'rgba(0,0,0,0.3)', borderRadius: '12px', padding: '20px',
        }}>
          <h4 style={{ color: s.color, marginBottom: '12px' }}>Kod</h4>
          <pre style={{ margin: 0, color: '#b0bec5', fontSize: '0.8rem', lineHeight: 1.6, whiteSpace: 'pre-wrap' }}>
            {s.code}
          </pre>
        </div>
        <div style={{ display: 'grid', gap: '16px' }}>
          <div style={{ background: 'rgba(76,175,80,0.08)', borderRadius: '12px', padding: '16px' }}>
            <h4 style={{ color: '#4caf50', marginBottom: '8px' }}>Zalety</h4>
            {s.pros.map(p => (
              <p key={p} style={{ color: '#b0bec5', fontSize: '0.85rem', margin: '4px 0' }}>+ {p}</p>
            ))}
          </div>
          <div style={{ background: 'rgba(244,67,54,0.08)', borderRadius: '12px', padding: '16px' }}>
            <h4 style={{ color: '#f44336', marginBottom: '8px' }}>Wady</h4>
            {s.cons.map(c => (
              <p key={c} style={{ color: '#b0bec5', fontSize: '0.85rem', margin: '4px 0' }}>- {c}</p>
            ))}
          </div>
        </div>
      </div>
    </div>
  );
}

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. Co oznacza Server-Side Rendering (SSR) w kontekście Next.js?

  1. PytaniePodstawowa koncepcja SSR

Przydatne artykuły