Backoff 退避策略是什麼？Exponential Backoff 指數退避完整教學

function fullJitterDelay(n, base = 1000, maxDelay = 30000) {
  const exponentialDelay = base * Math.pow(2, n);
  const cappedDelay = Math.min(exponentialDelay, maxDelay);
  return Math.random() * cappedDelay; // 在 0 到上限之間隨機取值
}

function equalJitterDelay(n, base = 1000, maxDelay = 30000) {
  const exponentialDelay = base * Math.pow(2, n);
  const cappedDelay = Math.min(exponentialDelay, maxDelay);
  const halfDelay = cappedDelay / 2;
  return halfDelay + Math.random() * halfDelay; // 在 delay/2 到 delay 之間
}

// fetchWithBackoff：帶指數退避 + Full Jitter 的 fetch 封裝
// 使用方式和 fetch() 完全相同，只是加了自動重試邏輯

async function fetchWithBackoff(url, options = {}, retryOptions = {}) {
  const {
    maxRetries = 3,       // 最大重試次數
    baseDelay = 1000,     // 基礎延遲（毫秒）
    maxDelay = 30000,     // 最大延遲上限（毫秒）
    retryOn = [500, 502, 503, 504, 429], // 哪些 HTTP 狀態碼才重試
  } = retryOptions;

  // 計算帶 Full Jitter 的指數退避延遲
  function calculateDelay(attempt) {
    const exponentialDelay = baseDelay * Math.pow(2, attempt);
    const cappedDelay = Math.min(exponentialDelay, maxDelay);
    return Math.random() * cappedDelay; // Full Jitter
  }

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

  let lastError = null;

  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);

      // 成功回應（2xx）直接回傳
      if (response.ok) {
        return response;
      }

      // 判斷這個狀態碼是否需要重試
      if (!retryOn.includes(response.status)) {
        // 4xx 錯誤（除了 429）通常是客戶端問題，不重試
        throw new Error(`請求失敗（${response.status}），不重試`);
      }

      // 需要重試的伺服器錯誤
      lastError = new Error(`伺服器回應錯誤：${response.status}`);

      // 如果是最後一次嘗試，直接拋出錯誤
      if (attempt === maxRetries) {
        throw lastError;
      }

      // 特殊處理 429 Rate Limiting：優先使用 Retry-After 標頭
      const retryAfter = response.headers.get('Retry-After');
      const delay = retryAfter
        ? parseInt(retryAfter, 10) * 1000  // Retry-After 是秒，轉為毫秒
        : calculateDelay(attempt);

      console.warn(
        `第 ${attempt + 1} 次請求失敗（${response.status}），` +
        `${Math.round(delay / 1000)} 秒後重試...`
      );
      await sleep(delay);

    } catch (error) {
      // 網路錯誤（斷線、DNS 失敗等）
      lastError = error;

      if (attempt === maxRetries) {
        throw new Error(`已達最大重試次數（${maxRetries}），最後錯誤：${error.message}`);
      }

      // 如果是我們主動拋出的「不重試」錯誤，直接往上拋
      if (error.message.includes('不重試')) {
        throw error;
      }

      const delay = calculateDelay(attempt);
      console.warn(
        `第 ${attempt + 1} 次請求發生網路錯誤，` +
        `${Math.round(delay / 1000)} 秒後重試...`,
        error.message
      );
      await sleep(delay);
    }
  }

  throw lastError;
}

// 使用範例
async function fetchUserData(userId) {
  try {
    const response = await fetchWithBackoff(
      `/api/users/${userId}`,
      {
        method: 'GET',
        headers: { 'Content-Type': 'application/json' },
      },
      {
        maxRetries: 3,
        baseDelay: 1000,
        maxDelay: 15000,
        retryOn: [500, 502, 503, 504, 429],
      }
    );

    const data = await response.json();
    console.log('使用者資料：', data);
    return data;

  } catch (error) {
    console.error('取得使用者資料失敗：', error.message);
    throw error;
  }
}

