一.什么是JWT令牌？

JWT，全称JSON Web Token，官网（https://jwt.io/），定义了一种间接的，自包含的格式，用于在通信双方以json数据格式安全的传输信息。由于数字签名的存在，这些信息是可靠的。

通俗来讲，我们可以通过JWT令牌来实现对于用户登录权限的校验以此达到安全性。

二.JWT令牌的组成：

• 第一部分：Header（头），记录令牌类型以及签名算法等。eg:{"alg"="HS256","type"="JWT"}
• 第二部分：Payload（有效载荷），携带一些自定义信息以及默认信息等。eg:{"id":"1","username"="Tom"}
• 第三部分：Signature（签名），防止Token被篡改，确保安全性。将header，payload，并加入指定秘钥，通过指定签名算法计算而来。（可以用Base64编码解码工具来解析第一第二部分，第三部分不能解析，因为第三部分是根据数字签名后的结果）

三.JWT令牌操作流程：

首先在浏览器发起请求执行登录操作，此时访问登录接口，若登录成功后会生成一个JWT令牌，并将生成的JWT令牌返回给前端，前端拿到JWT令牌会将其储存起来，后序每一次的请求都会将这个JWT令牌携带到服务端，而服务端则会进行统一拦截，拦截到这个请求会判断是否携带JWT令牌，若没有携带过来则拒绝访问，若携带过来则判断JWT令牌是否有效，如果JWT令牌有效，统一拦截器就会放行，以此来进行请求对应接口的处理。 

 总结来看就是两步骤： ①生成JWT令牌     ②校验JWT令牌

四.JWT令牌的具体实现：

1.pom.xml配置文件引入依赖：

<dependency>
     <groupId>io.jsonwebtoken</groupId>
     <artifactId>jjwt</artifactId>
     <version>0.9.1</version>
</dependency>

通过此操作，可以导入依赖内的Jwts工具类。

2.JWT令牌的生成与解析：

（1）下面代码是在SpringBoot测试类中生成JWT令牌的步骤：

@SpringBootTest
public class JwtTest {

    @Test
    public void testCreateJwt(){
        //定义map集合来封装自定义数据
        Map<String,Object> claims = new HashMap<>();
        claims.put("id","1");
        claims.put("username","Tom");
        //创建JWT令牌
        String jwt = Jwts.builder()
                .signWith(SignatureAlgorithm.HS256,"秘钥") //指定数字签名的算法 , 秘钥
                .setClaims(claims)  //设置自定义数据
                .setExpiration(new Date(System.currentTimeMillis() + 3600 * 1000))  //设置JWT令牌有效期 -> 1h
                .compact();  //拿到一个字符串类型的JWT令牌
        //输出JWT令牌
        System.out.println(jwt);
    }
}

（2）下面代码是在SpringBoot测试类中解析JWT令牌的步骤：

@SpringBootTest
public class JwtTest {

    @Test
    public void testParseJwt(){
        Claims claims = Jwts.parser()
                .setSigningKey("秘钥")  //给予前面自己生成JWT令牌所设置的签名秘钥才可以解析JWT令牌
                .parseClaimsJws("Jwt令牌字符串")  //Jwt令牌字符串
                .getBody();  //拿到第二部分内容
        //输出解析的Jwt令牌内容
        System.out.println(claims);//{name=tom, id=1, exp=1670467224}
    }
}

我们需要注意解析Jwt令牌需要使用相同的签名秘钥以及要在有效时间内才可以解析，若JWT令牌解析校验时候出错，则说明JWT令牌被篡改或失效了，令牌非法。

五.JWT令牌在项目中的具体实现操作：

1.导入JwtUtil工具类：

在utils包下导入：

public class JwtUtil {
    public static String createJWT(String secretKey, long ttlMillis, Map<String, Object> claims) {
        // 指定签名的时候使用的签名算法，也就是header那部分
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

        // 生成JWT的时间
        long expMillis = System.currentTimeMillis() + ttlMillis;
        Date exp = new Date(expMillis);

        // 设置jwt的body
        JwtBuilder builder = Jwts.builder()
                // 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
                .setClaims(claims)
                // 设置签名使用的签名算法和签名使用的秘钥
                .signWith(signatureAlgorithm, secretKey.getBytes(StandardCharsets.UTF_8))
                // 设置过期时间
                .setExpiration(exp);

        return builder.compact();
    }

