Java/后端

JWT

讲解了什么是jwt,组成,用什么用,落地一般干嘛,补充了什么是刷新令牌

一、为什么会有 JWT?——从 HTTP 无状态说起

HTTP 协议本身不记住“上一次请求是谁发的”。你登录成功了,下一个请求过来,服务器默认完全不知道你是谁。 所以所有身份认证方案,本质上都在解决同一个问题:如何让服务器在后续请求中认出“这是刚才登录成功的那个人”。

常见两种方案:

  • Session(有状态):登录成功后,服务器在内存/Redis 里存一条记录,比如 sessionId=abc -> 用户1,然后通过 Cookie 把 sessionId 发给浏览器。后续请求浏览器自动带 Cookie,服务器查 sessionId 找到用户。状态存在服务器。
  • JWT(无状态):登录成功后,服务器签发一个签名字符串,里面包含用户 ID、过期时间等。客户端自己保存(localStorage 或 Cookie),后续请求放在 Header 里,比如 Authorization: Bearer <token>。服务器验证签名,直接从 token 里读出用户 ID,不需要查库或查内存。状态存在客户端,服务器只用密钥验签。

选 JWT,因为前后端分离、未来要用 Vue/Axios,而且 JWT 天然支持横向扩展(多实例不用共享 Session)。我只需要把 Session 当作对比概念了解就行。

二、JWT 长什么样?

JWT 是 JSON Web Token 的缩写。它用 JSON 做载体、带数字签名,可以在不同服务端之间传输。 结构是三段,用英文句点 . 分割:

Header.Payload.Signature

1. Header

是一个 JSON,通常包含:

  • typ:类型,固定为 "JWT"。它只是告诉接收方“这是一个 JWT”,不是加密算法类型。我一开始以为 typ 是算法类型,后来发现算法是 alg。
  • alg:签名算法,比如 HS256、RS256。

Header 会被 Base64URL 编码。注意:是编码,不是加密。

2. Payload

也是一个 JSON,存放具体内容。声明分三类:

  • 注册声明(Registered Claims):标准字段,如 sub(主体)、exp(过期时间)、iat(签发时间)。
  • 公共声明(Public Claims):可以自定义,但建议用防冲突的命名空间。
  • 私有声明(Private Claims):业务自定义字段,如 userId、role。

这里有个坑:Payload 里的“注册声明、公共声明、私有声明”和 Java 的访问修饰符(public/private)完全没关系,只是 JWT 规范里的分类名字。 Payload 同样只是 Base64URL 编码,不是加密。任何人拿到 JWT 都能解码看到内容,所以绝对不能放密码、身份证号等敏感信息。

3. Signature

签名部分。生成方式: 把 Base64URL(Header) + "." + Base64URL(Payload) 拼成一个字符串,然后使用 Header 里声明的算法(比如 HS256)和服务器持有的密钥进行签名,最后把签名结果做 Base64URL 编码。

最终形式:

Base64URL(Header) . Base64URL(Payload) . Base64URL(Signature)

我给自己提的问题:服务器怎么发现 token 被篡改了? 因为签名是对 Header 和 Payload 算出来的。改一个字符,签名就对不上,验签直接失败。

三、签名不是加密!

我最初以为 JWT 是把 JSON 加密,其实不是。

  • 加密:可逆,有密钥能还原,目的是保密。
  • 签名:单向不可逆,目的是防篡改、证明来源。

JWT 的 Payload 是明文可读的,所以它不是用来保密的,而是用来证明“这个令牌是服务器签发的,没被改过”。 安全性依赖三件事:

  1. 密钥保密,不能硬编码提交 Git。
  2. 必须用 HTTPS 传输,防止令牌被窃取。
  3. Payload 不放秘密。

Payload 能放密码吗?为什么? 不能。因为 Payload 只是 Base64 编码,谁都能解码看到,放了就等于泄露。

四、JWT 用来做什么?——授权验证

JWT 常用在授权验证。流程是:

  1. 用户登录成功,服务器签发 JWT。
  2. 客户端每次请求都携带 JWT(通常放 Authorization 头)。
  3. 服务端在处理请求之前先校验 JWT,通过后才执行具体业务。

那它到底保护谁?既保护服务端,也保护用户:

  • 保护服务端:防止伪造请求。没有 JWT,任何人都能调你的 API 删库跑路。
  • 保护用户:防止 A 用户冒充 B 用户。服务器从 JWT 里解析出当前用户 ID,再检查要操作的数据是否属于该用户,这叫水平越权防护;同时根据角色/权限判断能否执行管理员操作,这叫垂直越权防护。

