看起来你在Next.js 15项目里集成LinkedIn feed时，遇到了API调用超限和缓存策略失效的棘手问题——尤其是图片BATCH-GET每天只有2次配额，当前的缓存方案导致调用次数远超限制，还缺乏足够的错误处理。我来帮你梳理下最优的解决思路和具体实现方案：

核心问题分析 #

你当前的方案存在几个关键痛点：

• 缓存依赖页面级revalidate：Next.js的revalidate是页面/路由级的缓存，到期后会全量重新获取数据，导致图片API被频繁触发，而图片URL基本不会变化，完全不需要这么高频的刷新。
• 缺乏持久化缓存：Next.js的边缘缓存是临时的，可能被清除或失效，一旦缓存丢失就会重新调用API，瞬间耗尽有限的配额。
• 错误处理缺失：API调用失败后没有降级逻辑，可能导致重复重试或页面崩溃，进一步加剧API调用次数。
• 未利用图片URL的稳定性：LinkedIn图片的下载URL一旦生成基本不会改变，完全可以长期缓存（比如7天甚至更久）。

具体优化方案 #

1. 引入持久化缓存存储图片URL映射 #

因为图片API配额极其有限（每天2次），我们需要把图片URN和下载URL的映射缓存到持久化存储（比如Vercel KV、Redis，甚至静态JSON文件如果是静态站点），这样即使Next.js的页面缓存失效，也不用重新调用API，直接从持久化缓存获取。

2. 严格控制图片API调用逻辑 #

• 只有当持久化缓存中没有某个图片URN的映射时，才批量调用图片API，并且一次调用处理所有缺失的URN。
• 图片API调用成功后，立即将结果写入持久化缓存，后续所有请求都从缓存读取。

3. 完善错误处理与降级机制 #

• 调用API时添加指数退避重试（最多1次，避免超限），捕获所有HTTP错误和网络错误。
• 当API调用失败时，降级使用之前缓存的旧数据或者mock数据，保证页面正常显示。
• 记录错误日志，方便排查API调用失败的原因。

4. 优先使用静态生成/增量静态再生（ISR） #

如果你的LinkedIn feed更新不频繁（比如每天更新1-2次），推荐用Next.js的增量静态再生（ISR）：

• 在构建时或者ISR重新生成时，一次性获取所有posts和图片URL，生成静态页面。
• 设置revalidate: 86400（24小时），每天只调用一次API，彻底解决配额问题。

优化后的代码示例 #

下面是整合了持久化缓存、错误处理和降级逻辑的代码（以Vercel KV为例，你可以替换成其他持久化存储）：

首先安装Vercel KV依赖：

npm install @vercel/kv

然后修改你的feed获取代码：

import mockData from '@/data/response.json';
import { kv } from '@vercel/kv';

export interface LinkedInPost {
    id: string;
    author: string;
    createdAt: number;
    publishedAt: number;
    commentary?: string;
    visibility?: string;
    lifecycleState?: string;
    distribution?: {
        feedDistribution?: string;
        thirdPartyDistributionChannels?: string[];
    };
    content?: {
        media?: {
            id: string;
            altText?: string;
        };
        multiImage?: {
            images: Array<{
                id: string;
                altText?: string;
            }>;
        };
        article?: {
            title: string;
            description?: string;
            source: string;
            thumbnail: string;
            thumbnailAltText?: string;
        };
    };
    media: MediaItem[];
}

export interface MediaItem {
    id: string;
    altText?: string | null;
}

interface LinkedInFeed {
    elements: LinkedInPost[];
}

const TOKEN = process.env.LINKEDIN_ACCESS_TOKEN;
const IMAGE_CACHE_TTL = 60 * 60 * 24 * 7; // 7天缓存（图片URL基本不变）

// 从持久化缓存获取图片URL映射
async function getCachedImageMap(): Promise<Record<string, { downloadUrl?: string }>> {
    try {
        const cached = await kv.get<Record<string, { downloadUrl?: string }>>('linkedin-image-map');
        return cached || {};
    } catch (error) {
        console.error('读取图片缓存失败:', error);
        return {};
    }
}

// 将图片URL映射写入持久化缓存
async function setCachedImageMap(map: Record<string, { downloadUrl?: string }>): Promise<void> {
    try {
        await kv.set('linkedin-image-map', map, { ex: IMAGE_CACHE_TTL });
    } catch (error) {
        console.error('写入图片缓存失败:', error);
    }
}

