JWT - 令牌认证（认证流程和原理、Jwt 工具类、搭配 Redis 使用） ...

目录

一、JWT 认证
1.1、对 JWT 的认识
1.1.1、JWT 解释
1.1.2、为什么使用的 JWT 认证，而不是 Session 认证？
a）基于传统的 Session 认证
1.1.3、JWT 认证流程
1.1.4、优势
1.1.5、JWT 的结构
JWT 第一部分：标头 Header
JWT 第二部分：有效载荷 Payload 
JWT 第三部分：签名 Signature
1.2、JWT 的使用
1.2.1、实例
a）引入 jwt 依赖
b）生成 Token
c）根据密钥创建验证对象，然后验证 Token
d）执行效果
1.2.2、封装 Jwt 工具类

---

一、JWT 认证

---

1.1、对 JWT 的认识

1.1.1、JWT 解释

JWT 是 “JSON Web Token” 的简写，也就是通过 JSON 情势作为 Web 应用中的令牌，用于在各方之间安全的将信息作为 JSON 对象传输.  在数据传输过程中还可以完成数据加密，签名等相干处理.
这就像是皇上的玉玺，谁见到了哪怕没见过皇上长啥样，都知道是皇上来了.

1.1.2、为什么使用的 JWT 认证，而不是 Session 认证？

a）基于传统的 Session 认证

http 协议是一种无状态的协议，也就意味着当用户第一次通过用户名和密码登录乐成以后，下一次再请求的时候，用户还需要再进行登录才行，因为根据 http 协议，我们不能知道是哪个用户发出的请求. 
为了解决上述问题，就是引入了 session 认证机制.  用户第一次登录乐成之后，服务端会生成一个 sessionId，将他保存到内存中，然后加入到响应中（set-cookie）发送给客户端，接着客户端保存到当地，之后客户端每次访问服务器时都会带上这个 sessionId 作为身份标识，服务端也就知道这个请求是来自于哪个用户了.
   弊端：
  1. 占用大量服务器内存：每个用户颠末认证之后都会再服务器的内存中记录一次，随着用户的增多，服务端的内存开销会显着增加.
2. 限制分布式架构的应用：用户认证之后会将 sessionId 保存到内存中，这就意味着用户下次请求必须要请求到这台服务器上，才完成能授权.  在分布式体系中，肯定水平上增大了配置 负载均衡 的复杂度（指定请求打到记录 sessionId 的差别服务器）.
3. 如果后端需要实现 session 共享机制，还需要进行 redis 集群的部署，加大了部署难度. 
4. 因为是基于 cookie 来进行用户辨认的（set-cookie），cookie 如果被捕获，用户很轻易受到 CSRF（跨网站请求伪造的攻击）.

1.1.3、JWT 认证流程

1. 起首前端将用户名和密码发送给后端，后端对用户名和密码校验乐成后，会将用户 id 和其他信息作为 payload ，然后将其分别进行 Base64 编码，拼接，最后再签名，形成一个 JWT（Token）.  形成的 JWT 就形同 xxx.yyy.zzz 这种结构的字符串.
2. 后端将 JWT 字符串作为登录乐成的响应结构返回给前端.  前端就可以通过 localStorage 保存到当地.  用户退出登录时删除保存的 JWT 即可.
3. 之后前端每次请求都会将 JWT 放入 HTTP Header 中的 Authorization 位（解决 XSS 和 XSRF 问题）.
4. 之后后端每次收到请求后都会先验证 JWT 的有效性.  例如，查抄签名是否正确、Token 是否过期、Token 的接收方是否是自己（可选）.

1.1.4、优势

• 不占用服务器资源：服务器只需要通过 JWT 工具进行校验即可.
  
• 适用于分布式微服务：不需要通过负载均衡找到指定服务器上的会话，只需要在网关中对请求头中的 JWT 令牌进行统一校验即可.
  
