多端统一登录与跨业务授权实践 Demo:从登录页设计到博客账号打通工具站

2026-08-03后端20 分钟195 次阅读
AI 摘要鱼粮不足,AI 今天先歇着 · 正文在下面

前言

最开始,系统的登录入口分散在多个地方:

  • 小程序使用微信登录;
  • 工具网站使用邮箱密码或邮箱验证码登录;
  • 博客服务有自己的一套登录态;
  • 宠物服务和壁纸服务还会使用不同的业务标识;
  • 用户在不同端之间无法自然地切换身份。

这种设计在早期可以快速上线,但随着业务增加,会出现几个明显问题:

  1. 用户需要重复注册多个账号;
  2. 同一个用户在不同业务线下的资料无法关联;
  3. 微信登录后没有邮箱,无法在 Web 端继续使用;
  4. 邮箱验证码首次登录时自动创建账号,却没有可靠的首次密码更新流程;
  5. 工具网站如果直接读取博客网站的 Token,会带来严重的跨域和安全风险;
  6. 登录页面只关注“接口能不能调通”,没有考虑用户对隐私、密码、验证码和账号绑定的理解成本。

因此,这次改造的目标不是简单增加几个登录按钮,而是建立一套统一且可扩展的身份流程:

text 复制代码
用户
 │
 ├── 微信登录
 │     └── 检查邮箱
 │           ├── 已绑定:进入业务
 │           └── 未绑定:邮箱验证码绑定
 │
 ├── 邮箱验证码登录
 │     ├── 已有账号:直接登录
 │     └── 没有账号:自动创建 + 首次更新密码
 │
 ├── 邮箱注册
 │     └── 邮箱验证码 + 中等以上强度密码
 │
 └── 博客账号登录工具站
       ├── 已有关联工具账号:签发工具 Token
       └── 没有关联工具账号:返回一次性授权码
             ├── 验证已有工具账号邮箱
             └── 注册工具账号后确认关联

本文中的“统一登录”并不等于所有业务线共用同一个 Token。更准确的说法是:

统一用户身份,隔离业务登录态。

博客账号和工具账号可以属于同一个全局用户,但每条业务线仍然拥有自己的登录凭据和 Token。

系统整体架构图

下面用一个通用 Demo 展示各组件之间的关系:

flowchart LR U[用户] M[示例小程序] T[示例工具站] B[示例博客站] A[统一认证服务] R[(Redis)] DB[(用户与业务账号数据库)] E[邮件服务] U --> M U --> T U --> B M --> A T --> A B --> A A --> DB A --> R A --> E B -. "postMessage 只回传授权结果" .-> T

图中最重要的边界是:

  • 示例博客站只持有博客业务 Token;
  • 示例工具站只持有工具业务 Token;
  • 两个站点之间不读取对方的 localStorage;
  • 跨站通信只传递后端生成的目标业务 Token 或一次性授权码;
  • Redis 只保存短期验证码和授权上下文。

统一登录决策流程图

flowchart TD S([开始登录]) --> C{选择登录方式} C --> W[微信登录] C --> E[邮箱验证码登录] C --> R[邮箱注册] C --> B[示例博客授权登录] W --> W1[服务端换取登录态] W1 --> I[查询当前用户信息] E --> E1[校验邮箱与验证码] E1 --> E2{账号是否存在} E2 -->|是| L[签发业务 Token] E2 -->|否| N[创建账号并标记首次登录] N --> P[强制更新密码] R --> R1[校验邮箱验证码] R1 --> R2[校验中等以上密码] R2 --> L B --> B1[博客完成登录并发起授权] B1 --> B2{是否已关联目标业务账号} B2 -->|是| L2[签发目标业务 Token] B2 -->|否| Q[返回一次性授权码] W --> I I --> I1{是否绑定邮箱} I1 -->|是| L I1 -->|否| M1[进入强制绑定邮箱] M1 --> M2[邮箱格式校验] M2 --> M3[发送验证码] M3 --> M4[校验验证码并绑定] M4 --> L L --> F([进入业务页面]) P --> F L2 --> F Q --> Q1[绑定已有账号或注册后确认] Q1 --> F

一、先设计清楚账号模型

1. 业务账号和全局用户不是一回事

在多业务系统中,建议至少区分三层概念:

概念 作用
全局用户 表示现实中的同一个用户
业务账号 某个业务线下的登录账号
登录 Token 某个业务账号在某个客户端上的登录凭证

例如:

text 复制代码
全局用户 globalUserId = U10001
│
├── blog 业务账号
│     ├── 邮箱:user@example.com
│     └── 博客 accessToken
│
└── tool 业务账号
      ├── 邮箱:user@example.com
      └── 工具 accessToken

博客账号和工具账号可以通过 globalUserId 表示属于同一个用户,但不应该直接复制:

  • 博客密码;
  • 博客业务 Token;
  • 博客的第三方登录凭据;
  • 博客站点的 localStorage;
  • 博客站点的业务权限。

这样做有两个好处:

  1. 工具站被攻破时,不会直接获得博客 Token;
  2. 每条业务线可以拥有自己的权限、套餐、数据范围和注销策略。

2. 业务线必须明确

示例系统使用请求头和请求参数传递业务上下文:

http 复制代码
business: tool
platformType: web
version: 1.0.0
Authorization: Bearer <tool-access-token>

小程序请求会使用:

http 复制代码
business: tool
platformType: miniapp
version: 1.0.0

其他业务线可以使用:

text 复制代码
tool      示例工具服务
pet       示例宠物服务
blog      示例博客服务
wallpaper 示例壁纸服务

业务线不能只依赖前端传来的字符串。后端需要在认证上下文中再次校验:

java 复制代码
if (!"blog".equals(sourceBusinessType)
        || !"tool".equals(targetBusinessType)) {
    throw new BizException("当前业务账号不支持授权登录目标业务线");
}

这一步可以避免用户伪造请求,把一个业务线的 Token 当成另一个业务线的 Token 使用。


二、登录页设计:先解决用户理解成本

1. 登录页的核心层级

示例小程序的登录页最终采用了客户端式的极简布局:

text 复制代码
                  圆形 Logo

                 示例应用
             登录后同步账号资产

       □ 我已阅读并同意用户协议和隐私政策

               [ 微信登录 ]

              其他登录方式

             [邮箱]     [注册]
             邮箱登录   邮箱注册

这个布局有几个设计原则:

  • 页面没有顶部原生导航栏,保持沉浸式;
  • 微信登录作为小程序主路径;
  • 邮箱登录和邮箱注册不是抢主按钮,而是辅助入口;
  • 隐私协议放在真正产生登录行为之前;
  • 点击邮箱图标后再展开表单,避免首屏出现过多输入框;
  • 密码输入支持显示/隐藏;
  • 注册时实时展示密码强度;
  • 首次邮箱快捷登录触发密码更新流程。

登录页不是越多入口越专业。真正好的登录页,应该让用户在三秒内理解“我应该点击哪里”。

2. 小程序登录页的关键模板

下面是登录页的核心 WXML 结构,保留了微信主按钮、协议勾选和邮箱辅助入口:

xml 复制代码
<view class="login-page">
  <view class="brand-logo">
    <image
      wx:if="{{miniappConfig.logoImage}}"
      class="brand-logo__image"
      src="{{miniappConfig.logoImage}}"
      mode="aspectFill"
    />
    <van-icon wx:else name="smile-o" size="76rpx" color="#8A5A16" />
  </view>

  <view class="brand-name">示例应用</view>
  <view class="brand-desc">登录后可同步账号资产与创作记录</view>

  <view class="agreement-row">
    <van-checkbox
      value="{{agreementChecked}}"
      checked-color="#19C37D"
      bind:change="onAgreementChange"
    />
    <view class="agreement-text">
      我已阅读并同意《用户协议》和《隐私政策》
    </view>
  </view>

  <button
    class="wechat-button"
    loading="{{wechatLoading}}"
    bind:tap="onWechatLogin"
  >
    <van-icon name="wechat" size="42rpx" color="#ffffff" />
    <text>{{wechatLoading ? '登录中...' : '微信登录'}}</text>
  </button>

  <view class="other-divider">
    <view class="other-divider__line"></view>
    <view class="other-divider__text">其他登录方式</view>
    <view class="other-divider__line"></view>
  </view>

  <view class="login-methods">
    <view
      class="method-item"
      bind:tap="setTab"
      data-index="1"
    >
      <view class="method-icon">
        <van-icon name="envelop-o" size="42rpx" color="#8A5A16" />
      </view>
      <view class="method-label">邮箱登录</view>
    </view>

    <view
      class="method-item"
      bind:tap="setTab"
      data-index="2"
    >
      <view class="method-icon">
        <van-icon name="contact" size="42rpx" color="#8A5A16" />
      </view>
      <view class="method-label">邮箱注册</view>
    </view>
  </view>
</view>

页面配置中关闭原生导航栏:

json 复制代码
{
  "navigationStyle": "custom",
  "usingComponents": {
    "van-checkbox": "@vant/weapp/checkbox/index",
    "van-field": "@vant/weapp/field/index",
    "van-icon": "@vant/weapp/icon/index"
  }
}

三、邮箱验证码登录和首次密码更新

1. 邮箱格式先在前端校验

前端校验的作用是减少无效请求,后端校验才是真正的安全边界:

ts 复制代码
const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/

function onEmailInput(event: WechatMiniprogram.CustomEvent) {
  const email = String(event.detail || '').trim()

  this.setData({
    email,
    emailValid: emailPattern.test(email),
  })
}

发送验证码按钮只有在邮箱格式正确后才可点击:

xml 复制代码
<button
  slot="button"
  class="code-button {{emailValid ? '' : 'code-button--disabled'}}"
  disabled="{{!emailValid || codeCountdown > 0}}"
  bind:tap="sendLoginCode"
>
  {{codeCountdown > 0 ? codeCountdown + 's' : '发送'}}
</button>

发送验证码:

ts 复制代码
async sendCode(
  email: string,
  countdownKey: 'codeCountdown' | 'registerCodeCountdown'
) {
  if (!emailPattern.test(email)) {
    wx.showToast({
      title: '请输入正确邮箱',
      icon: 'none',
    })
    return
  }

  const data = this.data as WechatMiniprogram.IAnyObject
  if (Number(data[countdownKey] || 0) > 0) return

  await sendEmailCode(email)
  this.startCountdown(countdownKey)

  wx.showToast({
    title: '验证码已发送',
    icon: 'success',
  })
}

后端仍然需要重新校验:

java 复制代码
if (!Validator.isEmail(dto.getEmail())) {
    throw new BizException("邮箱格式不正确");
}

String codeKey = AuthRedisKeysConstant.getEmailCheckCodeKey(
        businessType,
        dto.getEmail()
);

String expectedCode = RedisUtils.getString(codeKey);
if (!StrUtil.equals(dto.getCode(), expectedCode)) {
    throw new BizException("验证码错误或已过期");
}

RedisUtils.del(codeKey);

验证码必须满足以下条件:

  • 发送接口限流;
  • 同一个邮箱有冷却时间;
  • 验证码设置过期时间;
  • 校验成功后立即删除;
  • 验证码不能重复使用;
  • 失败次数过多时暂时锁定;
  • 日志中不能打印验证码明文。

