// app/api/revalidate/route.ts
import { revalidateTag } from "next/cache";
import { NextRequest } from "next/server";

export async function POST(request: NextRequest) {
  // 1. 验证请求来源（防止恶意调用）
  const authHeader = request.headers.get("authorization");
  if (authHeader !== `Bearer ${process.env.REVALIDATION_SECRET}`) {
    return Response.json({ error: "Unauthorized" }, { status: 401 });
  }

  // 2. 解析要失效的标签
  const { tags } = await request.json();

  if (!tags || !Array.isArray(tags)) {
    return Response.json({ error: "tags is required" }, { status: 400 });
  }

  // 3. 逐个失效标签
  for (const tag of tags) {
    revalidateTag(tag, "max");
  }

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

# services/cache.py
import httpx
from config import settings

async def revalidate_nextjs_cache(tags: list[str]):
    """通知 Next.js 刷新指定标签的缓存"""
    async with httpx.AsyncClient() as client:
        try:
            response = await client.post(
                f"{settings.NEXTJS_URL}/api/revalidate",
                json={"tags": tags},
                headers={
                    "Authorization": f"Bearer {settings.REVALIDATION_SECRET}"
                },
                timeout=5.0,
            )
            response.raise_for_status()
            return response.json()
        except httpx.HTTPError as e:
            # 缓存刷新失败不应该阻塞业务逻辑
            # 记录日志，但不抛异常
            print(f"Cache revalidation failed: {e}")
            return None

# routers/posts.py
from fastapi import APIRouter, Depends
from services.cache import revalidate_nextjs_cache

router = APIRouter()

@router.post("/posts")
async def create_post(post: PostCreate, db: Session = Depends(get_db)):
    # 1. 写入数据库
    new_post = crud.create_post(db, post)

    # 2. 通知 Next.js 刷新缓存
    await revalidate_nextjs_cache(["posts"])

    return new_post

@router.put("/posts/{post_id}")
async def update_post(
    post_id: int, post: PostUpdate, db: Session = Depends(get_db)
):
    updated = crud.update_post(db, post_id, post)

    # 失效列表和详情的缓存
    await revalidate_nextjs_cache(["posts", f"post-{post_id}"])

    return updated

// service/CacheRevalidationService.java
@Service
public class CacheRevalidationService {

    private final WebClient webClient;

    @Value("${nextjs.url}")
    private String nextjsUrl;

    @Value("${nextjs.revalidation-secret}")
    private String revalidationSecret;

    public CacheRevalidationService(WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder.build();
    }

    public void revalidateCache(List<String> tags) {
        webClient.post()
            .uri(nextjsUrl + "/api/revalidate")
            .header("Authorization", "Bearer " + revalidationSecret)
            .bodyValue(Map.of("tags", tags))
            .retrieve()
            .bodyToMono(String.class)
            .doOnError(e -> log.warn("Cache revalidation failed: {}", e.getMessage()))
            .onErrorComplete()  // 不阻塞业务逻辑
            .subscribe();
    }
}

// service/PostService.java
@Service
public class PostService {

    private final PostRepository postRepository;
    private final CacheRevalidationService cacheService;

    public Post createPost(PostCreateRequest request) {
        Post post = postRepository.save(new Post(request));

        // 异步通知 Next.js 刷新缓存
        cacheService.revalidateCache(List.of("posts"));

        return post;
    }

    public Post updatePost(Long id, PostUpdateRequest request) {
        Post post = postRepository.findById(id)
            .orElseThrow(() -> new NotFoundException("Post not found"));

        post.update(request);
        postRepository.save(post);

        cacheService.revalidateCache(List.of("posts", "post-" + id));

        return post;
    }
}

// 列表页：粗粒度标签
fetch("/api/posts", {
  next: { tags: ["posts"] },
  cache: "force-cache",
});

// 详情页：粗 + 细粒度标签
fetch(`/api/posts/${id}`, {
  next: { tags: ["posts", `post-${id}`] },
  cache: "force-cache",
});

// 更新单篇文章：只失效该文章 + 列表
updateTag(`post-${id}`);
updateTag("posts");

// 默认不缓存（no-store），这行代码每次都会请求 API
const res = await fetch("/api/posts");

// 需要缓存时必须显式声明
const res = await fetch("/api/posts", {
  next: { tags: ["posts"] },
  cache: "force-cache",
});

// ❌ Next.js 16 已废弃单参数形式
revalidateTag("posts");

// ✅ 必须传 cacheLife profile
revalidateTag("posts", "max");

npm run build  # 查看 ○ 和 ƒ 标记
npm start      # 用生产模式测试

// next.config.ts — 大多数生产应用建议开启
const nextConfig = {
  experimental: {
    staleTimes: {
      dynamic: 30,
      static: 300,
    },
  },
};

// ========== 数据获取 ==========
fetch("/api/data");                                              // 不缓存（15+ 默认）
fetch("/api/data", { cache: "force-cache" });                    // 显式缓存
fetch("/api/data", { next: { tags: ["data"] }, cache: "force-cache" }); // 缓存 + 标签（推荐）
fetch("/api/data", { next: { revalidate: 3600 }, cache: "force-cache" }); // 缓存 + 定时

// ========== 缓存失效 ==========
updateTag("data");                        // Server Action：写后即读
revalidateTag("data", "max");             // Route Handler：stale-while-revalidate
revalidatePath("/page");                  // 按路径失效
revalidatePath("/blog/[slug]", "page");   // 失效动态路由的所有页面
revalidatePath("/", "layout");            // 失效整个站点

// ========== 页面级配置 ==========
export const dynamic = "force-dynamic";   // 强制动态
export const revalidate = 3600;           // 定时重新验证

// ========== 客户端 ==========
router.refresh();                         // 清除当前页面的路由器缓存