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ó.
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
cacheLifevà gắn tag bằngcacheTag - Chọn đúng giữa
revalidateTag,updateTag,revalidatePath,refresh - Đọc hiểu mô hình cũ:
fetchoptions,revalidate,dynamic,unstable_cache
Bản đồ các lớp cache
| Lớp | Ở đâu | Lưu gì | Sống bao lâu | Xoá bằng |
|---|---|---|---|---|
| Request memoization | Server, trong 1 request | Kết quả fetch/hàm cache() trùng lặp | Hết request | Tự động |
Data cache / 'use cache' | Server, bền qua request và deploy (tuỳ cache handler) | Kết quả hàm/component/fetch | Theo cacheLife | revalidateTag, updateTag, revalidatePath |
| Prerender (Full Route Cache) | Server | HTML + RSC payload của phần static | Tới khi revalidate/deploy | Revalidate dữ liệu bên trong |
| Router Cache | Trình duyệt (bộ nhớ) | RSC payload các segment đã xem/prefetch | Phiên làm việc, theo staleTimes | router.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õ:
- 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. - Lúc build, Next.js prerender mọi thứ có thể thành vỏ tĩnh (static shell).
- 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).
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 |
|---|---|
stale | Client được dùng bản cache bao lâu mà không hỏi server |
revalidate | Sau bao lâu server làm mới ở nền (stale-while-revalidate) |
expire | Sau 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
}
| API | Dùng ở | Hành vi | Khi nào |
|---|---|---|---|
updateTag(tag) | Chỉ Server Action | Xoá 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 Handler | Stale-while-revalidate theo profile | Webhook 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 Handler | Làm mới mọi thứ của một đường dẫn | Không có tag rõ ràng; dùng tiết kiệm |
refresh() | Server Action | Là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ản | Mặc định của fetch | GET Route Handler |
|---|---|---|
| Next.js 13-14 | Cache (force-cache) — gây nhiều bất ngờ | Cache |
| Next.js 15 | Không cache | Không cache |
| Next.js 16 + Cache Components | Dynamic; 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 devthay 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
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
-
Next.js — Cache ComponentsMô hình mớiDocs
-
Next.js — 'use cache'API referenceDocs
-
Next.js — Caching and RevalidatingcacheTag, revalidateTag, updateTagDocs
-
Next.js — Caching (mô hình cũ)4 lớp cache, fetch optionsDocs
✅ 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
updateTagvsrevalidateTagvsrefresh - Tôi đọc được code dùng mô hình cũ (
revalidate,dynamic,unstable_cache)