2. 邮箱验证码登录接口

小程序和工具站都可以调用统一的邮箱验证码登录接口:

http 复制代码
POST /auth/sso/email/login
Content-Type: application/json

{
  "email": "user@example.com",
  "code": "123456",
  "businessType": "tool"
}

成功响应示例:

json 复制代码
{
  "code": 200,
  "data": {
    "accessToken": "tool-access-token",
    "refreshToken": "tool-refresh-token",
    "expireTime": "2026-08-02T12:00:00",
    "firstRegistered": true,
    "needUpdatePassword": true,
    "userInfo": {
      "id": 10001,
      "email": "user@example.com",
      "nickname": "示例用户"
    }
  }
}

这里的 needUpdatePassword 不能只作为一个提示字段。前端必须把它当成状态机的一部分处理。

3. 首次注册必须强制更新密码

工具网站的处理逻辑:

js 复制代码
async function saveLogin(loginData) {
  userStore.login(loginData)

  if (loginData.needUpdatePassword || loginData.firstRegistered) {
    pendingForcePasswordLoginData.value = loginData
    forcePasswordEmail.value = loginData.userInfo?.email || ''
    forcePasswordForm.value = {
      code: '',
      password: '',
      confirmPassword: ''
    }

    isOpen.value = false
    forcePasswordVisible.value = true
    message.warning('已为你创建账号,请先更新默认密码')
    return
  }

  await completeLogin(loginData)
}

更新密码前需要做三层校验:

js 复制代码
async function updateFirstPassword() {
  if (!forcePasswordEmail.value) {
    message.warning('邮箱不能为空')
    return
  }

  if (forcePasswordForm.value.code.length !== 6) {
    message.warning('请输入邮箱验证码')
    return
  }

  if (!isPasswordMedium(forcePasswordForm.value.password)) {
    message.warning('密码强度过低,请使用至少中等强度密码')
    return
  }

  if (
    forcePasswordForm.value.password
    !== forcePasswordForm.value.confirmPassword
  ) {
    message.warning('两次输入的密码不一致')
    return
  }

  await request({
    url: '/auth/sso/updatePassword',
    method: 'post',
    data: {
      email: forcePasswordEmail.value,
      captcha: forcePasswordForm.value.code,
      password: forcePasswordForm.value.password
    }
  })

  const loginData = pendingForcePasswordLoginData.value
  pendingForcePasswordLoginData.value = null

  if (loginData) {
    await completeLogin(loginData)
  }
}

4. 密码强度算法

密码强度不能只判断长度,可以从多个维度计算:

ts 复制代码
export function getPasswordStrength(password = '') {
  let score = 0

  if (password.length >= 8) score += 1
  if (password.length >= 12) score += 1
  if (/[a-z]/.test(password)) score += 1
  if (/[A-Z]/.test(password)) score += 1
  if (/\d/.test(password)) score += 1
  if (/[^A-Za-z0-9]/.test(password)) score += 1

  if (
    /(\w)\1{2,}/.test(password)
    || /123456|abcdef|qwerty/i.test(password)
  ) {
    score -= 1
  }

  if (score >= 5) {
    return { level: 'strong', text: '强', percent: 100 }
  }

  if (score >= 3) {
    return { level: 'medium', text: '中', percent: 66 }
  }

  return { level: 'weak', text: '弱', percent: 33 }
}

这里的中等强度不是绝对安全标准,生产环境还可以接入常见密码库或泄露密码库检测。


四、微信登录后的首次邮箱绑定

1. 微信登录不能直接结束

微信登录成功后,系统还需要查询当前用户信息:

ts 复制代码
async function onWechatLogin() {
  if (!this.data.agreementChecked) {
    wx.showToast({
      title: '请先同意用户协议和隐私政策',
      icon: 'none',
    })
    return
  }

  const loginResult = await wxLogin()
  const response = await wechatMiniLogin(loginResult.code)

  if (!response.data) {
    throw new Error('微信登录失败')
  }

  await finishLogin(response.data, this.data.redirect)
}

统一登录收口函数:

ts 复制代码
export async function finishLogin(loginData, redirect = '') {
  userStore.login(loginData)

  const userInfo = await refreshCurrentUserInfo()
  const nextUrl = normalizeRedirect(redirect)

  if (!isEmailBound(userInfo || loginData.userInfo)) {
    wx.redirectTo({
      url: `/pages/bind-email/index?required=1&redirect=${
        encodeURIComponent(nextUrl)
      }`,
      fail: () => {
        wx.reLaunch({
          url: `/pages/bind-email/index?required=1&redirect=${
            encodeURIComponent(nextUrl)
          }`,
        })
      },
    })
    return
  }

  wx.reLaunch({
    url: nextUrl,
  })
}

这个函数是整套方案的关键。微信登录、邮箱验证码登录、邮箱注册登录都必须进入同一个 finishLogin,避免出现:

  • 微信登录检查绑定,邮箱登录不检查;
  • 某个页面绕过绑定页;
  • 登录成功后不同入口跳转逻辑不一致;
  • 用户已经登录但邮箱状态没有刷新。

2. 邮箱绑定采用两阶段交互

第一阶段只负责邮箱格式校验:

ts 复制代码
function onEmailInput(event) {
  const email = String(event.detail || '').trim()

  this.setData({
    email,
    emailValid: emailPattern.test(email),
  })
}

第二阶段才允许发送验证码:

ts 复制代码
async function sendBindCode() {
  if (!emailPattern.test(this.data.email)) {
    wx.showToast({
      title: '请输入正确邮箱',
      icon: 'none',
    })
    return
  }

  await sendBindEmailCode(this.data.email)
  this.setData({
    step: 2,
    countdown: 60,
  })
}

