Next.js từ cơ bản đến nâng cao
Trang chủ / Module 6
🗄️ Module 6 / 18 · 6 ngày 📅 Tuần 4 ●●●● Cực khó

Caching và revalidation: Cache Components, 'use cache', tag

Các lớp cache của Next.js, mô hình Cache Components (Next.js 16): dynamic mặc định, 'use cache', cacheLife, cacheTag, revalidateTag/updateTag/refresh, Partial Prerendering, Router Cache phía client, và mô hình cũ bạn sẽ gặp trong dự án hiện có.

use cachecacheLifecacheTagupdateTagPPR
📌 Vì sao module này quan trọng

Caching là phần khó nhất và gây tranh cãi nhất của Next.js: "sửa dữ liệu rồi mà trang vẫn cũ", "trang lẽ ra static lại render mỗi request", "người dùng A thấy dữ liệu của B". Next.js 15 và 16 đã đổi mặc định hai lần, nên dự án thật thường trộn cả mô hình cũ lẫn mới. Hiểu module này là điều kiện để làm Next.js ở production.

🎯 Mục tiêu học tập

  • Kể tên và phân biệt các lớp cache: request memoization, data cache, prerender (full route), router cache phía client
  • Bật Cache Components và giải thích 'dynamic mặc định, cache khi chủ động'
  • Dùng 'use cache' ở mức file, component, hàm; biết cái gì trở thành cache key
  • Đặt thời gian sống bằng cacheLife và gắn tag bằng cacheTag
  • Chọn đúng giữa revalidateTag, updateTag, revalidatePath, refresh
  • Đọc hiểu mô hình cũ: fetch options, revalidate, dynamic, unstable_cache

Bản đồ các lớp cache

LớpỞ đâuLưu gìSống bao lâuXoá bằng
Request memoizationServer, trong 1 requestKết quả fetch/hàm cache() trùng lặpHết requestTự động
Data cache / 'use cache'Server, bền qua request và deploy (tuỳ cache handler)Kết quả hàm/component/fetchTheo cacheLiferevalidateTag, updateTag, revalidatePath
Prerender (Full Route Cache)ServerHTML + RSC payload của phần staticTới khi revalidate/deployRevalidate dữ liệu bên trong
Router CacheTrình duyệt (bộ nhớ)RSC payload các segment đã xem/prefetchPhiên làm việc, theo staleTimesrouter.refresh(), Server Action revalidate, refresh()

Khi debug "dữ liệu cũ", luôn hỏi: cũ ở lớp nào? Reload cứng hết cũ → Router Cache. Reload vẫn cũ → cache phía server.

Cache Components: dynamic mặc định, cache khi bạn nói

// next.config.ts
import type { NextConfig } from 'next';
const nextConfig: NextConfig = { cacheComponents: true };
export default nextConfig;

Khi bật, quy tắc rất rõ:

  1. Mọi truy cập dữ liệu (DB, fetch) và API theo request (cookies(), headers(), searchParams, connection()) là dynamic — chạy lúc request.
  2. Lúc build, Next.js prerender mọi thứ có thể thành vỏ tĩnh (static shell).
  3. Phần dynamic bắt buộc nằm trong <Suspense> (fallback của nó thuộc vỏ tĩnh) hoặc được đánh dấu 'use cache'. Nếu không, build báo lỗi chỉ ra chỗ dữ liệu không được cache nằm ngoài Suspense — buộc bạn quyết định có chủ đích thay vì vô tình làm cả trang chậm.
export default function ProductPage({ params }: { params: Promise<{ id: string }> }) {
  return (
    <>
      <SiteHeader />                                         {/* tĩnh, nằm trong shell */}
      <ProductInfo params={params} />                        {/* 'use cache' → được prerender/cache */}
      <Suspense fallback={<CartSkeleton />}>
        <CartBadge />                                        {/* đọc cookies() → stream lúc request */}
      </Suspense>
      <Suspense fallback={<StockSkeleton />}>
        <LiveStock params={params} />                        {/* tồn kho realtime, không cache */}
      </Suspense>
    </>
  );
}

