麻雀窝 Sparrow Zoo

跨域 SSO 下的用户信息共享与解耦:Context、职责边界与 token 重签

结合一次登录用户重构,说明跨域 SSO 中 token 即用户信息唯一载体,父子组件通过 Context 共享 LoginUser,HTTP 与 WebSocket 各司其职,修改头像后端重签 token 以守护数据一致。

前端与全栈工程师(涉及跨域登录、React Context、WebSocket 集成)发布于 更新于
用户信息共享与解耦LoginUserProviderContext · 单一数据源HTTP · Fetcher请求 / 响应WebSocket实时 / 握手avatar 重签 token → 数据一致
阅读目录

结论先行

跨域 SSO 里,用户信息以 token 为唯一载体,前端通过一个 Context 把同一份 LoginUser 分发给所有父子组件,而不是每个组件各自解码。这次重构把「读用户」收敛到 LoginUserProvider,把 HTTP(Fetcher/ChatApi)与 WebSocket(SparrowWebSocket)拆成两个职责清晰的通道,再让 MessageBroker 作为组装点接收 LoginUser 而非 token 本身。

一致性的落点在「重签」

因为头像等用户信息内嵌在 JWT 里,修改头像必须由后端重新签发一个包含新头像的 token,前端 setToken 覆盖后触发全局通知,父子组件才同步刷新。这解决的是本项目的凭据与展示一致性,不意味着后端签名校验、token 过期、跨站策略等可以省略。

一句话原则:传输层只碰 token 字符串,展示层只碰 LoginUser 对象,两者共享同一条 token、只解码一次、经 Context 广播。

问题背景

应用包含一个认证站(passport)和多个业务站(www / admin / chat / coder)。用户登录后拿到一个 JWT,前端把它存进跨域存储,再跳回业务页。业务页通过 CrosStorage 拿到 token,供 HTTP 请求和 WebSocket 握手使用。

早期问题是「用户信息从哪来」:Header 要显示头像和昵称,聊天页要拿 userId/category 建会话,头像编辑器要读当前头像——如果每个组件都自己 getToken + 解码,就会散落多份「取用户」的逻辑,头像改完更不知道如何让所有组件同步。

本次改动把这条链路收敛成一个可共享、可订阅的单一数据源,并把 HTTP / WebSocket 的职责拆开。下面先解释凭据模型,再讲共享、解耦与一致性。

涉及的关键角色
角色文件职责
LoginUserProvidercommon/lib/LoginUserProvider.tsx用 Context 分发用户,订阅 token 变化
CrosStoragecommon/lib/CrosStorage.ts跨域存储门面 + token 变更通知
Fetcher / ChatApicommon/lib/Fetcher.ts 等HTTP 请求,Authorization 头带 token
SparrowWebSocketcommon/lib/SparrowWebSocket.ts实时通道、握手鉴权、失败清理 token
MessageBrokersparrow-chat/lib/im/MessageBroker.ts组装 HTTP 与 WebSocket,接收 LoginUser

详细内容

凭据模型:token 就是用户信息的唯一载体

登录成功后,后端把用户信息直接编进 JWT 的 payload,前端不另存一份「用户对象」。要用的时候,从 token 解出用户信息:

code
static localize(token: string) {
  const decodeToken = decodeURIComponent(token);
  const parts: string[] = decodeToken.split('.');
  const body: string = parts[1];
  if (!body) return null;
  const userJson = atob(body);
  const userInfo = JSON.parse(userJson).body;
  return LoginUser.parseLoginJSON(userInfo);
}

解码得到的是一个 LoginUser,包含 userId、tenantId、category、nickName、avatar、expireAt 等字段。把用户信息内嵌进 token 有一个直接好处:头像、昵称、身份都跟着 token 走,不存在「昵称改了一份、头像还是旧的一份」的割裂——但代价是,任何会改变这些字段的操作(比如换头像),都必须回到后端重新签 token。

本地解码只用于展示

localize 只是把 token 里可读的字段取出来渲染界面,不能替代后端对签名、有效期和权限的校验。token 是否有效,最终由服务端说了算。

父子组件共享:LoginUserProvider 与 useLoginUser

顶层 layout.tsx 挂上 LoginUserProvider,Header、头像编辑器、聊天页等子组件通过 useLoginUser() 读到同一个 LoginUser。它只在 token 变化时重新加载,并把状态(loading / ready / error)一起暴露出来:

