// 显式启用永久缓存
const res = await fetch("https://api.example.com/posts", {
  cache: "force-cache",
});

// Next.js 15+ 的默认行为，也可以显式声明
const res = await fetch("https://api.example.com/posts", {
  cache: "no-store",
});

// ✅ 推荐：定时重新验证
const res = await fetch("https://api.example.com/posts", {
  next: { revalidate: 3600 }, // 每小时更新一次
});

// app/blog/page.tsx
export default async function BlogPage() {
  // 每小时重新验证一次
  const res = await fetch("https://api.example.com/posts", {
    next: { revalidate: 3600 },
  });

  const posts = await res.json();

  return (
    <div>
      {posts.map((post) => (
        <article key={post.id}>
          <h2>{post.title}</h2>
          <p>{post.excerpt}</p>
        </article>
      ))}
    </div>
  );
}

// app/profile/page.tsx
export default async function ProfilePage() {
  // 每次都重新获取
  const res = await fetch("https://api.example.com/user/me", {
    cache: "no-store",
    headers: {
      Authorization: `Bearer ${token}`,
    },
  });

  const user = await res.json();

  return (
    <div>
      <h1>{user.name}</h1>
      <p>{user.email}</p>
    </div>
  );
}

// app/products/page.tsx
export default async function ProductsPage() {
  // Next.js 15+ 必须显式声明 force-cache（13/14 中这是默认行为）
  const res = await fetch("https://api.example.com/products", {
    cache: "force-cache",
  });

  const products = await res.json();

  return (
    <div>
      {products.map((product) => (
        <div key={product.id}>
          <h3>{product.name}</h3>
          <p>${product.price}</p>
        </div>
      ))}
    </div>
  );
}

// 文章列表——打 'posts' 标签
const posts = await fetch("https://api.example.com/posts", {
  next: { tags: ["posts"] },
});

// 单篇文章——同时打 'posts' 和 'post-123' 两个标签
const post = await fetch("https://api.example.com/posts/123", {
  next: { tags: ["posts", "post-123"] },
});

// 文章评论——打 'posts'、'post-123'、'comments' 三个标签
const comments = await fetch("https://api.example.com/posts/123/comments", {
  next: { tags: ["posts", "post-123", "comments"] },
});

updateTag("posts");       // 失效所有文章相关的缓存
updateTag("post-123");    // 只失效 ID 为 123 的文章及其评论
updateTag("comments");    // 只失效评论

// 具体路径——直接传路径即可
revalidatePath("/blog");
revalidatePath("/blog/123");

// 动态路由——需要传第二个参数指定失效范围
revalidatePath("/blog/[slug]", "page");    // 失效所有匹配的页面
revalidatePath("/blog/[slug]", "layout");  // 失效所有匹配的页面及其共享布局

// app/actions.ts
'use server';

import { updateTag } from 'next/cache';

export async function createPost(formData: FormData) {
  // 1. 创建文章
  await db.post.create({
    data: {
      title: formData.get('title'),
      content: formData.get('content'),
    },
  });

  // 2. 立即失效缓存——下次请求会等待新数据返回
  updateTag('posts');
}

// app/actions.ts
'use server';

import { revalidateTag } from 'next/cache';

export async function createPost(formData: FormData) {
  await db.post.create({ data: { ... } });

  // 标记为过期，后台刷新
  revalidateTag('posts', 'max');
}

// app/actions.ts
"use server";

import { revalidatePath } from "next/cache";

export async function createPost(formData: FormData) {
  await db.post.create({
    data: {
      title: formData.get("title"),
      content: formData.get("content"),
    },
  });

  // 失效整个页面路径的缓存
  revalidatePath("/blog");
  revalidatePath("/");
}

// ❌ 这些不会被缓存
import axios from "axios";
import { prisma } from "@/lib/prisma";

// 1. axios
const res = await axios.get("https://api.example.com/posts");

// 2. Prisma
const posts = await prisma.post.findMany();

// 3. 其他 HTTP 库
const res = await got("https://api.example.com/posts");

import { prisma } from "@/lib/prisma";
import { cacheTag } from "next/cache";

// ✅ 使用 use cache 指令缓存数据库查询
export async function getPosts() {
  "use cache";
  cacheTag("posts");

  return await prisma.post.findMany();
}

// 使用
const posts = await getPosts();

import { unstable_cache } from "next/cache";
import { prisma } from "@/lib/prisma";

// 包裹数据库查询
export const getPosts = unstable_cache(
  async () => {
    return await prisma.post.findMany();
  },
  ["posts"], // 缓存键
  {
    revalidate: 3600, // 每小时更新
    tags: ["posts"], // 标签
  }
);

// 使用
const posts = await getPosts();

export default async function Page() {
  console.log("🔍 开始请求 API");

  const res = await fetch("https://api.example.com/posts", {
    next: { revalidate: 60 },
  });

  console.log("✅ 请求完成");

  return <div>...</div>;
}

# 构建后查看缓存文件
npm run build

# 查看缓存目录
ls -la .next/cache/fetch-cache/

// app/page.tsx
export const dynamic = "force-dynamic";

export default async function Page() {
  // 这个页面的所有 fetch 都不会缓存
  const res = await fetch("https://api.example.com/posts");
  return <div>...</div>;
}

// revalidatePath：失效整个页面
revalidatePath("/blog");

// revalidateTag：后台刷新（stale-while-revalidate）
revalidateTag("posts", "max");

// updateTag：立即失效（写后即读）
updateTag("posts");

// lib/api.ts
export async function getPosts() {
  const res = await fetch('https://api.example.com/posts', {
    next: {
      revalidate: 3600, // 每小时更新
      tags: ['posts'] // 打标签
    }
  });
  return res.json();
}

export async function getPost(id: string) {
  const res = await fetch(`https://api.example.com/posts/${id}`, {
    next: {
      revalidate: 3600,
      tags: ['posts', `post-${id}`] // 多个标签
    }
  });
  return res.json();
}

// app/actions.ts
'use server';

import { updateTag } from 'next/cache';

export async function createPost(formData: FormData) {
  // 1. 创建文章
  await db.post.create({ data: { ... } });

  // 2. 立即失效列表缓存（用户提交后立刻看到新文章）
  updateTag('posts');
}

export async function updatePost(id: string, formData: FormData) {
  // 1. 更新文章
  await db.post.update({ where: { id }, data: { ... } });

  // 2. 立即失效列表和详情缓存
  updateTag('posts');
  updateTag(`post-${id}`);
}

// app/api/webhook/route.ts
import { revalidateTag } from 'next/cache';

export async function POST(request: Request) {
  const { slug } = await request.json();

  // 后台刷新，走 stale-while-revalidate
  revalidateTag('posts', 'max');
  revalidateTag(`post-${slug}`, 'max');

  return Response.json({ revalidated: true });
}