第三阶段提交验证码:

ts 复制代码
async function onBindEmail() {
  if (this.data.code.length !== 6) {
    wx.showToast({
      title: '请输入6位验证码',
      icon: 'none',
    })
    return
  }

  await bindEmail(this.data.email, this.data.code)
  wx.reLaunch({
    url: normalizeRedirect(this.data.redirect),
  })
}

后端接口:

http 复制代码
POST /auth/user/info/email/code?email=user@example.com

POST /auth/user/info/email/bind
Content-Type: application/json

{
  "email": "user@example.com",
  "code": "123456"
}

绑定接口必须同时校验:

  1. 当前请求已经登录;
  2. 当前 Token 对应的业务线;
  3. 邮箱格式;
  4. 验证码是否属于当前业务线;
  5. 验证码是否过期;
  6. 邮箱是否已经被其他用户占用;
  7. 绑定操作是否幂等。

五、示例工具站如何使用示例博客登录

这是整篇文章最重要的部分。

1. 错误方案:工具站直接拿博客 Token

很多人第一反应是:

text 复制代码
工具站打开博客登录页
博客登录成功
博客把 accessToken 传给工具站
工具站保存这个 accessToken

这个方案不应该使用,原因包括:

  • 博客 Token 的业务上下文是 blog,工具接口需要的是 tool;
  • 工具站不应该拥有博客站点的登录凭证;
  • Token 一旦出现在 URL、日志或 postMessage 中,泄露面会扩大;
  • 两个站点的权限边界被打破;
  • 以后无法独立注销或限制工具业务权限。

2. 正确方案:博客授权,后端签发工具 Token

正确的流程是:

text 复制代码
工具站
  │
  │  打开博客登录页,并声明目标业务线 tool
  │
  ├──────> 博客站
  │          │
  │          │ 使用博客自己的 Cookie/localStorage 登录
  │          │
  │          ├── 博客调用后端 /auth/sso/business/login?targetBusinessType=tool
  │          │
  │          └── 后端判断是否已有工具账号
  │
  ├<────── 博客通过 postMessage 返回结果
  │
  ├── 已绑定:保存后端签发的 tool accessToken
  │
  └── 未绑定:暂存一次性 authorizationCode
        ├── 验证已有工具账号邮箱后绑定
        └── 注册工具账号后确认绑定

重点是:

工具站不是“拿到博客 Token”,而是“请求博客授权后,接收后端专门签发的工具 Token”。

3. 工具站打开博客授权窗口

工具站代码:

js 复制代码
function loginWithBlogAccount() {
  const query = new URLSearchParams({
    mode: 'login',
    ssoTarget: 'tool',
    ssoOrigin: window.location.origin
  })

  const popup = window.open(
    `${blogOrigin}/login?${query.toString()}`,
    'salmon-blog-sso',
    'popup=yes,width=540,height=760'
  )

  if (!popup) {
    message.warning('授权窗口被浏览器拦截,请允许弹窗后重试')
  }
}

这里传递的是:

  • ssoTarget=tool:目标业务线;
  • ssoOrigin:授权结果要回传到哪个站点;
  • mode=login:博客登录页进入授权登录模式。

这里没有传:

  • 博客 accessToken;
  • 用户密码;
  • 用户邮箱;
  • 用户 ID。

4. 博客站校验授权请求

博客登录页收到参数后,不能直接相信 URL 中的 ssoOrigin:

js 复制代码
function resolveBusinessSsoRequest() {
  const targetBusinessType = String(route.query.ssoTarget || '')
  const targetOrigin = String(route.query.ssoOrigin || '')

  if (targetBusinessType !== 'tool' || !targetOrigin) {
    return null
  }

  try {
    const parsedTargetOrigin = new URL(targetOrigin).origin
    const expectedToolsOrigin =
      import.meta.env.VITE_TOOLS_ORIGIN
      || 'https://tools.example.com'

    if (parsedTargetOrigin !== expectedToolsOrigin) {
      return null
    }

    return {
      targetBusinessType,
      targetOrigin: parsedTargetOrigin
    }
  } catch {
    return null
  }
}

这一步是为了防止攻击者构造如下链接:

text 复制代码
https://blog.example.com/login?ssoTarget=tool&ssoOrigin=https://evil.example.com

如果博客无条件相信这个地址,登录成功后就可能把授权结果发送给钓鱼页面。

5. 博客登录态只留在博客域名

博客登录成功后,在博客页面内部调用:

js 复制代码
async function completeBusinessSso() {
  const request = resolveBusinessSsoRequest()
  if (!request || !getAccessToken()) return false

  const authorization = await loginByBusinessAuthorization(
    request.targetBusinessType
  )

  if (!window.opener) {
    ElMessage.error('未找到工具站授权窗口,请返回工具站重试')
    return false
  }

  window.opener.postMessage(
    {
      type: 'demo-business-login',
      businessType: request.targetBusinessType,
      bound: authorization.bound,
      loginData: authorization.loginData,
      authorizationCode: authorization.authorizationCode
    },
    request.targetOrigin
  )

  window.close()
  return true
}

博客的请求拦截器会从博客自己的存储中读取博客 Token:

js 复制代码
service.interceptors.request.use((config) => {
  const accessToken = getAccessToken()

  if (accessToken) {
    config.headers.Authorization = `Bearer ${accessToken}`
  }

  config.headers.business = 'blog'
  config.headers.platformType = 'web'

  return config
})

工具站只看到授权结果,不会读取博客的 localStorage,也不会拿到博客原始 Token。


六、后端授权接口设计

1. 已登录博客账号发起业务授权

后端接口:

java 复制代码
/**
 * 已登录业务账号授权登录另一个业务线。
 */
@PostMapping("/business/login")
@NeedLogin
public ResultVO<BusinessAuthorizationVO> authorizeBusinessLogin(
        @RequestParam String targetBusinessType
) {
    return ResultVO.ok(
        userAuthService.authorizeBusinessLogin(
            ContextHolder.getAuthUserId(),
            ContextHolder.getBusinessType(),
            targetBusinessType
        )
    );
}

核心实现:

java 复制代码
@Transactional(rollbackFor = Exception.class)
public BusinessAuthorizationVO authorizeBusinessLogin(
        Long sourceAuthUserId,
        String sourceBusinessType,
        String targetBusinessType
) {
    if (!StrUtil.equals("blog", sourceBusinessType)
            || !StrUtil.equals("tool", targetBusinessType)) {
        throw new BizException("当前业务账号不支持授权登录目标业务线");
    }

    UserAuth sourceUser = this.getById(sourceAuthUserId);
    if (sourceUser == null) {
        throw new BizException("当前登录账号不存在");
    }

    String globalUserId = ensureGlobalUserId(sourceUser);

    UserAuth targetUser = this.getOne(
        new LambdaQueryWrapper<UserAuth>()
            .eq(UserAuth::getGlobalUserId, globalUserId)
            .eq(UserAuth::getBusinessType, targetBusinessType)
            .eq(UserAuth::getIsDeleted, 0)
            .last("LIMIT 1")
    );

    BusinessAuthorizationVO result =
        new BusinessAuthorizationVO();
    result.setTargetBusinessType(targetBusinessType);

    if (targetUser != null) {
        result.setBound(true);
        result.setLoginData(
            buildBusinessLogin(targetUser, targetBusinessType)
        );
        return result;
    }

    String authorizationCode = RandomUtil.randomString(48);
    BusinessAuthorizationGrant grant =
        new BusinessAuthorizationGrant();
    grant.setSourceAuthUserId(sourceAuthUserId);
    grant.setSourceBusinessType(sourceBusinessType);
    grant.setTargetBusinessType(targetBusinessType);

    RedisUtils.set(
        AuthRedisKeysConstant.getBusinessAuthorizationKey(
            authorizationCode
        ),
        grant,
        Duration.ofMinutes(5)
    );

    result.setBound(false);
    result.setAuthorizationCode(authorizationCode);
    return result;
}

返回对象:

java 复制代码
@Data
public class BusinessAuthorizationVO implements Serializable {

    private String targetBusinessType;

    /**
     * 是否已经存在目标业务账号。
     */
    private Boolean bound;

    /**
     * 已关联时返回目标业务独立登录态。
     */
    private LoginVO<CurrentUserInfoVO> loginData;

    /**
     * 未关联时返回一次性授权码。
     * 它不是 accessToken。
     */
    private String authorizationCode;
}

2. 已关联账号:返回工具 Token

如果博客账号和工具账号已经通过 globalUserId 关联,后端调用:

java 复制代码
result.setBound(true);
result.setLoginData(
    buildBusinessLogin(targetUser, "tool")
);

buildBusinessLogin 必须按目标业务线生成 Token:

text 复制代码
sourceBusinessType = blog
targetBusinessType = tool

返回:
tool accessToken
tool refreshToken
tool userInfo

不能返回博客登录态:

text 复制代码
错误:
blog accessToken -> 工具站

正确:
blog 授权请求 -> 后端签发 tool accessToken -> 工具站

3. 未关联账号:返回短期授权码

如果目标业务账号不存在,后端只创建一个 Redis 中的授权上下文:

java 复制代码
BusinessAuthorizationGrant grant =
    new BusinessAuthorizationGrant();

grant.setSourceAuthUserId(sourceAuthUserId);
grant.setSourceBusinessType("blog");
grant.setTargetBusinessType("tool");

RedisUtils.set(
    getBusinessAuthorizationKey(authorizationCode),
    grant,
    Duration.ofMinutes(5)
);

授权码应该具备以下特点:

  • 随机且不可预测;
  • 只在 Redis 中保存短时间;
  • 不能代表登录态;
  • 只能用于指定目标业务线;
  • 成功绑定后立即删除;
  • 过期后不能重新使用;
  • 不能把源 Token 写入授权码内容。

4. 绑定已有工具账号

工具站收到 bound=false 后,展示:

text 复制代码
当前博客账号尚未关联工具账号

[工具账号邮箱]
[邮箱验证码] [发送验证码]

[绑定已有工具账号]

没有工具账号,前往注册

发送验证码使用工具业务上下文:

js 复制代码
async function sendBusinessBindCode() {
  await request({
    url: '/auth/sso/email/code',
    method: 'post',
    params: {
      email: businessBindForm.value.email
    }
  })
}

提交绑定:

js 复制代码
async function bindExistingToolAccount() {
  const loginData = await request({
    url: '/auth/sso/business/bind',
    method: 'post',
    data: {
      authorizationCode:
        pendingBusinessAuthorizationCode.value,
      email: businessBindForm.value.email,
      code: businessBindForm.value.code
    }
  })

  pendingBusinessAuthorizationCode.value = ''
  userStore.login(loginData)
}

后端校验:

java 复制代码
@Transactional(rollbackFor = Exception.class)
public LoginVO<CurrentUserInfoVO> bindBusinessAuthorization(
        BusinessAuthorizationBindDTO dto
) {
    BusinessAuthorizationGrant grant =
        getBusinessAuthorizationGrant(dto.getAuthorizationCode());

    if (!Validator.isEmail(dto.getEmail())) {
        throw new BizException("请输入正确的工具账号邮箱");
    }

    String codeKey = AuthRedisKeysConstant
        .getEmailCheckCodeKey(
            grant.getTargetBusinessType(),
            dto.getEmail()
        );

    String expectedCode = RedisUtils.getString(codeKey);
    if (!StrUtil.equals(dto.getCode(), expectedCode)) {
        throw new BizException("邮箱验证码错误或已过期");
    }

    UserAuth targetUser = getByIdentity(
        grant.getTargetBusinessType(),
        dto.getEmail()
    );

    if (targetUser == null) {
        throw new BizException(
            "该邮箱尚未注册工具账号,请先注册"
        );
    }

    LoginVO<CurrentUserInfoVO> loginVO =
        mergeBusinessAuthorization(grant, targetUser);

    // 授权码和验证码都只能消费一次。
    RedisUtils.del(
        getBusinessAuthorizationKey(dto.getAuthorizationCode())
    );
    RedisUtils.del(codeKey);

    return loginVO;
}

5. 注册工具账号后确认关联

如果用户没有工具账号,必须先注册,再由用户明确确认关联:

text 复制代码
博客账号授权
  ↓
工具站发现没有目标账号
  ↓
用户点击“注册工具账号”
  ↓
邮箱验证码 + 密码强度校验
  ↓
注册成功并登录工具账号
  ↓
用户确认“关联博客账号”
  ↓
POST /auth/sso/business/bind/complete

前端提交:

js 复制代码
async function completeBusinessBinding() {
  const finalLoginData = await request({
    url: '/auth/sso/business/bind/complete',
    method: 'post',
    data: {
      authorizationCode:
        pendingBusinessAuthorizationCode.value
    }
  })

  pendingBusinessAuthorizationCode.value = ''
  userStore.login(finalLoginData)
}

后端接口:

java 复制代码
@PostMapping("/business/bind/complete")
@NeedLogin
public ResultVO<LoginVO<?>> completeBusinessAuthorization(
        @Valid @RequestBody BusinessAuthorizationCompleteDTO dto
) {
    return ResultVO.ok(
        userAuthService.completeBusinessAuthorization(
            ContextHolder.getAuthUserId(),
            ContextHolder.getBusinessType(),
            dto
        )
    );
}

这里加 @NeedLogin 很重要,因为只有当前已经登录的工具账号,才能确认将它和博客账号关联。


七、工具站接收授权结果

1. 使用 postMessage,而不是读取对方存储

工具站监听博客授权窗口返回的消息:

js 复制代码
function handleBusinessLoginMessage(event) {
  if (event.origin !== blogOrigin) {
    return
  }

  const payload = event.data

  if (
    payload?.type !== 'demo-business-login'
    || payload.businessType !== 'tool'
  ) {
    return
  }

  if (
    payload.bound
    && payload.loginData?.accessToken
    && payload.loginData?.refreshToken
    && payload.loginData?.userInfo?.id
  ) {
    saveLogin(payload.loginData)
    message.success('博客账号授权登录成功')
    return
  }

  if (!payload.bound && payload.authorizationCode) {
    pendingBusinessAuthorizationCode.value =
      payload.authorizationCode
    mode.value = 'business-bind'
    message.info(
      '该博客账号尚未绑定工具账号,请选择已有账号或注册'
    )
  }
}

监听和销毁:

js 复制代码
onMounted(() => {
  window.addEventListener(
    'message',
    handleBusinessLoginMessage
  )
})

onBeforeUnmount(() => {
  window.removeEventListener(
    'message',
    handleBusinessLoginMessage
  )
})

2. 为什么必须校验 event.origin

下面的代码是危险的:

js 复制代码
window.addEventListener('message', (event) => {
  saveLogin(event.data.loginData)
})

因为任何网页都可以向当前页面发送消息。

正确做法至少包括:

js 复制代码
if (event.origin !== 'https://blog.example.com') {
  return
}

if (event.data?.type !== 'demo-business-login') {
  return
}

if (event.data?.businessType !== 'tool') {
  return
}

发送时也不能使用 *:

js 复制代码
window.opener.postMessage(payload, targetOrigin)

而不是:

js 复制代码
window.opener.postMessage(payload, '*')

3. 工具站如何保存 Token

工具站收到的是工具业务 Token:

js 复制代码
function login(loginData) {
  setAccessToken(loginData.accessToken)
  setRefreshToken(loginData.refreshToken)

  accessToken.value = loginData.accessToken || ''
  userInfo.value = {
    ...(loginData.userInfo || {})
  }

  localStorage.setItem(
    'tools_user_info',
    JSON.stringify(userInfo.value)
  )
}

后续工具 API 自动携带:

js 复制代码
service.interceptors.request.use((config) => {
  const accessToken = getAccessToken()

  if (
    config.headers.Authorization !== 'no-auth'
    && accessToken
  ) {
    config.headers.Authorization =
      `Bearer ${accessToken}`
  }

  config.headers.business = 'tool'
  config.headers.platformType = 'web'

  return config
})

注意这里的 accessToken 是目标业务线 Token,不是博客 Token。


八、Token 过期和刷新

1. accessToken 与 refreshToken 的职责

Token 作用 建议生命周期
accessToken 访问业务接口 较短
refreshToken 换取新的 accessToken 较长

工具站发现接口返回未登录时:

js 复制代码
async function refreshSession() {
  const refreshToken = getRefreshToken()

  const data = await request({
    url: '/auth/sso/refreshToken',
    method: 'post',
    data: { refreshToken },
    headers: {
      Authorization: 'no-auth'
    }
  })

  setAccessToken(data.accessToken)

  if (data.refreshToken) {
    setRefreshToken(data.refreshToken)
  }

  return data
}

