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 是明文可读的,所以它不是用来保密的,而是用来证明“这个令牌是服务器签发的,没被改过”。 安全性依赖三件事:
- 密钥保密,不能硬编码提交 Git。
- 必须用 HTTPS 传输,防止令牌被窃取。
- Payload 不放秘密。
Payload 能放密码吗?为什么? 不能。因为 Payload 只是 Base64 编码,谁都能解码看到,放了就等于泄露。
四、JWT 用来做什么?——授权验证
JWT 常用在授权验证。流程是:
- 用户登录成功,服务器签发 JWT。
- 客户端每次请求都携带 JWT(通常放
Authorization头)。 - 服务端在处理请求之前先校验 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 里,所以可以关。这不是随手关,是因为无状态所以可以关。permitAllvsauthenticated的边界就是公开/受保护接口清单。
另外,密码存储要用 BCrypt,不是 MD5。BCrypt 自带盐、故意慢、可校验。验证不是重新哈希后比较字符串,而是调用 BCrypt.checkpw(明文, 库中哈希)。Spring 里推荐用 spring-security-crypto 的 BCryptPasswordEncoder,不依赖完整 Security 也能用。
我给自己提的问题:认证和授权的区别?STATELESS 改变了什么?CSRF 为什么能关? 认证是“你是谁”,授权是“你能干什么”。STATELESS 让 Security 不创建 HttpSession,每次请求都靠 token 识别用户。CSRF 能关是因为 JWT 不放 Cookie 自动携带,攻击者无法利用浏览器自动带凭证的机制。
七、其他细节与自检问题汇总
我给自己列了 10 个自检问题,用来检验是否真的理解:
- HTTP 无状态是什么意思?Session 和 JWT 分别怎么解决?
- JWT 三段各是什么?Payload 能放密码吗?为什么?
- 服务器怎么发现 token 被篡改了?
- BCrypt 和 MD5 的区别?登录时怎么验证密码?
- 认证和授权的区别?
- Spring Security 的过滤器链在请求的哪个阶段起作用?
- 为什么本项目可以关闭 CSRF?什么情况下不能关?
- 为什么 userId 必须从服务端取,不能信前端?
- JWT 泄露了怎么办?为什么令牌要设短有效期?
- 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):长期,有状态,服务器存储,可以主动撤销。
工作流程
- 登录成功
服务器同时签发:
- 一个短期访问令牌(JWT)
- 一个长期刷新令牌(随机字符串)
- 客户端保存
- 访问令牌:存在内存或 localStorage,每次请求放在
Authorization头里。 - 刷新令牌:放在更安全的地方,比如 HttpOnly Cookie,或者安全的本地存储。
- 访问令牌:存在内存或 localStorage,每次请求放在
- 访问令牌过期 客户端请求 API,服务器返回 401(未授权/令牌过期)。
- 用刷新令牌换新令牌
客户端拿着刷新令牌,调用专门的刷新接口,比如
POST /api/v1/auth/refresh。 - 服务器验证刷新令牌
- 检查这个刷新令牌是否存在于数据库/Redis 中。
- 检查是否过期、是否被撤销、是否绑定了设备等。
- 如果有效,签发新的访问令牌,可能同时轮换刷新令牌(旧的作废,发一个新的)。
- 客户端拿到新访问令牌 继续正常请求。
- 用户登出或修改密码 服务器删除该用户的刷新令牌记录,之后这个刷新令牌就失效了,无法再换取新的访问令牌。
刷新令牌和 JWT 的关系
- 访问令牌:通常就是 JWT,无状态,服务器不存储。
- 刷新令牌:通常不是 JWT,而是一个随机字符串;即使做成 JWT,服务器也必须存一份记录,否则无法主动作废。
所以刷新令牌把“有状态”的部分集中到了服务器端,而日常请求仍然可以用无状态的 JWT,兼顾了安全性和扩展性。
安全注意事项
- 刷新令牌必须安全存储 不能放在容易被 XSS 读取的地方。推荐放在 HttpOnly Cookie 里,或者由客户端安全地保存。
- 刷新令牌要能主动作废 服务器端要存记录,支持撤销(比如用户登出、修改密码、检测到异常登录)。
- 刷新令牌可以轮换 每次使用后,旧的刷新令牌作废,发一个新的。这样即使旧令牌泄露,攻击者用一次后就会失效。
- 绑定设备 / IP(可选) 增加盗用难度,但可能影响用户体验。
- 设置合理有效期 比如 7 天、30 天,到期后必须重新登录。
我给自己提的问题
- 访问令牌和刷新令牌有什么区别? 访问令牌短期、无状态、用于日常请求;刷新令牌长期、有状态、只用于续期。
- 为什么刷新令牌要有状态? 因为要能主动作废,弥补 JWT 无法主动撤销的缺点。
- 刷新令牌泄露了怎么办? 服务器端可以撤销它,并让该用户重新登录;配合轮换机制,旧令牌用一次就失效。
一句话总结
刷新令牌是一个长期凭证,用来在访问令牌过期后换取新的访问令牌。 它让用户可以长时间保持登录状态,同时访问令牌保持短期,降低泄露风险。 典型的搭配是:短期 JWT 用于请求,长期刷新令牌用于续期。