code
const load = useCallback(() => {
  storage.getCurrentUser().then((user) => {
    setState(user ? { user, status: 'ready' } : { user: null, status: 'error' });
  }).catch(() => setState({ user: null, status: 'error' }));
}, []);

useEffect(() => {
  load();
  const unsubscribe = CrosStorage.onTokenChange(load);
  return () => { unsubscribe(); storage.destroy(); };
}, [load]);

关键在 CrosStorage.onTokenChange:它把「登录 / 登出 / 换头像」这些会改变 token 的动作都变成一次广播,Provider 收到后重新 load,所有用 useLoginUser 的组件自然刷新。

useLoginUser 的三态
status含义典型处理
loading正在读取 token 并解码渲染骨架 / Loading
ready拿到了有效用户正常渲染头像、昵称、会话
error读不到或解码失败展示「读取失败」并给重试入口

相比之前聊天页自己 getToken + locateToken 再判断 visitor,现在子组件只声明「我要用户」,不再关心 token 从哪来、怎么解码。

分析:Fetcher 也能直接读上下文用户信息

这里有一个值得说清的分层问题。Fetcher 目前这样取凭据:

code
let token: string | null = null;
if (crosStorage) {
  token = await crosStorage.getToken();
}
const options: RequestInit = {
  method: 'GET',
  headers: { Authorization: token as string },
};

表面看,Fetcher 每次请求都重新 getToken,而 LoginUserProvider 已经把同一份 token 解成了 LoginUser 放在 Context 里——于是自然会产生「让 Fetcher 也直接读上下文用户信息,这样全部共享」的想法。

结论要分成两层看:

  1. 凭据层(token 字符串):Authorization 头、WebSocket 握手协议都必须携带原始 token 字符串,而不是解码后的对象。这一层 Fetcher 必须走 CrosStorage.getToken(),且 Fetcher 是静态类、不挂在组件树里,也调不了 useLoginUser() 这个 hook。
  2. 领域层(LoginUser 对象):真正需要「用户是谁、头像是什么、什么身份」的是组件。这一层已经由 LoginUserProvider 统一解码并分发,不该再让每个组件各自解码。
「全部共享」的本质是单一解码点,不是单一取用点

让所有地方都读同一份数据,不等于所有地方都读同一个 API。正确做法是:token 只解码一次、由 Context 广播;传输层(Fetcher / WebSocket)继续按需取 token 字符串,展示层(组件)从 Context 取 LoginUser。硬把 Fetcher 改成读 Context 用户对象,既拿不到能放进 Authorization 头的原始 token,也会把静态工具类跟 React 生命周期耦合在一起。

所以这次重构没有让 Fetcher 去读 Context,而是把「谁需要解码后的用户」这件事上提到 Provider,让传输层与展示层各取所需、互不越界。

HTTP 与 WebSocket 职责解耦

以前 MessageBroker 既要自己拿 token、解码用户,又要建 WebSocket、发 HTTP 请求,职责缠在一起。现在把「读用户」交给调用方(聊天组件从 Context 拿到 LoginUser),MessageBroker 只负责组装:

code
constructor(translator, redirectToLogin, loginUser: LoginUser) {
  this.translator = translator;
  this.currentUser = ChatUser.fromLoginUser(loginUser);
  this.contactContainer = new ContactContainer(translator, this.currentUser);
  this.sessionContainer = new SessionContainer(translator, this.contactContainer, this.currentUser);
  const sparrowWebSocket = new SparrowWebSocket(WEBSOCKET, translator);
  sparrowWebSocket.connect();
  this.webSocket = sparrowWebSocket;
}

WebSocket 自己负责握手时取 token 并放进子协议:

this.crosStorage.getToken(StorageType.AUTOMATIC).then((token) => {
  if (!token) { this.redirectLogin(); return; }
  this.ws = new WebSocket(this.url, [token as string]);
  this.onOpen(); this._onMsg(); this.onClose(); this.onError();
});
解耦后各层的单一职责
层负责不再负责
Fetcher / ChatApi请求-响应,Authorization 头带 token不负责解码用户、不管连接状态
SparrowWebSocket实时通道、握手鉴权、心跳重连、鉴权失败清 token不发 HTTP、不组装业务数据
MessageBroker把 HTTP 与 WebSocket 组装进 IM 语义不再自己取 token / 解码用户
LoginUserProvider读 token、解码 LoginUser、订阅变化不参与传输、不关心协议