• 信息安全：由于签名是使用 标头 和 有效负载 盘算的，因此还可以验证内容是否遭到窜改.
  
• 支持多种语言：Token 时以 JSON 加密的情势保存在客户端的. 原则上任何 web 都支持.
  

1.1.5、JWT 的结构

JWT 令牌由三个部分组成，分别是 标头（Header）、有效载荷（Payload）、签名（Signature），并且由 "." 分割.
雷同于 xxxx.yyyy.zzzzz ，也就是 Header.Payload.Signature

JWT 第一部分：标头 Header

标头通常由两个部分组成，分别是 令牌的范例（例如 JWT） 和 所使用的签名算法.（例如HMAC、SHA256、RSA.  一样平常就是用 HS 256 即可）.  
例如：

1. {
2.     "alg": "HS256",
3.     "typ": "JWT"
4. }

复制代码

最后，他会使用 Base64 编码构造出 JWT 结构中的第一部分（Header）.
   Ps：Base64 只是一种编码，也就是说，可以被翻译回原来的样子. 因此他并不是一种加密过程.
  
JWT 第二部分：有效载荷 Payload 

令牌的第二部分就是有效载荷，这就是我们一些自定义传输的信息，通常是一些用户信息.
   Ps：值得留意的是，Base64 是一种编码，可以被翻译回来，因此在 JWT 中不因该在 负载 中加入任何敏感数据，例如用户密码.
  例如：

1. {
2.     "id": "6",
3.     "username": "cyk",
4.     "admin": true
5. }

复制代码

最后，他会使用 Base64 编码构造出 JWT 结构中的第二部分（Payload）.

JWT 第三部分：签名 Signature

Signatrue 需要使用 Base64 编码后的 header 和 payload 以及提供的 密钥（私钥），然后使用 header 中指定的签名算法（HS256）构建一个签名，包管 JWT 没有被窜改过.
例如，一旦窜改 header 中的信息，那么服务端拿到传来的 JWT，会先辈行验签，就是拿着新的 JWT 的第一部分和第二部分，再以同样的 密钥（私钥） 再生成一个 JWT 第三部分（签名），然后拿着这个新生成的 签名和 前端刚刚传来的 JWT 的第三部分进行比对，就会对比出不一致.
   Ps：这就使得后端不需要存储任何数据，就可以校验用户的身份，制止了使用 session 而导致占用大量内存空间.
  
1.2、JWT 的使用

1.2.1、实例

这里用一个简朴的栗子来演示 JWT 的使用.
a）引入 jwt 依赖

1.         <dependency>
2.             <groupId>com.auth0</groupId>
3.             <artifactId>java-jwt</artifactId>
4.             <version>3.4.0</version>
5.         </dependency>

复制代码

b）生成 Token

1.     @Test
2.     public void createJwt() {
3.         //设置令牌的过期时间位 100 s
4.         Calendar instance = Calendar.getInstance();
5.         instance.add(Calendar.SECOND, 100);
7.         //创建 Token
8.         String token = JWT.create()
9.                 .withClaim("userId", 6) //payload
10.                 .withClaim("username", "cyk") //payload
11.                 .withExpiresAt(instance.getTime()) //设置过期时间
12.                 .sign(Algorithm.HMAC256("djafo&*&(988*T*"));//签名(这里自定义密钥即可)
14.         System.out.println(token);
15.     }

复制代码

执行之后，通过 sout 展示 token 如下：

c）根据密钥创建验证对象，然后验证 Token

1.     @Test
2.     public void test() {
3.         //创建验证对象
4.         JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("djafo&*&(988*T*")).build();
5.         //验证Token(验证失败，会引发异常)
6.         DecodedJWT verify = jwtVerifier.verify("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2OTcxNjcwNTMsInVzZXJJZCI6NiwidXNlcm5hbWUiOiJjeWsifQ.WsDPqbmeeqyKPMRllrDv4kfUL-m6hZxAfGc21-t51GE");
8.         System.out.println(verify.getClaim("userId").asInt());
9.         System.out.println(verify.getClaim("username").asString());
10.     }

