当前位置：首页 > article >正文

双 Token 无感刷新机制在前后端分离架构中实现

article 2025/3/15 8:49:28

在前后端分离的架构中，双 Token 无感刷新是一种常见的身份验证机制，用于在 Access Token 过期时，通过 Refresh Token 自动获取新的 Access Token，从而避免用户频繁登录。

1. 双 Token 无感刷新的核心流程

1.1 核心流程

用户登录：
- 前端发送用户名和密码到后端。
- 后端验证成功后，返回 Access Token 和 Refresh Token。
- 前端将这两个 Token 存储在本地（如 localStorage 或 Cookie）。
Access Token 过期：
- 前端发起请求时，携带 Access Token。
- 如果 Access Token 过期，后端返回 401 Unauthorized 错误。
自动刷新 Token：
- 前端检测到 401 错误后，使用 Refresh Token 请求新的 Access Token。
- 后端验证 Refresh Token 的有效性，如果有效，返回新的 Access Token。
- 前端更新本地存储的 Access Token，并重试之前的请求。
Refresh Token 过期：
- 如果 Refresh Token 也过期，后端返回 401 错误。
- 前端清除本地存储的 Token，并跳转到登录页面。

2. 前端实现（React + TypeScript）

2.1 配置 Axios 拦截器

Axios 拦截器用于在请求发送前和响应返回后执行逻辑，是实现无感刷新的核心。

import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse, AxiosError } from 'axios';

// 创建 Axios 实例
const api: AxiosInstance = axios.create({
  baseURL: 'https://your-api-url.com',
  headers: {
    'Content-Type': 'application/json',
  },
});

// 请求拦截器：在请求头中添加 Access Token
api.interceptors.request.use(
  (config: AxiosRequestConfig) => {
    const accessToken = localStorage.getItem('accessToken');
    if (accessToken) {
      config.headers.Authorization = `Bearer ${accessToken}`;
    }
    return config;
  },
  (error: AxiosError) => {
    return Promise.reject(error);
  }
);

// 响应拦截器：处理 Access Token 过期
api.interceptors.response.use(
  (response: AxiosResponse) => {
    return response;
  },
  async (error: AxiosError) => {
    const originalRequest = error.config;

    // 检测到 401 错误且未重试过
    if (error.response?.status === 401 && !originalRequest._retry) {
      originalRequest._retry = true; // 标记请求已重试

      try {
        // 使用 Refresh Token 获取新的 Access Token
        const refreshToken = localStorage.getItem('refreshToken');
        const response = await axios.post('https://your-api-url.com/refresh-token', { refreshToken });
        const { accessToken } = response.data;

        // 更新本地存储的 Access Token
        localStorage.setItem('accessToken', accessToken);
        api.defaults.headers.common['Authorization'] = `Bearer ${accessToken}`;
        originalRequest.headers['Authorization'] = `Bearer ${accessToken}`;

        // 重试原始请求
        return api(originalRequest);
      } catch (refreshError) {
        // 刷新 Token 失败，清除本地存储并跳转到登录页
        localStorage.removeItem('accessToken');
        localStorage.removeItem('refreshToken');
        window.location.href = '/login';
        return Promise.reject(refreshError);
      }
    }

    return Promise.reject(error);
  }
);

export default api;

2.2 使用 React Context 管理 Token 状态

通过 React Context 管理 Token 的状态，方便在组件中共享和更新。

import React, { createContext, useContext, useState, useEffect } from 'react';

interface AuthContextType {
  accessToken: string | null;
  refreshToken: string | null;
  setTokens: (accessToken: string, refreshToken: string) => void;
  clearTokens: () => void;
}

const AuthContext = createContext<AuthContextType | undefined>(undefined);

export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
  const [accessToken, setAccessToken] = useState<string | null>(localStorage.getItem('accessToken'));
  const [refreshToken, setRefreshToken] = useState<string | null>(localStorage.getItem('refreshToken'));

  const setTokens = (accessToken: string, refreshToken: string) => {
    localStorage.setItem('accessToken', accessToken);
    localStorage.setItem('refreshToken', refreshToken);
    setAccessToken(accessToken);
    setRefreshToken(refreshToken);
  };

  const clearTokens = () => {
    localStorage.removeItem('accessToken');
    localStorage.removeItem('refreshToken');
    setAccessToken(null);
    setRefreshToken(null);
  };

  return (
    <AuthContext.Provider value={{ accessToken, refreshToken, setTokens, clearTokens }}>
      {children}
    </AuthContext.Provider>
  );
};

export const useAuth = () => {
  const context = useContext(AuthContext);
  if (!context) {
    throw new Error('useAuth must be used within an AuthProvider');
  }
  return context;
};

2.3 在组件中使用

在需要身份验证的组件中，使用 useAuth Hook 获取和更新 Token。

import React from 'react';
import { useAuth } from './AuthContext';
import api from './api';

const ProtectedComponent: React.FC = () => {
  const { accessToken, setTokens, clearTokens } = useAuth();

  const fetchData = async () => {
    try {
      const response = await api.get('/protected-resource');
      console.log(response.data);
    } catch (error) {
      console.error('Failed to fetch data', error);
    }
  };

  return (
    <div>
      <button onClick={fetchData}>Fetch Data</button>
      <button onClick={clearTokens}>Logout</button>
    </div>
  );
};

export default ProtectedComponent;

3. 后端实现（Node.js + Express）

3.1 登录接口

登录成功后返回 Access Token 和 Refresh Token。

const express = require('express');
const jwt = require('jsonwebtoken');
const app = express();

app.use(express.json());

const SECRET_KEY = 'your-secret-key';
const REFRESH_SECRET_KEY = 'your-refresh-secret-key';

app.post('/login', (req, res) => {
  const { username, password } = req.body;

  // 模拟用户验证
  if (username === 'admin' && password === 'password') {
    const accessToken = jwt.sign({ username }, SECRET_KEY, { expiresIn: '15m' });
    const refreshToken = jwt.sign({ username }, REFRESH_SECRET_KEY, { expiresIn: '7d' });

    res.json({ accessToken, refreshToken });
  } else {
    res.status(401).json({ message: 'Invalid credentials' });
  }
});

3.2 刷新 Token 接口

验证 Refresh Token 并返回新的 Access Token。

app.post('/refresh-token', (req, res) => {
  const { refreshToken } = req.body;

  if (!refreshToken) {
    return res.status(401).json({ message: 'Refresh token is required' });
  }

  try {
    const decoded = jwt.verify(refreshToken, REFRESH_SECRET_KEY);
    const accessToken = jwt.sign({ username: decoded.username }, SECRET_KEY, { expiresIn: '15m' });
    res.json({ accessToken });
  } catch (error) {
    res.status(401).json({ message: 'Invalid refresh token' });
  }
});