WebSocket 鉴权失败时仍然自己收尾:userAuthCallback 在握手返回失败后 removeToken() 并跳登录,把「实时通道的凭据失效」闭环在通道层处理,HTTP 层不感知。

token 数据一致性:修改 avatar 重新签 token

既然用户信息(含头像)内嵌在 token 里,换头像就不能只改后端数据库——前端手里的旧 token 里还是旧头像,父/子组件和后续请求会读到不一致的用户信息。所以修改头像的接口返回的不只是新头像,还有一个重新签发的 token:

code
// uploader:上传图片 → 修改头像,返回 { avatar, token }
public static modifyUserAvatar(avatar: string, translator: Translator) {
  return Fetcher.post<ModifyAvatarResult>({ url: '/profile/modify-user-avatar.json', body: { avatar } });
}

头像编辑页拿到新 token 后覆盖本地凭据:

Uploader.uploadAvatar(base64, clientFileName, crop, t).then(({ token }) => {
  const storage = CrosStorage.getCrosStorage();
  storage.setToken(token).then(() => {
    toast.success(t('upload-success'));
    Navigations.redirectToIndex();
  }).finally(() => storage.destroy());
});

setToken 写入成功后会触发一次 token 变更通知,链路上所有订阅者(LoginUserProvider)重新加载,Header 头像、聊天页里的用户信息一起刷新到最新值:

public async setToken(token, storage = StorageType.AUTOMATIC, saveOptions?) {
  const mode = this.stores.resolve(storage);
  const result = await this.set(token, TOKEN_KEY, mode, saveOptions);
  CrosStorage.notifyTokenChange();
  return result;
}
重签是唯一的数据一致性落点

换头像这类会改变 token 内字段的操作,只有「后端重签 → 前端覆盖 → 全局通知刷新」这一条闭环,才能保证父组件、子组件、后续 HTTP/WebSocket 请求看到的是同一个用户。少了重签这一步,界面和请求就会各自为政。

边界与取舍:visitor、加载态与失效清理

这条链路还有几个必须处理好的边界:

边界场景与处理方式
场景处理说明
游客(visitor)user.isVisitor() 时走登录入口没有真实凭据也要有可识别的降级身份,不能当普通用户渲染
读不到 tokenstatus 置为 error,给重试按钮区分「尚未加载完」与「确实读不到」,避免白屏
鉴权失败WebSocket 侧 removeToken + 跳登录通道层的凭据失效就地闭环
组件卸载Provider cleanup 里 unsubscribe + destroy避免订阅泄漏、反复创建 CrosStorage 实例

这里的核心取舍是:把「身份」和「凭据」分开,但让它们指向同一个来源。传输层要的是凭据(token 字符串),展示层要的是身份(LoginUser),两者都从同一条 token 派生,只是取用方式不同。这样既避免了每个组件重复解码,又保住了 HTTP / WebSocket 各自的职责边界。

总结归纳

把用户信息收敛成单一数据源,再把传输与展示拆开。LoginUserProvider 用 Context 分发同一份 LoginUser,通过 CrosStorage.onTokenChange 订阅变化;组件统一 useLoginUser(),不再各自取 token、各自解码。

Fetcher 与 WebSocket 各司其职。HTTP 层只负责请求-响应、按需取 token 放进 Authorization 头;WebSocket 层只负责实时通道与握手鉴权;MessageBroker 作为组装点接收 LoginUser 而非 token。凭据层和领域层指向同一条 token,但取用方式不同。

一致性靠重签闭环。因为头像等字段内嵌在 JWT 里,改头像由后端重签新 token,前端 setToken 覆盖并触发全局刷新。下一步可继续补强:token 过期轮换、跨站登出广播,以及把传输层对 token 的校验(类型、长度、来源)做得更严。

参考资料

  1. React · createContext

    Context 的创建与 Provider 分发,本文共享用户信息的实现基础。

  2. React · useContext

    子组件读取 Context 值,对应 useLoginUser。

  3. React · useEffect

    订阅 token 变化与 cleanup 清理的生命周期。

  4. RFC 7519 · JSON Web Token

    JWT 的结构与 claims,用户信息内嵌 payload 的依据。

  5. MDN · Authorization

    HTTP 请求携带凭据的标准头。

  6. MDN · WebSocket

    实时通道、子协议(token 握手)与连接生命周期。

  7. MDN · fetch

    HTTP 请求封装,Fetcher 的底层实现。

  8. MDN · Window.postMessage

    跨域存储 RPC 的底层消息机制。