这里核心思想是服务器权威。 前端(客户端)不可信,前端传过来的 userId、role 都可以被伪造。所以服务端必须自己从 JWT 中解析身份,绝不能相信前端参数。 这很像 UE 开发里的服务器权威:客户端不可信,服务器做最终裁决;JWT 就相当于服务器签发的“签名过的身份声明”,服务器验签后就可以信任里面的用户 ID。

我给自己提的问题:为什么 userId 必须从服务端取,不能信前端? 因为前端数据可以被任意篡改,只有服务端自己签发的 JWT 才能证明身份。

五、有效期与刷新令牌

JWT 的 Payload 里有 exp 字段,表示过期时间。 因为 JWT 是无状态的,服务器一旦签发,就无法主动作废一个还没过期的 JWT(除非引入黑名单,那就又变成有状态了)。 如果 token 被偷了,攻击者可以一直用到过期。所以:

  • 短期 JWT:有效期设短,比如 15 分钟到 2 小时,减少被盗后的风险窗口。
  • 刷新令牌(Refresh Token):有效期长,比如 7 天,存在服务器端(数据库/Redis),可以主动作废(比如用户登出、修改密码)。短期 JWT 过期后,用刷新令牌换取新的 JWT。

这就是“短期 JWT + 刷新令牌”的机制。

我给自己提的问题:JWT 泄露了怎么办?为什么令牌要设短有效期? 短有效期能减少泄露后的可利用时间。配合刷新令牌,可以在服务端主动让刷新令牌失效,从而阻断攻击者获取新的 JWT。

六、Java 里怎么用?

在 Java 里用 JWT,需要引入依赖,常用 jjwt 等库。主要操作三类:

  • 生成:登录成功后,用用户 ID、过期时间、密钥生成 JWT。
  • 解析:每个请求进来,验签并读出用户 ID。
  • 校验:过期、篡改、格式错误都算无效。

Spring Security 本质是一个过滤器链。请求进来先穿过一串 Filter,最后才到 DispatcherServlet。 两个容易混淆的概念:

  • 认证 Authentication:你是谁(登录、验证令牌)。
  • 授权 Authorization:你能干什么(角色、权限)。

自定义 JWT 过滤器通常放在标准用户名密码过滤器之前:解析 token,有效就把用户放入 SecurityContext;无效或缺失就继续走,由授权规则决定是否返回 401。

配置 SecurityFilterChain 时,关键几行:

http.authorizeHttpRequests(auth -> auth
        .requestMatchers("/api/v1/auth/**").permitAll()
        .requestMatchers(HttpMethod.GET, "/api/v1/knowledge-items/**").permitAll()
        .requestMatchers("/api/v1/learning/**").authenticated()
        .anyRequest().authenticated())
    .sessionManagement(s -> s.sessionCreationPolicy(STATELESS))   // 无状态
    .csrf(csrf -> csrf.disable());                                // 无状态 API 可关
  • STATELESS:告诉 Security 不要创建/使用 HttpSession,配合 JWT。
  • csrf.disable():CSRF 攻击依赖 Cookie 自动携带,JWT 放在 Header 里,所以可以关。这不是随手关,是因为无状态所以可以关。
  • permitAll vs authenticated 的边界就是公开/受保护接口清单。

另外,密码存储要用 BCrypt,不是 MD5。BCrypt 自带盐、故意慢、可校验。验证不是重新哈希后比较字符串,而是调用 BCrypt.checkpw(明文, 库中哈希)。Spring 里推荐用 spring-security-crypto 的 BCryptPasswordEncoder,不依赖完整 Security 也能用。

我给自己提的问题:认证和授权的区别?STATELESS 改变了什么?CSRF 为什么能关? 认证是“你是谁”,授权是“你能干什么”。STATELESS 让 Security 不创建 HttpSession,每次请求都靠 token 识别用户。CSRF 能关是因为 JWT 不放 Cookie 自动携带,攻击者无法利用浏览器自动带凭证的机制。

七、其他细节与自检问题汇总

我给自己列了 10 个自检问题,用来检验是否真的理解:

  1. HTTP 无状态是什么意思?Session 和 JWT 分别怎么解决?
  2. JWT 三段各是什么?Payload 能放密码吗?为什么?
  3. 服务器怎么发现 token 被篡改了?
  4. BCrypt 和 MD5 的区别?登录时怎么验证密码?
  5. 认证和授权的区别?
  6. Spring Security 的过滤器链在请求的哪个阶段起作用?
  7. 为什么本项目可以关闭 CSRF?什么情况下不能关?
  8. 为什么 userId 必须从服务端取,不能信前端?
  9. JWT 泄露了怎么办?为什么令牌要设短有效期?
  10. STATELESS 配置具体改变了 Security 的什么行为?

