🚀 API调用最佳实践指南

// 使用p-limit控制并发请求数量
const pLimit = require('p-limit');
const limit = pLimit(5); // 最多5个并发请求

const requests = urls.map(url =>
  limit(() => fetchAPI(url))
);

const results = await Promise.all(requests);

// 使用AbortController实现超时控制
const fetchWithTimeout = async (url, options = {}, timeout = 8000) => {
  const controller = new AbortController();
  const timeoutId = setTimeout(() => {
    controller.abort();
  }, timeout);

  try {
    const response = await fetch(url, {
      ...options,
      signal: controller.signal
    });
    clearTimeout(timeoutId);
    return response;
  } catch (error) {
    clearTimeout(timeoutId);
    if (error.name === 'AbortError') {
      throw new Error('请求超时');
    }
    throw error;
  }
};

// 完整的错误处理示例
async function callAPI(endpoint, data) {
  try {
    const response = await axios.post(endpoint, data, {
      timeout: 10000,
      headers: { 'Content-Type': 'application/json' }
    });

    return response.data;
  } catch (error) {
    if (error.response) {
      // 服务器返回了错误状态码
      const status = error.response.status;
      if (status === 429) {
        throw new Error('请求过于频繁，请稍后重试');
      } else if (status >= 500) {
        throw new Error('服务器内部错误，请稍后重试');
      } else if (status === 401) {
        throw new Error('认证失败，请检查API密钥');
      }
    } else if (error.request) {
      // 请求已发出但没有收到响应
      throw new Error('网络连接失败，请检查网络设置');
    } else {
      // 请求配置出错
      throw new Error('请求配置错误：' + error.message);
    }
  }
}

// 带指数退避和抖动的重试机制
async function retryRequest(fn, maxRetries = 3) {
  let lastError;

  for (let i = 0; i <= maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      lastError = error;

      // 判断是否应该重试
      if (!shouldRetry(error, i, maxRetries)) {
        throw error;
      }

      // 计算退避时间：2^i + 随机抖动
      const backoff = Math.pow(2, i) * 1000;
      const jitter = Math.random() * 1000;
      const delay = Math.min(backoff + jitter, 10000);

      console.log(`重试 ${i + 1}/${maxRetries}，等待 ${Math.round(delay)}ms`);
      await sleep(delay);
    }
  }

  throw lastError;
}

function shouldRetry(error, attempt, maxRetries) {
  if (attempt >= maxRetries) return false;

  // 网络错误或5xx错误可重试
  if (!error.response) return true;
  const status = error.response.status;
  return status === 429 || status >= 500;
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// 使用异步队列控制并发
class ConcurrentQueue {
  constructor(maxConcurrent = 3) {
    this.maxConcurrent = maxConcurrent;
    this.running = 0;
    this.queue = [];
  }

  async add(task) {
    return new Promise((resolve, reject) => {
      this.queue.push({
        task,
        resolve,
        reject
      });
      this.run();
    });
  }

  async run() {
    if (this.running >= this.maxConcurrent || this.queue.length === 0) {
      return;
    }

    this.running++;
    const { task, resolve, reject } = this.queue.shift();

    try {
      const result = await task();
      resolve(result);
    } catch (error) {
      reject(error);
    } finally {
      this.running--;
      this.run();
    }
  }
}

// 使用示例
const queue = new ConcurrentQueue(3);
const requests = urls.map(url =>
  queue.add(() => fetchAPI(url))
);
const results = await Promise.all(requests);

// 使用Node-cache实现内存缓存
const NodeCache = require('node-cache');
const cache = new NodeCache({
  stdTTL: 300, // 默认缓存5分钟
  checkperiod: 60 // 每分钟检查过期缓存
});

async function fetchWithCache(key, fetchFn, ttl = 300) {
  // 尝试从缓存读取
  const cached = cache.get(key);
  if (cached) {
    console.log('Cache hit:', key);
    return cached;
  }

  // 缓存未命中，调用API
  console.log('Cache miss:', key);
  const data = await fetchFn();

  // 写入缓存
  cache.set(key, data, ttl);

  return data;
}

// 使用示例
const getUser = (userId) =>
  fetchWithCache(`user:${userId}`, async () => {
    const response = await axios.get(`/api/users/${userId}`);
    return response.data;
  });

// 结构化日志示例
const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  transports: [
    new winston.transports.File({ filename: 'api-error.log', level: 'error' }),
    new winston.transports.File({ filename: 'api-combined.log' })
  ]
});

async function loggedAPIRequest(url, options) {
  const requestId = generateUUID();
  const startTime = Date.now();

  try {
    logger.info('API请求开始', {
      requestId,
      url,
      method: options.method,
      timestamp: new Date().toISOString()
    });

    const response = await fetch(url, options);
    const duration = Date.now() - startTime;

    logger.info('API请求成功', {
      requestId,
      status: response.status,
      duration,
      timestamp: new Date().toISOString()
    });

    return response;
  } catch (error) {
    const duration = Date.now() - startTime;

    logger.error('API请求失败', {
      requestId,
      error: error.message,
      stack: error.stack,
      duration,
      timestamp: new Date().toISOString()
    });

    throw error;
  }
}