Kurs Next.js · Moduł 5: Strategie renderowania
Streaming danych i React Suspense
W tej lekcji10
W nowoczesnym rozwoju aplikacji webowych wydajność i responsywność interfejsu użytkownika są kluczowymi czynnikami wpływającymi na doświadczenie użytkownika. Next.js, jako framework frontendowy, wprowadza zaawansowane techniki, które pomagają osiągnąć płynne doświadczenie użytkownika nawet przy złożonych operacjach pobierania danych. W tym module przyjrzymy się, jak Next.js App Router wykorzystuje streaming danych i React Suspense do tworzenia bardziej responsywnych aplikacji.
Problemy tradycyjnego renderowania
Przed przejściem do streamingu danych, warto zrozumieć ograniczenia tradycyjnych podejść do renderowania:
- Renderowanie blokujące - klasycznie, cała strona musi poczekać, aż wszystkie dane zostaną pobrane, zanim cokolwiek zostanie wyświetlone użytkownikowi
- Waterfall data fetching - sekwencyjne pobieranie danych, gdzie każde żądanie musi poczekać na zakończenie poprzedniego
- Wszystko albo nic - cała strona jest renderowana jako jedna niepodzielna całość
Te ograniczenia prowadzą do wolniejszego czasu do pierwszej treści (TTFB - Time To First Byte) i mogą powodować frustrację użytkowników, szczególnie na wolniejszych połączeniach lub przy skomplikowanych zapytaniach do bazy danych.
Streaming danych - nowe podejście
Streaming danych, wprowadzony w Next.js App Router, pozwala na stopniowe przesyłanie fragmentów UI z serwera do klienta w miarę ich gotowości, zamiast czekać na zakończenie wszystkich operacji pobierania danych.
Kluczowe zalety tego podejścia to:
- Szybszy TTFB (Time To First Byte) - użytkownik widzi pierwszą treść szybciej
- Progresywny rendering - UI jest renderowany stopniowo, co daje poczucie szybszej responsywności
- Unikanie blokowania - wolniejsze komponenty nie blokują renderowania szybszych komponentów
React Suspense - fundament streamingu w React
Suspense to funkcja React wprowadzona w wersji 16.6, która umożliwia "zawieszenie" renderowania komponentu do czasu spełnienia określonego warunku (np. załadowania danych). Next.js App Router w pełni wykorzystuje tę funkcjonalność do implementacji streamingu danych.
Podstawową ideą Suspense jest:
- Umożliwienie komponentom "wstrzymania" renderowania podczas oczekiwania na dane
- Wyświetlenie komponentu zastępczego (fallback) podczas ładowania
- Zastąpienie fallbacku właściwym komponentem, gdy dane są gotowe
Implementacja streamingu danych w Next.js App Router
1. Podstawowy przykład użycia React Suspense
Zacznijmy od podstawowego przykładu, który pokazuje, jak używać Suspense w Next.js:
// app/dashboard/page.tsx
import { Suspense } from 'react';
import { UserProfile } from './user-profile';
import { RecentOrders } from './recent-orders';
import { Analytics } from './analytics';
import { Loading } from '@/components/loading';
export default function DashboardPage() {
return (
<div className="dashboard-container">
<h1>Panel użytkownika</h1>
{/* Natychmiast renderowany nagłówek */}
<div className="dashboard-header">
<Suspense fallback={<Loading />}>
<UserProfile />
</Suspense>
</div>
<div className="dashboard-grid">
{/* Sekcja zamówień z własnym stanem ładowania */}
<div className="orders-section">
<Suspense fallback={<Loading type="orders" />}>
<RecentOrders />
</Suspense>
</div>
{/* Sekcja analityki z własnym stanem ładowania */}
<div className="analytics-section">
<Suspense fallback={<Loading type="analytics" />}>
<Analytics />
</Suspense>
</div>
</div>
</div>
);
}W tym przykładzie:
- Strona dashboardu jest podzielona na niezależne sekcje
- Każda sekcja jest owinięta w komponent
Suspensez odpowiednim fallbackiem - Sekcje są renderowane niezależnie, gdy ich dane są gotowe
Komponenty UserProfile, RecentOrders i Analytics mogą asynchronicznie pobierać dane:
// app/dashboard/user-profile.tsx
async function getUserData() {
// Pobieranie danych użytkownika - może zająć 500ms
const res = await fetch('/api/user');
return res.json();
}
export async function UserProfile() {
const user = await getUserData();
return (
<div className="user-profile">
<img src={user.avatar} alt={user.name} />
<h2>{user.name}</h2>
<p>{user.email}</p>
</div>
);
}// app/dashboard/recent-orders.tsx
async function getRecentOrders() {
// Pobieranie ostatnich zamówień - może zająć 2s
const res = await fetch('/api/orders/recent');
return res.json();
}
export async function RecentOrders() {
const orders = await getRecentOrders();
return (
<div>
<h3>Ostatnie zamówienia</h3>
<table>
<thead>
<tr>
<th>ID</th>
<th>Produkt</th>
<th>Cena</th>
<th>Status</th>
</tr>
</thead>
<tbody>
{orders.map(order => (
<tr key={order.id}>
<td>{order.id}</td>
<td>{order.product}</td>
<td>{order.price} zł</td>
<td>{order.status}</td>
</tr>
))}
</tbody>
</table>
</div>
);
}2. Zagnieżdżone komponenty Suspense
Możemy tworzyć bardziej złożone struktury z zagnieżdżonymi komponentami Suspense:
// app/products/[category]/page.tsx
import { Suspense } from 'react';
import { CategoryHeader } from './category-header';
import { ProductGrid } from './product-grid';
import { ProductFilter } from './product-filter';
import { RelatedCategories } from './related-categories';
import { SimilarProducts } from './similar-products';
import { Loading } from '@/components/loading';
export default async function CategoryPage({ params }) {
return (
<div className="category-page">
{/* Zagnieżdżone komponenty Suspense */}
<Suspense fallback={<Loading height="200px" />}>
<CategoryHeader category={(await params).category} />
<div className="product-layout">
<aside className="filters">
<Suspense fallback={<Loading type="filters" />}>
<ProductFilter category={(await params).category} />
</Suspense>
</aside>
<main className="products">
<Suspense fallback={<Loading type="products" count={12} />}>
<ProductGrid category={(await params).category} />
</Suspense>
</main>
</div>
<div className="recommendations">
<Suspense fallback={<Loading type="categories" />}>
<RelatedCategories category={(await params).category} />
</Suspense>
<Suspense fallback={<Loading type="products" />}>
<SimilarProducts category={(await params).category} />
</Suspense>
</div>
</Suspense>
</div>
);
}W tym przykładzie:
- Zewnętrzny
Suspenseobejmuje cały widok kategorii - Wewnętrzne komponenty
Suspensedzielą stronę na mniejsze, niezależnie ładowane sekcje - Każda sekcja ma własny stan ładowania dostosowany do typu treści
3. Streaming z komponentami klienta
Możemy łączyć streaming z komponentami klienta, co daje nam możliwość tworzenia interaktywnych UI z płynnym ładowaniem:
// app/products/[id]/page.tsx
import { Suspense } from 'react';
import { ProductDetails } from './product-details';
import { ProductReviews } from './product-reviews';
import AddToCartButton from './add-to-cart-button'; // Komponent klienta
import ProductImageGallery from './product-image-gallery'; // Komponent klienta
import { Loading } from '@/components/loading';
export default async function ProductPage({ params }) {
return (
<div className="product-page">
<div className="product-main">
<Suspense fallback={<Loading type="image-gallery" />}>
<ProductImageWrapper productId={(await params).id} />
</Suspense>
<div className="product-info">
<Suspense fallback={<Loading type="product-details" />}>
<ProductDetailsWrapper productId={(await params).id} />
</Suspense>
{/* Komponent klienta dla interaktywności */}
<AddToCartButton productId={(await params).id} />
</div>
</div>
<div className="product-reviews">
<Suspense fallback={<Loading type="reviews" />}>
<ProductReviews productId={(await params).id} />
</Suspense>
</div>
</div>
);
}
// Wrapper komponentów, które potrzebują props
async function ProductImageWrapper({ productId }) {
const product = await getProduct(productId);
return <ProductImageGallery images={product.images} />;
}
async function ProductDetailsWrapper({ productId }) {
const product = await getProduct(productId);
return <ProductDetails product={product} />;
}
async function getProduct(id) {
const res = await fetch(`/api/products/${id}`);
return res.json();
}W tym przykładzie:
ProductImageGalleryiAddToCartButtonto komponenty klienta ('use client')- Wrapujemy komponenty klienta w asynchroniczne komponenty serwera, aby przekazać im dane
- Komponent
AddToCartButtonjest interaktywny od razu po załadowaniu, nawet gdy inne części strony są wciąż w trakcie ładowania
Zaawansowane techniki streamingu danych
1. Równoległe pobieranie danych
Jedną z najlepszych praktyk przy streamingu danych jest paralelizacja żądań, aby uniknąć wodospadowego pobierania danych:
// app/dashboard/page.tsx
import { Suspense } from 'react';
import { UserProfile } from './user-profile';
import { RecentOrders } from './recent-orders';
import { Analytics } from './analytics';
import { Loading } from '@/components/loading';
// Preinicjalizacja zapytań - unikanie wodospadu danych
export function generateMetadata() {
// Inicjujemy pobieranie danych wcześnie, aby były gotowe
// gdy komponenty będą ich potrzebować
preloadUserData();
preloadRecentOrders();
preloadAnalytics();
return {
title: 'Dashboard - Moja Aplikacja',
};
}
// Funkcje preinicjalizujące
function preloadUserData() {
void getUserData(); // void ignoruje Promise
}
function preloadRecentOrders() {
void getRecentOrders(); // void ignoruje Promise
}
function preloadAnalytics() {
void getAnalyticsData(); // void ignoruje Promise
}
// Funkcje pobierające dane z cache
async function getUserData() {
const res = await fetch('/api/user', { cache: 'force-cache' });
return res.json();
}
async function getRecentOrders() {
const res = await fetch('/api/orders/recent', { cache: 'force-cache' });
return res.json();
}
async function getAnalyticsData() {
const res = await fetch('/api/analytics', { cache: 'force-cache' });
return res.json();
}
export default function DashboardPage() {
return (
<div className="dashboard-container">
{/* ... struktura strony z komponentami Suspense, jak wcześniej ... */}
</div>
);
}W tym podejściu:
- Inicjujemy pobieranie danych już w funkcji
generateMetadata, zanim komponenty ich zażądają - Używamy
voiddo ignorowania Promise, ponieważ nie potrzebujemy ich rezultatu w tej funkcji - W komponentach używamy tych samych funkcji pobierających dane, które korzystają z cache
2. Kaskadowe Suspense - priorytetyzacja zawartości
Możemy strategicznie priorytetyzować ładowanie treści, aby najważniejsze elementy były wyświetlane jako pierwsze:
// app/article/[slug]/page.tsx
import { Suspense } from 'react';
import { ArticleHeader } from './article-header';
import { ArticleContent } from './article-content';
import { ArticleComments } from './article-comments';
import { RelatedArticles } from './related-articles';
import { AuthorBio } from './author-bio';
import { SocialSharing } from './social-sharing';
import { Loading } from '@/components/loading';
export default async function ArticlePage({ params }) {
return (
<article className="article-container">
{/* Priorytet 1: Nagłówek artykułu - ładuje się pierwszy */}
<Suspense fallback={<Loading type="header" />}>
<ArticleHeader slug={(await params).slug} />
</Suspense>
<div className="article-grid">
<div className="article-main">
{/* Priorytet 2: Treść artykułu */}
<Suspense fallback={<Loading type="content" />}>
<ArticleContent slug={(await params).slug} />
<div className="article-footer">
{/* Priorytet 3: Autor i udostępnianie - ładują się po treści */}
<Suspense fallback={<Loading type="author" />}>
<AuthorBio slug={(await params).slug} />
</Suspense>
<SocialSharing url={`/article/${(await params).slug}`} />
</div>
</Suspense>
</div>
<aside className="article-sidebar">
{/* Priorytet 4: Powiązane artykuły - ładują się na końcu */}
<Suspense fallback={<Loading type="related" />}>
<RelatedArticles slug={(await params).slug} />
</Suspense>
</aside>
</div>
{/* Priorytet 5: Komentarze - ładują się na samym końcu */}
<Suspense fallback={<Loading type="comments" />}>
<ArticleComments slug={(await params).slug} />
</Suspense>
</article>
);
}W tym przykładzie:
- Ustalamy jasną hierarchię priorytetów dla zawartości strony
- Najbardziej krytyczne elementy (nagłówek, treść) są streamowane jako pierwsze
- Mniej krytyczne elementy (komentarze, powiązane artykuły) są streamowane później
- Zagnieżdżając komponenty Suspense, tworzymy naturalny przepływ ładowania treści
3. Streaming komponentów z danymi zależnymi
Czasami potrzebujemy, aby jeden komponent poczekał na dane z innego komponentu. Możemy to zrealizować za pomocą kontekstu i współdzielonych zasobów:
// app/shop/[category]/[subcategory]/page.tsx
import { Suspense } from 'react';
import { CategoryProvider } from './category-context';
import { CategoryInfo } from './category-info';
import { SubcategoryProducts } from './subcategory-products';
import { Loading } from '@/components/loading';
export default async function SubcategoryPage({ params }) {
const { category, subcategory } = await params;
return (
<div className="shop-page">
<CategoryProvider category={category}>
<Suspense fallback={<Loading type="category" />}>
<CategoryInfo />
{/* Ten komponent potrzebuje danych z CategoryInfo */}
<Suspense fallback={<Loading type="products" />}>
<SubcategoryProducts subcategory={subcategory} />
</Suspense>
</Suspense>
</CategoryProvider>
</div>
);
}// app/shop/[category]/[subcategory]/category-context.tsx
'use client';
import { createContext, useContext, useState, useEffect } from 'react';
const CategoryContext = createContext(null);
export function CategoryProvider({ children, category }) {
const [categoryData, setCategoryData] = useState(null);
const [loading, setLoading] = useState(true);
useEffect(() => {
async function loadCategoryData() {
try {
const res = await fetch(`/api/categories/${category}`);
const data = await res.json();
setCategoryData(data);
} catch (error) {
console.error('Error loading category data:', error);
} finally {
setLoading(false);
}
}
loadCategoryData();
}, [category]);
return (
<CategoryContext.Provider value={{ categoryData, loading }}>
{children}
</CategoryContext.Provider>
);
}
export function useCategoryContext() {
const context = useContext(CategoryContext);
if (!context) {
throw new Error('useCategoryContext must be used within a CategoryProvider');
}
return context;
}W komponentach odbierających dane:
// app/shop/[category]/[subcategory]/category-info.tsx
'use client';
import { useCategoryContext } from './category-context';
export function CategoryInfo() {
const { categoryData, loading } = useCategoryContext();
if (loading) {
return <div>Ładowanie informacji o kategorii...</div>;
}
return (
<div className="category-info">
<h1>{categoryData.name}</h1>
<p>{categoryData.description}</p>
<div className="category-stats">
<span>{categoryData.productCount} produktów</span>
<span>{categoryData.brandsCount} marek</span>
</div>
</div>
);
}// app/shop/[category]/[subcategory]/subcategory-products.tsx
'use client';
import { useCategoryContext } from './category-context';
import { useEffect, useState } from 'react';
export function SubcategoryProducts({ subcategory }) {
const { categoryData } = useCategoryContext();
const [products, setProducts] = useState([]);
const [loading, setLoading] = useState(true);
useEffect(() => {
// Czekamy, aż categoryData będzie dostępne
if (!categoryData) return;
async function loadProducts() {
try {
// Używamy categoryData do pobierania produktów
const res = await fetch(
`/api/products?category=${categoryData.id}&subcategory=${subcategory}`
);
const data = await res.json();
setProducts(data);
} catch (error) {
console.error('Error loading products:', error);
} finally {
setLoading(false);
}
}
loadProducts();
}, [categoryData, subcategory]);
if (loading) {
return <div>Ładowanie produktów...</div>;
}
return (
<div className="products-grid">
{products.map(product => (
<div key={product.id} className="product-card">
<img src={product.image} alt={product.name} />
<h3>{product.name}</h3>
<p>{product.price} zł</p>
</div>
))}
</div>
);
}Server Components vs. Client Components w kontekście streamingu
Przy implementacji streamingu danych w Next.js App Router, ważne jest zrozumienie różnic między komponentami serwera i klienta:
Server Components
Komponenty serwera są idealne do streamingu, ponieważ:
- Mogą asynchronicznie pobierać dane bezpośrednio z baz danych lub API
- Są renderowane na serwerze i przesyłane do klienta jako HTML
- Mogą być wrappowane w
Suspensedla obsługi stanu ładowania
// app/products/product-list.tsx (Server Component)
async function getProducts() {
// Bezpośredni dostęp do bazy danych na serwerze
const products = await db.products.findMany();
return products;
}
export async function ProductList() {
const products = await getProducts();
return (
<div className="product-list">
{products.map(product => (
<div key={product.id} className="product-item">
<h3>{product.name}</h3>
<p>{product.price} zł</p>
</div>
))}
</div>
);
}Client Components
Komponenty klienta są potrzebne dla interaktywności, ale mają inne zachowanie w kontekście streamingu:
- Nie mogą być bezpośrednio asynchroniczne
- Używają hooków React (useState, useEffect) do pobierania danych
- Są renderowane na kliencie i wymagają przesłania JS do przeglądarki
// app/products/filter-panel.tsx (Client Component)
'use client';
import { useState, useEffect } from 'react';
export function FilterPanel({ onFilterChange }) {
const [categories, setCategories] = useState([]);
const [loading, setLoading] = useState(true);
const [selectedCategory, setSelectedCategory] = useState(null);
useEffect(() => {
async function loadCategories() {
try {
const res = await fetch('/api/categories');
const data = await res.json();
setCategories(data);
} catch (error) {
console.error('Error loading categories:', error);
} finally {
setLoading(false);
}
}
loadCategories();
}, []);
function handleCategoryChange(categoryId) {
setSelectedCategory(categoryId);
onFilterChange({ category: categoryId });
}
if (loading) return <div>Ładowanie filtrów...</div>;
return (
<div className="filter-panel">
<h3>Kategorie</h3>
<ul>
{categories.map(category => (
<li key={category.id}>
<button
onClick={() => handleCategoryChange(category.id)}
className={selectedCategory === category.id ? 'active' : ''}
>
{category.name}
</button>
</li>
))}
</ul>
</div>
);
}Łączenie Server i Client Components
Najlepszą praktyką jest używanie Server Components do pobierania danych i przygotowywania zawartości, a Client Components do interaktywności:
// app/products/page.tsx
import { Suspense } from 'react';
import { ProductList } from './product-list'; // Server Component
import FilterPanel from './filter-panel'; // Client Component
import { Loading } from '@/components/loading';
export default function ProductsPage() {
return (
<div className="products-page">
<div className="sidebar">
<FilterPanel onFilterChange={/* obsługa po stronie klienta */} />
</div>
<div className="main-content">
<Suspense fallback={<Loading type="products" />}>
<ProductList />
</Suspense>
</div>
</div>
);
}Obsługa błędów w streamingu danych
Podczas streamingu danych, istotna jest odpowiednia obsługa błędów. Next.js App Router dostarcza komponent Error Boundary do obsługi błędów w strumieniowanych komponentach:
// app/dashboard/error.tsx
'use client';
import { useEffect } from 'react';
export default function Error({
error,
reset
}: {
error: Error & { digest?: string };
reset: () => void;
}) {
useEffect(() => {
// Logowanie błędu do serwisu monitorującego
console.error('Dashboard error:', error);
}, [error]);
return (
<div className="error-container">
<h2>Coś poszło nie tak!</h2>
<p>{error.message || 'Wystąpił nieoczekiwany błąd.'}</p>
<button
onClick={() => reset()}
className="button"
>
Spróbuj ponownie
</button>
</div>
);
}Możemy także tworzyć komponent Error Boundary dla konkretnych sekcji:
// app/dashboard/analytics-error.tsx
'use client';
export default function AnalyticsError({ error, reset }) {
return (
<div className="section-error">
<h3>Błąd ładowania analityki</h3>
<p>Nie mogliśmy załadować danych analitycznych: {error.message}</p>
<button onClick={reset}>Spróbuj ponownie</button>
</div>
);
}A następnie używać go dla konkretnych sekcji:
// app/dashboard/page.tsx
import { Suspense } from 'react';
import { ErrorBoundary } from 'react-error-boundary';
import { UserProfile } from './user-profile';
import { RecentOrders } from './recent-orders';
import { Analytics } from './analytics';
import AnalyticsError from './analytics-error';
import { Loading } from '@/components/loading';
export default function DashboardPage() {
return (
<div className="dashboard-container">
{/* ... inne sekcje ... */}
<div className="analytics-section">
<ErrorBoundary FallbackComponent={AnalyticsError}>
<Suspense fallback={<Loading type="analytics" />}>
<Analytics />
</Suspense>
</ErrorBoundary>
</div>
</div>
);
}Optymalizacja wydajności streamingu
Właściwa implementacja streamingu danych może znacząco poprawić wydajność aplikacji. Oto kilka dodatkowych technik optymalizacyjnych:
1. Zapobieganie migotaniu interfejsu
// app/layout.tsx
export default function RootLayout({ children }) {
return (
<html lang="pl">
<body>
{/* Ustawienie minimalnego opóźnienia dla Suspense */}
<script dangerouslySetInnerHTML={{ __html: `
window.SuspenseMinDelay = 300; // ms
` }} />
{children}
</body>
</html>
);
}Możemy również stworzyć własny komponent do opóźniania stanu ładowania:
// components/delayed-suspense.tsx
'use client';
import { Suspense, useState, useEffect } from 'react';
export function DelayedSuspense({
children,
fallback,
delay = 300
}) {
const [showFallback, setShowFallback] = useState(false);
useEffect(() => {
const timer = setTimeout(() => {
setShowFallback(true);
}, delay);
return () => clearTimeout(timer);
}, [delay]);
return (
<Suspense fallback={showFallback ? fallback : null}>
{children}
</Suspense>
);
}2. Priorytetyzacja krytycznych danych
// app/products/[id]/page.tsx
import { Suspense } from 'react';
import { ProductBasicInfo } from './product-basic-info'; // Krytyczne dane
import { ProductDetails } from './product-details'; // Ważne dane
import { ProductReviews } from './product-reviews'; // Mniej krytyczne dane
import { RelatedProducts } from './related-products'; // Najmniej krytyczne dane
import { Loading } from '@/components/loading';
export default async function ProductPage({ params }) {
// Preinicjalizacja krytycznych danych
preloadProductBasicInfo((await params).id);
return (
<div className="product-page">
{/* Natychmiastowe renderowanie krytycznych informacji */}
<div className="product-hero">
<Suspense fallback={<Loading priority="high" />}>
<ProductBasicInfo productId={(await params).id} />
</Suspense>
</div>
{/* Mniej krytyczne sekcje ładowane później */}
<div className="product-content">
<Suspense fallback={<Loading priority="medium" />}>
<ProductDetails productId={(await params).id} />
</Suspense>
</div>
<div className="product-secondary">
<Suspense fallback={<Loading priority="low" />}>
<ProductReviews productId={(await params).id} />
</Suspense>
</div>
<div className="product-related">
<Suspense fallback={<Loading priority="lowest" />}>
<RelatedProducts productId={(await params).id} />
</Suspense>
</div>
</div>
);
}
// Preinicjalizacja krytycznych danych
function preloadProductBasicInfo(id) {
void getProductBasicInfo(id);
}
async function getProductBasicInfo(id) {
const res = await fetch(`/api/products/${id}/basic`, {
priority: 'high' // Ustawienie priorytetu fetch API
});
return res.json();
}3. Ograniczanie przeskoków układu (CLS)
// components/loading.tsx
export function Loading({ type, priority = 'medium', height, width }) {
// Określamy wymiary szkieletu na podstawie typu zawartości
const dimensions = getDimensionsForType(type, { height, width });
return (
<div
className={`skeleton-loader ${type} priority-${priority}`}
style={{
height: dimensions.height,
width: dimensions.width,
// Predefiniowane wymiary zapobiegają przeskokom layoutu
}}
>
<div className="skeleton-animation" />
</div>
);
}
function getDimensionsForType(type, userDimensions) {
// Domyślne wymiary dla różnych typów treści
const defaults = {
'header': { height: '100px', width: '100%' },
'products': { height: '300px', width: '100%' },
'sidebar': { height: '400px', width: '250px' },
// ... inne typy
};
return {
height: userDimensions.height || defaults[type]?.height || '200px',
width: userDimensions.width || defaults[type]?.width || '100%'
};
}Typowe przypadki użycia streamingu danych
Streaming danych jest szczególnie przydatny w następujących scenariuszach:
1. Aplikacje e-commerce
- Szybkie ładowanie podstawowych informacji o produkcie
- Asynchroniczne ładowanie recenzji i rekomendacji
- Interaktywne filtry i wyszukiwanie podczas ładowania produktów
2. Dashboardy analityczne
- Natychmiastowe ładowanie krytycznych wskaźników
- Stopniowe ładowanie złożonych wykresów i raportów
- Niezależne sekcje analityczne z własnymi stanami ładowania
3. Agregatory treści
- Szybkie ładowanie nagłówków i obrazów
- Opóźnione ładowanie treści artykułów
- Priorytetyzacja aktualnych treści przed archiwalnymi
4. Social media i aplikacje czatu
- Szybkie ładowanie podstawowych informacji profilu
- Strumieniowanie wiadomości i komentarzy
- Ładowanie mediów w tle po załadowaniu tekstu
Podsumowanie
Streaming danych i React Suspense w Next.js App Router oferują potężne narzędzia do tworzenia wydajniejszych i bardziej responsywnych aplikacji. Kluczowe zalety tego podejścia to:
- Lepsze doświadczenie użytkownika - treść jest wyświetlana stopniowo, co daje wrażenie szybszego działania aplikacji
- Optymalizacja TTFB i LCP - krytyczne części UI ładują się szybciej, poprawiając kluczowe metryki wydajności
- Granularna kontrola - możliwość precyzyjnego sterowania kolejnością ładowania treści
- Elastyczne zarządzanie UI - lepsze zarządzanie stanami ładowania dla różnych sekcji strony
Implementując streaming danych w swoich aplikacjach Next.js, pamiętaj o następujących najlepszych praktykach:
- Dziel UI na logiczne, niezależne części - każda część powinna być owinięta własnym komponentem Suspense
- Priorytetyzuj krytyczne treści - najważniejsze elementy powinny być ładowane jako pierwsze
- Równoległe pobieranie danych - inicjalizuj zapytania wcześnie, aby uniknąć wodospadowego ładowania
- Zapewnij płynne stany ładowania - stosuj szkielety ładowania o odpowiednich wymiarach, by uniknąć przeskoków layoutu
- Odpowiednio obsługuj błędy - używaj Error Boundary dla każdej sekcji, aby izolować problemy
W następnym module omówimy szczegółowo, jak tworzyć zaawansowane szkielety ładowania i wskaźniki postępu, które uzupełniają strategię streamingu danych, zapewniając jeszcze lepsze doświadczenie użytkownika.
Kod do tej lekcji: App.tsx
import React, { useState, useEffect, Suspense } from 'react';
// Symulacja Streaming i React.Suspense w Next.js
function SlowComponent({ label, delay }: { label: string; delay: number }) {
const [data, setData] = useState<string | null>(null);
useEffect(() => {
const timer = setTimeout(() => {
setData(`Dane zaladowane po ${delay}ms`);
}, delay);
return () => clearTimeout(timer);
}, [delay]);
if (!data) throw new Promise(() => {}); // symulacja pending
return (
<div style={{ background: '#1a2744', border: '1px solid #64ffda', borderRadius: 8, padding: 16, marginBottom: 12 }}>
<h3 style={{ color: '#64ffda', margin: 0 }}>{label}</h3>
<p style={{ color: '#ccc', margin: '8px 0 0' }}>{data}</p>
</div>
);
}
// Komponent ladowania (fallback dla Suspense)
function StreamingFallback({ label }: { label: string }) {
return (
<div style={{
background: '#1a1a2e', border: '1px dashed #555',
borderRadius: 8, padding: 16, marginBottom: 12
}}>
<div style={{ color: '#888' }}>Streaming: {label}...</div>
<div style={{
height: 12, background: 'linear-gradient(90deg, #333, #555, #333)',
borderRadius: 4, marginTop: 8, animation: 'pulse 1.5s infinite'
}} />
</div>
);
}
// Komponent demonstracyjny z roznymi czasami ladowania
function DemoSection({ label, delay }: { label: string; delay: number }) {
const [key, setKey] = useState(0);
return (
<div>
<button onClick={() => setKey(k => k + 1)} style={{
background: '#2196f3', color: '#fff', border: 'none',
borderRadius: 4, padding: '4px 10px', marginBottom: 8, cursor: 'pointer', fontSize: 11
}}>
Przeladuj {label}
</button>
<ErrorBoundary key={key} fallback={<StreamingFallback label={label} />}>
<Suspense fallback={<StreamingFallback label={label} />}>
<SlowComponent label={label} delay={delay} key={key} />
</Suspense>
</ErrorBoundary>
</div>
);
}
// Prosta granica bledow
class ErrorBoundary extends React.Component<
{ children: React.ReactNode; fallback: React.ReactNode },
{ hasError: boolean }
> {
state = { hasError: false };
static getDerivedStateFromError() { return { hasError: true }; }
render() {
return this.state.hasError ? this.props.fallback : this.props.children;
}
}
export default function StreamingDemo() {
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: 20, color: '#e0e0e0', fontFamily: 'monospace' }}>
<h1 style={{ color: '#64ffda' }}>Streaming i Suspense</h1>
<p style={{ color: '#888', marginBottom: 20 }}>
Kazda sekcja laduje sie niezaleznie - to wlasnie streaming!
</p>
<DemoSection label="Nawigacja (szybka)" delay={500} />
<DemoSection label="Lista produktow (srednia)" delay={1500} />
<DemoSection label="Rekomendacje AI (wolna)" delay={3000} />
</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. SSG w Next.js to:
2. ISR w Next.js oznacza:
Zadania praktyczne w grze
- Edytor kodu
Zaimplementuj dashboard z Streaming SSR i Suspense
- Układanie w pionie
Ułóż etapy renderowania Server Component w prawidłowej kolejności:
- Klikanie w kolejności
Ułóż składnię fetch z opcją revalidate w Next.js
- Edytor kodu
Utwórz Server Component, który asynchronicznie pobiera dane z API i wyświetla listę produktów