    public static Claims parseJWT(String secretKey, String token) {
        // 得到DefaultJwtParser
        Claims claims = Jwts.parser()
                // 设置签名的秘钥
                .setSigningKey(secretKey.getBytes(StandardCharsets.UTF_8))
                // 设置需要解析的jwt
                .parseClaimsJws(token)
                .getBody();
        return claims;
    }

}

这个工具类仔细对比上面所讲解的JWT令牌的生成与解析其实是一样的，只不过有变量的值需要我们调用方法传参过来。

2.在application.yml文件配置相关信息：

sky:
  jwt:
    # 设置jwt签名加密时使用的秘钥
    admin-secret-key: itcast
    # 设置jwt过期时间
    admin-ttl: 7200000
    # 设置前端传递过来的令牌名称
    admin-token-name: token

3.在config包下创建JWT令牌的配置属性类来封装配置文件的配置项：

（这里开启了驼峰，所以可以忽略两文件的属性名不同）

@Component
@ConfigurationProperties(prefix = "sky.jwt")
@Data
public class JwtProperties {
    /**
     * 管理端员工生成jwt令牌相关配置
     */
    private String adminSecretKey;
    private long adminTtl;
    private String adminTokenName;
}

4.在登录接口使用JWT令牌操作：

@RestController
@RequestMapping("/admin/employee")
@Slf4j
@Api(tags = "员工相关接口")
public class EmployeeController {

    @Autowired
    private EmployeeService employeeService;
    @Autowired
    private JwtProperties jwtProperties;

    @PostMapping("/login")
    @ApiOperation(value = "员工登录")
    public Result<EmployeeLoginVO> login(@RequestBody EmployeeLoginDTO employeeLoginDTO) 
    {
        log.info("员工登录：{}", employeeLoginDTO);
        //根据前端请求的数据在数据库中查询账号是否存在
        Employee employee = employeeService.login(employeeLoginDTO);

        //判断是否登录成功,若失败则抛出异常
        if(employee == null){
            throw new LoginFailedException(MessageConstant.LOGIN_FAILED);
        }
        //登录成功后，生成jwt令牌
        Map<String, Object> claims = new HashMap<>();
        claims.put("EmpId", employee.getId());
        String token = JwtUtil.createJWT(
                jwtProperties.getAdminSecretKey(),
                jwtProperties.getAdminTtl(),
                claims);
        //将token等信息封装并返回给前端
        //这里EmployeeLoginVO类上加了@Builder注解，所以可以通过调用builder().属性(属性值).build()来创建类对象
        EmployeeLoginVO employeeLoginVO = EmployeeLoginVO.builder()
                .id(employee.getId())
                .userName(employee.getUsername())
                .name(employee.getName())
                .token(token)
                .build();
        return Result.success(employeeLoginVO);
    }
}

5.JWT令牌的拦截器：

我们前面在登录接口生成了JWT令牌，所以我们需要再其他接口开校验JWT令牌的合法性。

若成功直接放行return true，若失败则响应401状态码并return false。

@Component
@Slf4j
public class JwtTokenAdminInterceptor implements HandlerInterceptor {

    @Autowired
    private JwtProperties jwtProperties;
    //此方法会在方法执行前执行
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("当前线程的id：" + Thread.currentThread().getId());
        //判断当前拦截到的是Controller的方法还是其他资源
        if (!(handler instanceof HandlerMethod)) {
            //当前拦截到的不是动态方法，直接放行
            return true;
        }

        //1、从请求头中获取令牌
        String token = request.getHeader(jwtProperties.getAdminTokenName());

        //2、校验令牌
        try {
            log.info("jwt校验:{}", token);
            //解析并获取JWT令牌第二部分内容
            Claims claims = JwtUtil.parseJWT(jwtProperties.getAdminSecretKey(), token);
            //获取JWT令牌第二部分的id值
            Long empId = Long.valueOf(claims.get(JwtClaimsConstant.EMP_ID).toString());
            log.info("当前员工的id：{}", empId);
            //利用线程记录id值（后面再获取数据库中自增的id加的代码）
            BaseContext.setCurrentId(empId);
            //3、通过，放行
            return true;
        } catch (Exception ex) {
            //4、不通过，响应401状态码
            response.setStatus(401);
            return false;
        }
    }
}

好了，JWT令牌的使用就到这里了，记得三连支持，感谢收看！！！