// 呼叫
fetchUserData(123);

npm install axios-retry

import axios from 'axios';
import axiosRetry from 'axios-retry';

// 配置 Axios 實例
const instance = axios.create({
  baseURL: 'https://api.example.com',
});

// 設定 axios-retry 的配置
axiosRetry(instance, {
  retries: 3, // 重試次數
  retryDelay: axiosRetry.exponentialDelay, // 退避策略，使用指數退避
  retryCondition: (error) => {
    // 在此處添加自定義的重試條件，例如只在特定錯誤碼時重試
    return axiosRetry.isNetworkError(error) || (error.response && error.response.status === 500);
  },
});

// 使用 Axios 實例進行請求
instance.get('/data')
  .then(response => {
    console.log(response.data);
  })
  .catch(error => {
    console.error(error.message);
  });

axiosRetry(instance, {
  // 最多重試 4 次
  retries: 4,

  // 使用指數退避（內建選項）
  // axiosRetry.exponentialDelay 會產生 100ms, 200ms, 400ms... 的延遲
  retryDelay: (retryCount) => {
    // 自定義延遲：加入 Jitter
    const delay = axiosRetry.exponentialDelay(retryCount);
    const jitter = Math.random() * 500; // 加入最多 500ms 的隨機抖動
    return delay + jitter;
  },

  // 重試條件：哪些情況下要重試
  retryCondition: (error) => {
    // 網路錯誤（斷線）
    if (axiosRetry.isNetworkError(error)) return true;

    // 冪等請求（GET、HEAD）的超時也重試
    if (axiosRetry.isIdempotentRequestError(error)) return true;

    // 5xx 伺服器錯誤重試
    if (error.response && error.response.status >= 500) return true;

    // 429 Rate Limiting 重試
    if (error.response && error.response.status === 429) return true;

    return false;
  },

  // 在每次重試前執行的回呼（可用於記錄 log）
  onRetry: (retryCount, error, requestConfig) => {
    console.warn(`重試第 ${retryCount} 次：`, requestConfig.url, error.message);
  },
});

// 取得商品詳情，最多重試 3 次
async function getProductDetails(productId) {
  return fetchWithBackoff(
    `https://api.shop.com/products/${productId}`,
    { headers: { Authorization: `Bearer ${token}` } },
    { maxRetries: 3, baseDelay: 500 }
  );
}

async function connectWithBackoff(dbClient, maxRetries = 5) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      await dbClient.connect();
      console.log('資料庫連線成功');
      return;
    } catch (error) {
      const delay = Math.min(1000 * Math.pow(2, i), 30000);
      console.warn(`資料庫連線失敗，${delay / 1000} 秒後重試...`);
      await new Promise(r => setTimeout(r, delay));
    }
  }
  throw new Error('無法連線到資料庫');
}

// 送出付款請求，加入重試保護
async function processPayment(paymentData) {
  return fetchWithBackoff(
    'https://payment-gateway.com/api/charge',
    {
      method: 'POST',
      body: JSON.stringify(paymentData),
      headers: { 'Content-Type': 'application/json' },
    },
    {
      maxRetries: 2, // 金流敏感，重試次數保守一些
      baseDelay: 2000,
      retryOn: [503, 504], // 只在明確的伺服器故障時重試，不包含 500（避免重複扣款）
    }
  );
}

// fetchWithBackoff 已內建處理 Retry-After 標頭（見上方原生實作）
// 當伺服器回傳：
// HTTP/1.1 429 Too Many Requests
// Retry-After: 60
// 函式會自動等待 60 秒後重試，而不是使用指數退避

async function callOpenAI(prompt) {
  return fetchWithBackoff(
    'https://api.openai.com/v1/chat/completions',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ model: 'gpt-4', messages: [{ role: 'user', content: prompt }] }),
    },
    { maxRetries: 3, retryOn: [429, 500, 503] }
  );
}