Đây chính là Partial Prerendering: phản hồi đầu tiên là vỏ tĩnh từ CDN (rất nhanh), các lỗ động stream vào trong cùng response.

'use cache': ở đâu, cache key là gì

import { cacheLife, cacheTag } from 'next/cache';

// 1. Hàm dữ liệu
export async function getProduct(id: string) {
  'use cache';
  cacheLife('hours');
  cacheTag('products', `product:${id}`);
  return db.query.products.findFirst({ where: eq(products.id, id) });
}

// 2. Component
async function ProductInfo({ params }: { params: Promise<{ id: string }> }) {
  'use cache';
  const { id } = await params;
  const p = await getProduct(id);
  return <section><h1>{p.name}</h1><Price value={p.price} /></section>;
}

// 3. Cả file (mọi export async trong file đều được cache)
'use cache';
export default async function Page() { /* ... */ }
  • Cache key = id build + id của hàm + các tham số (đã serialize) + biến closure. Tham số khác → mục cache khác.
  • Không gọi cookies()/headers() bên trong phạm vi 'use cache' — đọc ở ngoài rồi truyền giá trị vào làm tham số (để giá trị đó thành một phần cache key).
  • children/JSX truyền vào component cached được coi như "lỗ" — không thành key, nên có thể bọc phần dynamic bên trong phần cached.
  • Biến thể: 'use cache: remote' (lưu ở cache handler từ xa, chia sẻ giữa instance), 'use cache: private' (cache theo người dùng, được phép đọc cookies — kiểm tra trạng thái ổn định trên docs).
⚠️ Lộ dữ liệu giữa người dùng

Cache một hàm trả về dữ liệu riêng của người dùng mà không có userId trong tham số → người dùng B nhận dữ liệu cache của A. Dữ liệu cá nhân hoá: hoặc không cache, hoặc userId phải là tham số.

cacheLife: thời gian sống

Thuộc tínhÝ nghĩa
staleClient được dùng bản cache bao lâu mà không hỏi server
revalidateSau bao lâu server làm mới ở nền (stale-while-revalidate)
expireSau bao lâu không có request thì bỏ hẳn, request kế tiếp phải chờ dữ liệu mới

Profile có sẵn: 'seconds', 'minutes', 'hours', 'days', 'weeks', 'max' (và 'default'). Tự định nghĩa:

// next.config.ts
const nextConfig = {
  cacheComponents: true,
  cacheLife: { catalog: { stale: 300, revalidate: 900, expire: 86400 } },
};
// dùng: cacheLife('catalog')

Cache quá ngắn (seconds) bên trong trang sẽ khiến phần đó không được đưa vào prerender — Next.js coi nó như dynamic.

Làm mới cache: revalidateTag, updateTag, revalidatePath, refresh

'use server';
import { revalidateTag, updateTag, revalidatePath, refresh } from 'next/cache';

export async function updateProductPrice(id: string, price: number) {
  await requireAdmin();
  await db.update(products).set({ price }).where(eq(products.id, id));
  updateTag(`product:${id}`);   // hết hạn NGAY, request tiếp theo (của chính người sửa) đọc dữ liệu mới
}

export async function importCatalog() {
  await runImport();
  revalidateTag('products', 'max');  // đánh dấu cũ, phục vụ bản cũ trong lúc làm mới nền (SWR)
}

export async function markNotificationsRead() {
  await db.update(notifications).set({ read: true });
  refresh();                    // làm mới dữ liệu KHÔNG cache trên trang hiện tại của client
}
APIDùng ởHành viKhi nào
updateTag(tag)Chỉ Server ActionXoá ngay, đọc lại dữ liệu mới (read-your-writes)Người dùng sửa và phải thấy ngay kết quả của mình
revalidateTag(tag, profile)Server Action, Route HandlerStale-while-revalidate theo profileWebhook CMS, job nền, cập nhật hàng loạt chấp nhận trễ vài giây
revalidatePath(path)Server Action, Route HandlerLàm mới mọi thứ của một đường dẫnKhông có tag rõ ràng; dùng tiết kiệm
refresh()Server ActionLàm mới router phía client (dữ liệu không cache)Dữ liệu dynamic trên trang hiện tại vừa đổi