复制代码

一旦执行失败，则会引发如下异常：

• SignatureVerificationException：签名不一致异常.
  
• TokenExpiredException：令牌过期异常.
  
• AlgorithmMismatchException：算法不匹配异常.
  
• InvalidClaimException：失败的 payload 异常.
  

d）执行效果

1.2.2、封装 Jwt 工具类

未来在我们的项目中，肯定是需要对上述过程进行封装来使用的.
主要有三个方法：

• 生成 Token.
  
• 验证 Token 正当性.
  
• 获取 Token.
  

a）Java 如下：

1. /**
2. * Jwt 工具类
3. */
4. public class JwtUtils {
6.     //自定义密钥
7.     private static final String SIGN = "Y*(GY*G^&*%69g*()&";
9.     /**
10.      * 生成 Token
11.      * @param map 自定义的载荷数据
12.      * @return 返回 Token
13.      */
14.     public static String createToken(Map<String, String> map) {
15.         //1.设置过期时间(默认 1 天过期)
16.         Calendar instance = Calendar.getInstance();
17.         instance.add(Calendar.DATE, 1);
19.         //2.创建 jwt builder，添加自定义的载荷数据
20.         JWTCreator.Builder builder = JWT.create();
21.         for(Map.Entry<String, String> entry : map.entrySet()) {
22.             builder.withClaim(entry.getKey(), entry.getValue());
23.         }
25.         //3.生成 Token
26.         String token = builder.withExpiresAt(instance.getTime()) //过期时间
27.                 .sign(Algorithm.HMAC256(SIGN));// sign
28.         return token;
29.     }
31.     /**
32.      * 验证 Token 合法性
33.      * @param token
34.      */
35.     public static boolean checkToken(String token) {
36.         try {
37.             JWT.require(Algorithm.HMAC256(SIGN)).build().verify(token);
38.         } catch (Exception e) {
39.             e.printStackTrace();
40.             return false;
41.         }
42.         return true;
43.     }
46.     /**
47.      * 获取 Token 信息
48.      * @param token
49.      * @return
50.      */
51.     public static DecodedJWT getTokenInfo(String token) {
52.         DecodedJWT verify = JWT.require(Algorithm.HMAC256(SIGN)).build().verify(token);
53.         return verify;
54.     }
56. }

复制代码

b）Kotlin 如下：

1. import com.auth0.jwt.JWT
2. import com.auth0.jwt.algorithms.Algorithm
3. import com.auth0.jwt.interfaces.DecodedJWT
4. import java.util.*
6. /**
7. * Jwt 工具类
8. */
9. object JwtUtils {
11.     //自定义密钥
12.     private const val SIGN = "Y*(GY*G^&*%69g*()&"
13.     //过期时间(默认 1 天过期)
14.     private const val EXPIRE_TIME = 1
16.     /**
17.      * 生成 Token
18.      * @param map 自定义的载荷数据
19.      * @return 返回 Token
20.      */
21.     fun createToken(map: Map<String, String>): String {
22.         //1.设置过期时间
23.         val expireTime = Calendar.getInstance().apply {
24.                 this.add(Calendar.DATE, EXPIRE_TIME)
25.             }.time
27.         //2.创建 jwt builder，添加自定义的载荷数据
28.         val builder = JWT.create()
29.         for ((key, value) in map) {
30.             builder.withClaim(key, value)
31.         }
33.         //3.生成 Token
34.         return builder.withExpiresAt(expireTime) //过期时间
35.             .sign(Algorithm.HMAC256(SIGN)) // sign
36.     }
38.     /**
39.      * 验证 Token 合法性
40.      * @param token
41.      */
42.     fun checkToken(token: String): Boolean {
43.         return try {
44.             JWT.require(Algorithm.HMAC256(SIGN)).build().verify(token)
45.             true
46.         } catch (e: Exception) {
47.             e.printStackTrace()
48.             false
49.         }
50.     }
52.     /**
53.      * 获取 Token 信息
54.      * @param token
55.      * @return
56.      */
57.     fun getTokenInfo(token: String): DecodedJWT {
58.         return JWT.require(Algorithm.HMAC256(SIGN)).build().verify(token)
59.     }
60. }