2. 并发刷新要排队

如果多个接口同时发现 Token 过期,不能每个接口都刷新一次。应该只允许一个刷新请求,其余请求进入等待队列:

js 复制代码
let isRefreshing = false
const waitingQueue = []

async function handleTokenRefresh(config) {
  return new Promise((resolve, reject) => {
    waitingQueue.push({
      retry: () => resolve(service(config)),
      fail: reject
    })

    if (isRefreshing) return

    isRefreshing = true

    refreshSession()
      .then(() => {
        waitingQueue.forEach(item => item.retry())
        waitingQueue.length = 0
      })
      .catch(error => {
        waitingQueue.forEach(item => item.fail(error))
        waitingQueue.length = 0
        handleSessionExpired()
      })
      .finally(() => {
        isRefreshing = false
      })
  })
}

这类“请求排队 + 单次刷新 + 失败统一退出”的设计,是面试中很容易被问到的工程细节。


九、完整流程时序图

1. 微信登录并强制绑定邮箱

sequenceDiagram participant U as 用户 participant M as 示例小程序 participant A as 认证服务 participant R as Redis participant E as 邮件服务 U->>M: 点击微信登录 M->>M: wx.login() M->>A: POST /auth/oauth2/login/wx/mini A-->>M: accessToken + refreshToken M->>A: GET /auth/user/info A-->>M: email 未绑定 M-->>U: 跳转绑定邮箱页 U->>M: 输入邮箱 M->>A: POST /auth/user/info/email/code A->>R: 写入验证码和过期时间 A->>E: 发送验证码 E-->>U: 收到验证码 U->>M: 输入验证码 M->>A: POST /auth/user/info/email/bind A->>R: 校验并删除验证码 A-->>M: 绑定成功 M-->>U: 进入首页

2. 博客授权登录工具站

sequenceDiagram participant T as 工具站 participant B as 博客授权窗口 participant A as 认证服务 participant R as Redis participant U as 用户 T->>B: /login?ssoTarget=tool&ssoOrigin=工具站Origin B->>B: 使用博客自己的登录态 B->>A: POST /auth/sso/business/login?targetBusinessType=tool A->>A: 校验 source=blog,target=tool alt 已有关联工具账号 A-->>B: bound=true + tool loginData B-->>T: postMessage(tool loginData) T->>T: 保存 tool accessToken else 未有关联工具账号 A->>R: 写入5分钟一次性授权上下文 A-->>B: bound=false + authorizationCode B-->>T: postMessage(authorizationCode) T-->>U: 选择绑定已有账号或注册 U->>T: 邮箱验证码或注册后确认 T->>A: /auth/sso/business/bind A->>R: 校验并消费授权码 A-->>T: tool loginData end

十、首次邮箱绑定流程图

微信、第三方登录或跨业务授权后,如果目标账号没有邮箱,可以统一进入下面的绑定流程:

flowchart TD A([登录成功]) --> B{邮箱是否已绑定} B -->|是| Z([进入业务]) B -->|否| C[展示绑定邮箱页] C --> D[输入邮箱] D --> E{正则校验通过} E -->|否| D E -->|是| F[点击发送验证码] F --> G[服务端限流并发送邮件] G --> H[输入 6 位验证码] H --> I{验证码是否正确且未过期} I -->|否| H I -->|是| J[绑定邮箱] J --> K{绑定是否成功} K -->|否| C K -->|是| Z

这个流程的体验重点是:邮箱格式不正确时,不显示或不允许点击发送验证码;验证码发送成功后,再进入验证码输入阶段;绑定成功后回到用户原本想访问的页面。

十一、实现过程中遇到的问题

1. 把登录页做成了“表单卡片”

最初的登录页包含大面积品牌卡片、三段式 Tab 和嵌套表单,功能完整,但用户很难一眼看到主登录动作。

后来调整为:

  • Logo 居中;
  • 微信登录作为唯一主按钮;
  • 其他登录方式使用图标;
  • 邮箱表单按需展开;
  • 移除顶部原生导航栏。

这说明登录页的设计重点不是展示所有功能,而是减少用户第一次进入页面时需要做的选择。

2. 只有前端判断首次注册状态

曾经只在接口返回后弹 Toast:

js 复制代码
if (response.data.needUpdatePassword) {
  wx.showToast({
    title: '记得稍后更新密码'
  })
}

这并不能保证用户真的更新密码。用户关闭页面后,默认密码仍然存在。

更合理的做法是:

text 复制代码
首次创建账号
  ↓
强制弹出更新密码窗口
  ↓
邮箱验证码
  ↓
密码强度至少中等
  ↓
确认密码
  ↓
更新成功后才完成登录流程

3. 把博客 Token 直接传给工具站

这种做法看起来简单,实际上破坏了业务边界。

现在的方案使用:

text 复制代码
博客 Token 只在博客域名使用
博客调用后端授权接口
后端返回工具 Token 或短期授权码
工具站只保存工具 Token

这个设计更适合长期维护,也更容易扩展到:

  • 宠物服务;
  • 壁纸服务;
  • 移动端 App;
  • 桌面端客户端;
  • 第三方 OAuth 登录。

4. 未绑定时自动创建目标账号

如果用户使用博客登录工具站时没有工具账号,系统不应该偷偷创建一个空的工具账号。

正确体验是:

text 复制代码
没有工具账号
  ↓
明确提示
  ↓
用户选择:
  ├── 绑定已有工具账号
  └── 注册新的工具账号

这样可以避免:

  • 误合并账号;
  • 用户邮箱绑定错误;
  • 用户不知道系统创建了新账号;
  • 授权登录后产生无法找回的空账号。

十二、安全设计清单

