Service Worker架构：高效动态认证令牌管理与网络请求同步

// 模拟异步获取认证令牌的函数
// 实际应用中，这里会发起网络请求到认证服务
async function fetchAuthToken() {
  console.log('正在获取新的认证令牌...');
  return new Promise(resolve => {
    setTimeout(() => {
      const newToken = `Bearer_TOKEN_${Date.now()}`; // 模拟生成新令牌
      console.log('令牌已获取:', newToken);
      resolve(newToken);
    }, 1500); // 模拟网络延迟
  });
}

// 定义一个变量来持有当前有效的（或正在获取中的）令牌Promise
let currentTokenPromise = null;

// 用于初始化和刷新令牌的函数
async function initializeOrRefreshToken() {
  currentTokenPromise = fetchAuthToken(); // 将变量指向一个新的令牌Promise
  try {
    await currentTokenPromise; // 等待新令牌获取完成
    console.log('令牌刷新成功。');
  } catch (error) {
    console.error('令牌刷新失败:', error);
    // 可以在这里处理刷新失败的情况，例如重置currentTokenPromise为null
    // 或者返回一个拒绝的Promise以通知后续请求
    throw error; // 向上抛出错误
  }
}

// 首次启动时获取令牌
initializeOrRefreshToken();

// 设置定时器，每隔15分钟刷新一次令牌
const TOKEN_REFRESH_INTERVAL = 15 * 60 * 1000; // 15分钟
setInterval(() => {
  console.log('定时器触发，准备刷新令牌...');
  initializeOrRefreshToken(); // 调用刷新函数
}, TOKEN_REFRESH_INTERVAL);

// 封装网络请求，确保使用最新的认证令牌
async function makeAuthenticatedRequest(url, options = {}) {
  try {
    console.log(`请求 ${url} 发起，等待令牌...`);
    // 等待当前currentTokenPromise解析，确保获取到最新令牌
    const token = await currentTokenPromise;
    console.log(`使用令牌 ${token.substring(0, 20)}... 发送请求到 ${url}`);

    const headers = {
      ...options.headers,
      'Authorization': token
    };

    return fetch(url, { ...options, headers });
  } catch (error) {
    console.error(`向 ${url} 发送认证请求失败:`, error);
    // 可以在这里进一步处理错误，例如返回一个自定义错误响应
    throw error;
  }
}

// 示例：在Service Worker的fetch事件中使用
/*
self.addEventListener('fetch', event => {
  const request = event.request;
  // 假设所有到 /api/ 的请求都需要认证
  if (request.url.includes('/api/')) {
    event.respondWith(
      makeAuthenticatedRequest(request.url, {
        method: request.method,
        body: request.body,
        headers: Object.fromEntries(request.headers.entries())
      })
      .catch(error => {
        // 当认证或请求失败时，返回一个适当的错误响应
        return new Response('Authentication required or network error', { status: 401 });
      })
    );
  } else {
    // 对于不需要认证的请求，直接转发
    event.respondWith(fetch(request));
  }
});
*/

let currentTokenPromise = null;
let refreshTimeoutId = null; // 用于管理定时器ID

async function fetchAuthTokenRobust() {
  console.log('正在尝试获取认证令牌...');
  try {
    const token = await fetchAuthToken(); // 调用原始的获取令牌函数
    currentTokenPromise = Promise.resolve(token); // 成功则更新为已解决的Promise
    scheduleNextRefresh(); // 成功后才安排下一次刷新
    return token;
  } catch (error) {
    console.error('获取令牌失败:', error);
    currentTokenPromise = null; // 失败则重置为null，等待下次请求触发重试
    throw error; // 向上抛出错误
  }
}

function scheduleNextRefresh() {
  if (refreshTimeoutId) {
    clearTimeout(refreshTimeoutId); // 清除任何现有的定时器
  }
  refreshTimeoutId = setTimeout(() => {
    console.log('定时器触发，准备刷新令牌...');
    fetchAuthTokenRobust(); // 重新获取令牌
  }, TOKEN_REFRESH_INTERVAL);
}

// 首次启动时立即获取令牌
fetchAuthTokenRobust();

async function makeAuthenticatedRequestRobust(url, options = {}) {
  // 如果currentTokenPromise为null，说明令牌尚未获取或已失效，需要重新获取
  if (!currentTokenPromise) {
    console.log('令牌不可用或已过期，尝试重新获取...');
    try {
      await fetchAuthTokenRobust(); // 强制获取新令牌，并等待其完成
    } catch (error) {
      console.error('重新获取令牌失败，无法发送认证请求。');
      throw new Error('Authentication token unavailable.'); // 抛出明确错误
    }
  }

  try {
    const token = await currentTokenPromise; // 等待当前有效的tokenPromise解析
    const headers = {
      ...options.headers,
      'Authorization': token
    };
    return fetch(url, { ...options, headers });
  } catch (error) {
    console.error(`向 ${url} 发送认证请求失败 (令牌可能已失效或网络错误):`, error);
    // 可以在这里进一步处理，例如重定向到登录页或返回一个特定的错误响应
    throw error;
  }
}