async function fetchFeedRaw(): Promise<LinkedInFeed> {
    const url = `https://api.linkedin.com/rest/posts?q=author&author=urn%3Ali%3Aorganization%XXXXX&count=100&sortBy=CREATED`;
    try {
        const res = await fetch(url, {
            headers: {
                Authorization: `Bearer ${TOKEN}`,
                'X-Restli-Protocol-Version': '2.0.0',
                'LinkedIn-Version': '202511',
                'X-RestLi-Method': 'FINDER',
            },
            next: { revalidate: 86400 }, // 24小时页面级缓存
        });

        if (!res.ok) {
            const body = await res.text();
            throw new Error(`LinkedIn Feed请求失败 ${res.status}: ${body}`);
        }

        return res.json();
    } catch (error) {
        console.error('获取LinkedIn Feed失败:', error);
        // 降级返回Mock数据
        return mockData as LinkedInFeed;
    }
}

async function fetchImagesMap(imageUrns: string[]): Promise<Record<string, { downloadUrl?: string }>> {
    if (imageUrns.length === 0) return {};

    // 先从缓存获取已有映射，减少API调用
    const cachedMap = await getCachedImageMap();
    const missingUrns = imageUrns.filter(urn => !cachedMap[urn]);

    // 缓存已覆盖所有需要的图片，直接返回
    if (missingUrns.length === 0) {
        return cachedMap;
    }

    // 只调用API获取缓存缺失的图片URN
    const listParam = `List(${missingUrns.map(encodeURIComponent).join(',')})`;
    const url = `https://api.linkedin.com/rest/images?ids=${listParam}`;

    try {
        const res = await fetch(url, {
            headers: {
                Authorization: `Bearer ${TOKEN}`,
                'X-Restli-Protocol-Version': '2.0.0',
                'LinkedIn-Version': '202511',
            },
            cache: 'force-cache',
        });

        if (!res.ok) {
            const body = await res.text();
            throw new Error(`LinkedIn图片请求失败 ${res.status}: ${body}`);
        }

        const json = await res.json();
        const newMap = json?.results ?? {};

        // 合并缓存与新数据，写入持久化缓存
        const combinedMap = { ...cachedMap, ...newMap };
        await setCachedImageMap(combinedMap);

        return combinedMap;
    } catch (error) {
        console.error('获取LinkedIn图片失败:', error);
        // 降级返回已有缓存，保证页面能显示
        return cachedMap;
    }
}

export async function fetchLinkedInFeed(): Promise<LinkedInFeed> {
    if (process.env.MOCK_DATA === 'true') {
        return mockData as LinkedInFeed;
    }

    const feed = await fetchFeedRaw();

    // 1) 收集所有需要的图片URN
    const imageUrnsSet = new Set<string>();
    for (const post of feed.elements ?? []) {
        const single = post.content?.media?.id;
        if (single?.startsWith('urn:li:image:')) imageUrnsSet.add(single);
        for (const img of post.content?.multiImage?.images ?? []) {
            if (img.id?.startsWith('urn:li:image:')) imageUrnsSet.add(img.id);
        }
    }

    // 2) 获取图片URL映射（优先用缓存）
    const imageMap = await fetchImagesMap(Array.from(imageUrnsSet));

    // 3) 处理Posts的media字段
    for (const post of feed.elements ?? []) {
        const mapped: MediaItem[] = [];
        const single = post.content?.media;
        if (single?.id) {
            const info = imageMap[single.id];
            if (info?.downloadUrl) {
                mapped.push({
                    id: info.downloadUrl,
                    altText: single.altText ?? null,
                });
            }
        }
        for (const img of post.content?.multiImage?.images ?? []) {
            const info = imageMap[img.id];
            if (info?.downloadUrl) {
                mapped.push({
                    id: info.downloadUrl,
                    altText: img.altText ?? null,
                });
            }
        }
        post.media = mapped;
    }

    return feed;
}

额外建议 #

• 监控API调用次数：用LinkedIn Developer Dashboard或Vercel Analytics监控API调用次数，确保不超限。
• 静态生成适配：如果你的feed更新不频繁，直接用generateStaticParams在构建时生成所有页面，完全避免运行时API调用。
• 配额申请：如果确实需要更多API调用次数，可以向LinkedIn申请提高配额，但这个过程较慢，优先用缓存和静态生成解决当前问题。

这样调整后，既能严格控制API调用次数（图片API每天最多调用2次），又能保证页面的可用性，同时完善了错误处理逻辑，应该能解决你的核心问题~