前端

  • 所有登录入口都经过统一登录收口函数;
  • 邮箱发送验证码前做格式校验;
  • 登录和注册按钮在加载期间禁用;
  • 密码支持显示/隐藏;
  • 密码强度实时展示;
  • 首次注册强制更新密码;
  • postMessage 校验 event.origin;
  • postMessage 使用精确 targetOrigin,禁止使用 *;
  • 不从其他域名读取 localStorage;
  • 不把博客 Token 写入 URL。

后端

  • 所有邮箱、验证码和密码参数重新校验;
  • 验证码按业务线隔离;
  • 验证码设置过期时间;
  • 验证码验证成功后立即删除;
  • 授权码使用高熵随机值;
  • 授权码设置短 TTL;
  • 授权码只允许消费一次;
  • 授权码校验源业务线和目标业务线;
  • 业务 Token 独立签发;
  • 绑定操作使用事务;
  • 邮箱和账号唯一性使用数据库约束;
  • 密码使用安全哈希算法保存;
  • 登录、验证码和授权接口限流;
  • 日志中不打印密码、验证码和完整 Token。

推荐的数据库约束

sql 复制代码
ALTER TABLE user_auth
    ADD UNIQUE KEY uk_business_email (business_type, email);

ALTER TABLE user_auth
    ADD UNIQUE KEY uk_global_business (global_user_id, business_type);

实际执行 SQL 时,还需要根据当前表结构、历史数据和数据库字符集规划迁移。中文数据库环境建议明确使用 utf8mb4:

sql 复制代码
SET NAMES utf8mb4;

十三、面试中如何讲这套方案

面试官问“你是怎么做多端统一登录的”,可以按下面的结构回答:

1. 先讲目标

“我们有小程序、工具网站和博客服务,目标是让用户能够跨端使用,但不能让不同业务线直接共享 Token。”

2. 再讲核心模型

“系统使用全局用户和业务账号两层模型。博客和工具账号可以通过 globalUserId 关联,但每条业务线独立签发 accessToken 和 refreshToken。”

3. 再讲授权流程

“工具站打开博客授权页,博客站使用自己的登录态调用后端业务授权接口。后端判断是否已有工具账号:如果已绑定,签发工具 Token;如果未绑定,只返回一个 Redis 中保存五分钟的一次性授权码。工具站不能直接拿博客 Token。”

4. 再讲跨域通信

“博客授权窗口通过 postMessage 把结果回传给工具站,但双方都校验 origin,发送时使用明确 targetOrigin,禁止使用 *。Token 不出博客 API 请求上下文,只回传后端为目标业务线签发的 Token。”

5. 再讲首次注册

“邮箱验证码登录如果没有账号会自动创建,但响应会返回 needUpdatePassword。前端进入强制修改密码流程,要求邮箱验证码、两次密码一致且密码强度至少达到中等。”

6. 最后讲过期处理

“accessToken 过期后由 refreshToken 刷新。并发请求只允许一个刷新请求,其他请求进入等待队列;刷新成功后统一重试,失败则清理登录态并跳转登录页。”

这套回答能够覆盖:

  • 认证和授权的区别;
  • OAuth/SSO 的核心思想;
  • Token 隔离;
  • 跨域通信;
  • Redis 短期状态;
  • 幂等和一次性消费;
  • 密码安全;
  • 并发控制;
  • 用户体验设计。

十四、结果与后续优化

本次改造完成后,登录链路具备以下能力:

  1. 小程序拥有独立的现代化登录页;
  2. 微信登录后强制检查邮箱绑定;
  3. 邮箱验证码登录支持自动创建账号;
  4. 首次创建账号强制更新默认密码;
  5. 注册时实时显示密码强度;
  6. 密码输入支持显示和隐藏;
  7. 工具网站可以通过博客账号授权登录;
  8. 博客 Token 不会直接交给工具站;
  9. 已绑定账号直接获得工具业务 Token;
  10. 未绑定账号必须经过邮箱验证或注册确认;
  11. 授权码短时有效且只能使用一次;
  12. 工具站和博客站可以独立刷新和注销自己的登录态。

后续还可以继续增强:

  • 增加标准 OAuth 2.1 Authorization Code + PKCE 流程;
  • 增加 state 防重放和请求关联校验;
  • 增加设备管理和登录设备列表;
  • 增加异地登录提醒;
  • 增加邮箱变更和解绑二次验证;
  • 增加 Token 轮换和 refreshToken 复用检测;
  • 增加登录、验证码和业务授权的风控策略;
  • 使用 HttpOnly、Secure、SameSite Cookie 承载 Web 登录态;
  • 对移动端和 Web 端采用不同的 Token 存储策略;
  • 对授权绑定增加审计日志和用户可见的关联记录。

结语

一个真正可用的登录系统,绝不是“登录接口返回 Token,然后把 Token 存起来”这么简单。

它至少要同时考虑:

  • 用户能不能看懂;
  • 不同登录方式是否一致;
  • 首次注册是否安全;
  • 第三方登录后是否完成邮箱绑定;
  • 不同业务线是否隔离;
  • 跨域授权是否泄露 Token;
  • 授权码是否短时、随机、一次性;
  • Token 过期是否能够平滑刷新;
  • 账号绑定是否需要用户明确确认。

这个 Demo 最终采用了这样的原则:

统一身份关系,隔离业务 Token;
授权由博客发起,登录态由目标业务签发;
未绑定账号不自动合并,邮箱验证和用户确认必须存在;
前端负责体验,后端负责最终校验。

这套设计适用于任何拥有多个产品、多个客户端或多个业务线的系统。

觉得有用就点个赞,不用登录也能读

评论

0 条
登录 之后才能评论
—
还没有评论,来说第一句