Ở Next.js 16, revalidateTag với một tham số đã lỗi thời — luôn truyền profile thứ hai (thường là 'max').

Router Cache phía client

Trình duyệt giữ RSC payload của các trang đã xem/prefetch để Back/Forward và điều hướng tức thì. Mặc định trang dynamic không được tái sử dụng (stale 0 giây), layout và loading thì có. Điều chỉnh bằng experimental.staleTimes.

  • Server Action gọi updateTag/revalidatePath/refresh → Next.js tự làm mới Router Cache liên quan.
  • Dữ liệu đổi từ nơi khác (người khác sửa, webhook) → client không tự biết: dùng router.refresh() theo sự kiện realtime, polling, hoặc chấp nhận tới lần điều hướng sau.

Mô hình cũ (Next.js 13-15) — bạn sẽ gặp trong dự án có sẵn

// Cấu hình theo route segment
export const revalidate = 3600;            // ISR: làm mới tối đa mỗi giờ
export const dynamic = 'force-dynamic';    // luôn render mỗi request
export const dynamic = 'force-static';     // ép static, cookies()/headers() trả rỗng

// fetch options
await fetch(url, { cache: 'force-cache' });                         // cache vô thời hạn
await fetch(url, { next: { revalidate: 60, tags: ['products'] } });  // ISR + tag
await fetch(url, { cache: 'no-store' });                            // không cache

// Cache hàm không phải fetch (ORM)
import { unstable_cache } from 'next/cache';
const getProducts = unstable_cache(async () => db.product.findMany(), ['products'], { revalidate: 300, tags: ['products'] });
Phiên bảnMặc định của fetchGET Route Handler
Next.js 13-14Cache (force-cache) — gây nhiều bất ngờCache
Next.js 15Không cacheKhông cache
Next.js 16 + Cache ComponentsDynamic; cache bằng 'use cache'Dynamic; cache bằng 'use cache' trong hàm helper

Khi phỏng vấn hoặc vào dự án mới, hỏi ngay: "dự án dùng Next.js bản nào và đã bật Cache Components chưa?" — câu trả lời đổi toàn bộ cách đọc code.

🚩 Sai lầm hay gặp

  • Cache dữ liệu cá nhân hoá mà không có userId trong tham số → lộ dữ liệu giữa người dùng.
  • Sửa dữ liệu trong Server Action nhưng quên updateTag → người sửa thấy dữ liệu cũ.
  • Dùng revalidatePath('/') cho mọi thay đổi — làm mới quá nhiều, mất lợi ích cache.
  • Kiểm tra hành vi cache trên next dev thay vì next build && next start.
  • Nhiều instance self-host mà mỗi instance có cache trong bộ nhớ riêng → revalidate ở instance này, instance khác vẫn cũ (Module 17).

🏋️ Bài tập thực hành

Catalog có cache chủ đích

Bật cacheComponents. Trang sản phẩm: thông tin sản phẩm 'use cache' + cacheTag('product:id'); giá khuyến mãi cache minutes; tồn kho realtime trong Suspense; giỏ hàng đọc cookie trong Suspense. Trang admin sửa giá bằng Server Action + updateTag. Route Handler /api/webhooks/cms nhận webhook rồi revalidateTag('products','max'). Viết bảng: mỗi phần của trang thuộc lớp cache nào, làm mới bằng gì. Chạy next build và chụp lại ký hiệu ◐.

📚 Tài nguyên học tập

✅ Tự đánh giá hoàn thành

  • Tôi kể được 4 lớp cache và cách xoá từng lớp
  • Tôi giải thích được quy tắc 'dynamic trong Suspense hoặc use cache' của Cache Components
  • Tôi biết cái gì thành cache key của 'use cache' và rủi ro lộ dữ liệu
  • Tôi chọn đúng updateTag vs revalidateTag vs refresh
  • Tôi đọc được code dùng mô hình cũ (revalidate, dynamic, unstable_cache)