这些问题的答案其实都已经融入上面的笔记里了。 最后再强调几个我容易记错的点:

  • Header 里的 typ 是类型标识,固定 "JWT",不是加密算法类型。
  • Payload 的“注册声明、公共声明、私有声明”和 Java 访问修饰符无关。
  • Header 和 Payload 是 Base64URL 编码,不是加密。
  • Signature 是对 Header.Payload 的签名,不是加密。
  • JWT 不是用来“加密 JSON”,而是用来“签名 JSON”,保证不被篡改。

补充:刷新令牌(Refresh Token)

为什么还需要刷新令牌?

前面说 JWT 是无状态的,服务器签发后无法主动作废。 所以访问令牌(Access Token)的有效期必须设短,比如 15 分钟到 2 小时,减少被盗后的风险。

但这样用户就得频繁重新登录,体验很差。 刷新令牌就是来解决这个矛盾的:用短期访问令牌做日常请求,用长期刷新令牌来续期。

刷新令牌是什么?

刷新令牌是一个长期凭证,专门用来在访问令牌过期后,换取新的访问令牌。 它通常不是 JWT,而是一个随机字符串(比如 UUID),并且服务器端必须存一份记录(数据库或 Redis),这样才能主动作废它。

  • 访问令牌(Access Token):短期,通常就是 JWT,无状态,服务器不存储。
  • 刷新令牌(Refresh Token):长期,有状态,服务器存储,可以主动撤销。

工作流程

  1. 登录成功 服务器同时签发:
    • 一个短期访问令牌(JWT)
    • 一个长期刷新令牌(随机字符串)
  2. 客户端保存
    • 访问令牌:存在内存或 localStorage,每次请求放在 Authorization 头里。
    • 刷新令牌:放在更安全的地方,比如 HttpOnly Cookie,或者安全的本地存储。
  3. 访问令牌过期 客户端请求 API,服务器返回 401(未授权/令牌过期)。
  4. 用刷新令牌换新令牌 客户端拿着刷新令牌,调用专门的刷新接口,比如 POST /api/v1/auth/refresh。
  5. 服务器验证刷新令牌
    • 检查这个刷新令牌是否存在于数据库/Redis 中。
    • 检查是否过期、是否被撤销、是否绑定了设备等。
    • 如果有效,签发新的访问令牌,可能同时轮换刷新令牌(旧的作废,发一个新的)。
  6. 客户端拿到新访问令牌 继续正常请求。
  7. 用户登出或修改密码 服务器删除该用户的刷新令牌记录,之后这个刷新令牌就失效了,无法再换取新的访问令牌。

刷新令牌和 JWT 的关系

  • 访问令牌:通常就是 JWT,无状态,服务器不存储。
  • 刷新令牌:通常不是 JWT,而是一个随机字符串;即使做成 JWT,服务器也必须存一份记录,否则无法主动作废。

所以刷新令牌把“有状态”的部分集中到了服务器端,而日常请求仍然可以用无状态的 JWT,兼顾了安全性和扩展性。

安全注意事项

  1. 刷新令牌必须安全存储 不能放在容易被 XSS 读取的地方。推荐放在 HttpOnly Cookie 里,或者由客户端安全地保存。
  2. 刷新令牌要能主动作废 服务器端要存记录,支持撤销(比如用户登出、修改密码、检测到异常登录)。
  3. 刷新令牌可以轮换 每次使用后,旧的刷新令牌作废,发一个新的。这样即使旧令牌泄露,攻击者用一次后就会失效。
  4. 绑定设备 / IP(可选) 增加盗用难度,但可能影响用户体验。
  5. 设置合理有效期 比如 7 天、30 天,到期后必须重新登录。

我给自己提的问题

  • 访问令牌和刷新令牌有什么区别? 访问令牌短期、无状态、用于日常请求;刷新令牌长期、有状态、只用于续期。
  • 为什么刷新令牌要有状态? 因为要能主动作废,弥补 JWT 无法主动撤销的缺点。
  • 刷新令牌泄露了怎么办? 服务器端可以撤销它,并让该用户重新登录;配合轮换机制,旧令牌用一次就失效。

一句话总结

刷新令牌是一个长期凭证,用来在访问令牌过期后换取新的访问令牌。 它让用户可以长时间保持登录状态,同时访问令牌保持短期,降低泄露风险。 典型的搭配是:短期 JWT 用于请求,长期刷新令牌用于续期。