如何处理令牌过期？Firebase用户令牌过期监听实现方法问询

我之前帮不少开发者解决过这类问题，你说的每次请求前手动校验令牌确实太繁琐了，完全是重复劳动——其实Firebase本身就提供了内置的身份状态监听机制，再配合统一的网络请求拦截，就能彻底摆脱重复代码，实现自动化的过期处理。

下面分几种场景给你具体的实现方案：

1. 用Firebase Auth的内置状态监听搞定核心逻辑 #

Firebase Auth自带的addStateDidChangeListener是处理这类问题的首选，它会自动监听用户的身份状态变化——包括令牌过期、用户登出、账号被禁用等情况。你只需要在App启动时注册一次这个监听，就能全局捕获身份失效事件，不用在每个请求里写校验代码。

举个iOS的实现例子（Swift）：

import FirebaseAuth

class AppDelegate: UIResponder, UIApplicationDelegate {
    var window: UIWindow?
    private var authStateListener: AuthStateDidChangeListenerHandle?

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        FirebaseApp.configure()
        
        // 注册Auth状态监听，全局生效
        authStateListener = Auth.auth().addStateDidChangeListener { [weak self] auth, user in
            guard let self = self else { return }
            
            if user == nil {
                // 用户身份失效（包含令牌过期），直接跳转到登录页
                self.navigateToLogin()
            } else {
                // 可选：提前检测令牌是否即将过期，主动刷新避免跳转
                user?.getIDTokenResult(completion: { tokenResult, error in
                    if let error = error {
                        self.navigateToLogin()
                    } else if let tokenResult = tokenResult, 
                              tokenResult.expirationDate.timeIntervalSinceNow < 300 { // 剩余时间不足5分钟
                        // 强制刷新令牌
                        user?.getIDTokenForcingRefresh(true) { _, refreshError in
                            if refreshError != nil {
                                self.navigateToLogin()
                            }
                        }
                    }
                })
            }
        }
        
        return true
    }
    
    private func navigateToLogin() {
        // 封装跳转逻辑，避免重复代码
        guard let loginVC = UIStoryboard(name: "Main", bundle: nil)
                .instantiateViewController(withIdentifier: "LoginViewController") as? LoginViewController else {
            return
        }
        window?.rootViewController = UINavigationController(rootViewController: loginVC)
        window?.makeKeyAndVisible()
    }
    
    func applicationWillTerminate(_ application: UIApplication) {
        // 移除监听，防止内存泄漏
        if let listener = authStateListener {
            Auth.auth().removeStateDidChangeListener(listener)
        }
    }
}

这个监听会在身份状态变化时自动触发，从根源上避免了重复校验的问题。

2. 统一网络拦截器处理请求层面的令牌问题 #

如果你的APP用了统一的网络客户端（比如Alamofire），可以添加一个请求拦截器，自动处理令牌的添加、刷新，以及401错误（令牌过期的典型返回码）。这样即使偶尔出现监听没捕获到的情况，也能在请求层面兜底处理。

比如用Alamofire的RequestAdapter和RequestRetrier实现：

import Alamofire
import FirebaseAuth

class FirebaseTokenInterceptor: RequestAdapter, RequestRetrier {
    func adapt(_ urlRequest: URLRequest, for session: Session, completion: @escaping (Result<URLRequest, Error>) -> Void) {
        guard let user = Auth.auth().currentUser else {
            // 无用户，返回错误，后续处理跳转
            let authError = NSError(domain: "AuthError", code: 401, 
                                   userInfo: [NSLocalizedDescriptionKey: "用户未登录"])
            completion(.failure(authError))
            return
        }
        
        // 获取当前令牌（自动缓存，未过期直接返回）
        user.getIDTokenForcingRefresh(false) { token, error in
            if let error = error {
                completion(.failure(error))
            } else if let token = token {
                var adaptedRequest = urlRequest
                adaptedRequest.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
                completion(.success(adaptedRequest))
            }
        }
    }
    
    func retry(_ request: Request, for session: Session, dueTo error: Error, completion: @escaping (RetryResult) -> Void) {
        // 检查是否是401错误（令牌过期）
        guard let response = request.task?.response as? HTTPURLResponse, 
              response.statusCode == 401 else {
            completion(.doNotRetry)
            return
        }
        
        // 尝试强制刷新令牌
        Auth.auth().currentUser?.getIDTokenForcingRefresh(true) { _, refreshError in
            if refreshError == nil {
                // 刷新成功，重试当前请求
                completion(.retry)
            } else {
                // 刷新失败，跳转到登录页
                DispatchQueue.main.async {
                    let loginVC = UIStoryboard(name: "Main", bundle: nil)
                            .instantiateViewController(withIdentifier: "LoginViewController") as! LoginViewController
                    UIApplication.shared.windows.first?.rootViewController = UINavigationController(rootViewController: loginVC)
                }
                completion(.doNotRetry)
            }
        }
    }
}

然后初始化Alamofire Session时用上这个拦截器：

let networkSession = Session(interceptor: FirebaseTokenInterceptor())

这样所有通过这个Session发送的请求都会自动处理令牌相关的问题，不用在每个请求里重复写逻辑。

3. 全局通知配合复杂架构（可选） #

如果你的APP架构比较复杂，多个页面或组件需要响应令牌过期事件（比如清空本地缓存、终止正在进行的任务），可以在监听触发时发送全局通知：

在Auth状态监听里添加：

if user == nil {
    NotificationCenter.default.post(name: .tokenExpired, object: nil)
    self.navigateToLogin()
}

先扩展一下Notification.Name：

extension Notification.Name {
    static let tokenExpired = Notification.Name("TokenExpiredNotification")
}

然后在需要响应的组件里注册通知：

override func viewDidLoad() {
    super.viewDidLoad()
    NotificationCenter.default.addObserver(self, 
                                         selector: #selector(handleTokenExpired), 
                                         name: .tokenExpired, 
                                         object: nil)
}

@objc private func handleTokenExpired() {
    // 做一些清理工作，比如清空本地用户缓存、停止后台任务
    UserDefaults.standard.removeObject(forKey: "UserProfile")
}

deinit {
    NotificationCenter.default.removeObserver(self)
}

几个关键注意点： #

• 内存泄漏：一定要在合适的时机移除Auth状态监听和Notification监听（比如App终止、页面销毁时），避免内存泄漏。
• 提前刷新令牌：通过getIDTokenForcingRefresh(true)主动刷新即将过期的令牌，能避免用户在操作过程中突然跳转登录，提升体验。
• 统一跳转逻辑：把跳转登录的代码封装成全局方法，不要在多个地方重复写。

这样一套组合拳下来，你就能彻底摆脱逐请求校验的繁琐，实现优雅的令牌过期自动处理。

内容的提问来源于stack exchange，提问作者Toma Radu-Petrescu