复制代码

1.2.3、案例：用户登录和退出登录

用户登录：登录时根据用户信息创建 jwt，并把生成的 token 保存到 redis 上.

1.     @SneakyThrows
2.     @Override
3.     public String login(UserLoginDto loginDto) {
4.         //1.非空校验
5.         if(loginDto == null || !StringUtils.hasLength(loginDto.getPassword()) ||
6.                 !StringUtils.hasLength(loginDto.getUsername())) {
7.             throw new ApplicationException(AppResult.fail(CodeMsg.FAIL_NULL_USER));
8.         }
9.         //2.校验密码
10.         User dbUser = userMapper.selectUserByName(loginDto.getUsername());
11.         if(dbUser == null) {
12.             throw new ApplicationException(AppResult.fail(CodeMsg.FAIL_NOT_EXISTS_USER));
13.         }
14.         if(!PasswordUtils.check(loginDto.getPassword(), dbUser.getPassword())) {
15.             throw new ApplicationException(AppResult.fail(CodeMsg.FAIL_ERROR_USER));
16.         }
17.         //3.Jwt 生成 token 作为 key，json 格式的用户信息作为值，保存到 redis 上
18.         HashMap<String, String> map = new HashMap<>();
19.         map.put("username", loginDto.getUsername());
20.         String token = JwtUtils.createToken(map);
21.         String userJson = objectMapper.writeValueAsString(dbUser);
22.         redisTemplate.opsForValue().set(RedisConstants.TOKEN + token, userJson);
23.         //4.将 token 数据返回
24.         log.info("用户上线！{}", dbUser.toString());
25.         return token;
26.     }

复制代码

  问题：jwt 为什么要在 redis 上保存一份？  
  JWT 一旦生成，有效期内不绝有效，无法被销毁，如果不这样保存大概会导致以下情况：

• 如果 jwt 用户登录身份鉴权，也就意味着再 JWT 有效期内，用户无法退出登录.
  
• 一旦黑客攻击，已经拿到用户的权限，在服务器上乱搞，作为管理员也没有办法，如果之前用 redis 存储过，此时，就可以就可以直接删除 redis 上的 token
  

因此需要搭配 redis 来销毁 JWT，具体做法就是 jwt 在 redis 上也存储一份，当用户登录时，先查验 redis 上是否存有 jwt（如果 redis 上没有 jwt，就不往后执行了，直接返回失败信息），再用 jwt 工具查验令牌是否有效. 因此就可以通过删除 redis 上的 jwt 到达销毁 jwt 的目的了.

退出登录：退出登录时从 redis 上删除 token（相当于销毁 JWT 令牌）.

1.     @SneakyThrows
2.     @Override
3.     public void logout(String token) {
4.         //1.非空校验
5.         if(token == null) {
6.             log.info("token 数据异常！");
7.             throw new ApplicationException(AppResult.fail("token 数据异常！"));
8.         }
9.         //2.从 redis 上获取用户信息(用来打印日志)
10.         String userJson = redisTemplate.opsForValue().get(RedisConstants.TOKEN + token);
11.         log.info("用户退出登录！{}", userJson);
12.         //3.从 redis 上删除该用户的 token 数据
13.         redisTemplate.delete(RedisConstants.TOKEN + token);
14.     }

复制代码

  Ps：这里就不用判断 JWT 是否有效了，因为即使过期无效，用户也是退出登录，不影响整体业务逻辑.
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。