JWT登录校验流程

jwt令牌的基本概念：

1. JWT（JSON Web Token）

• 定义：JWT 是一种开放标准（RFC 7519），用于在各方之间作为 JSON 对象安全地传输信息。它可以被验证和信任，因为它是数字签名的。
• 结构：JWT 有三个部分，每部分使用 . 分隔：
  1. Header：包含令牌的类型（通常是 JWT）和所使用的签名算法（如 HMAC SHA256 或 RSA）。
  2. Payload：包含声明（claims），即存储的信息，可以是用户信息、权限等。
  3. Signature：用于验证消息的真实性，以防止数据被篡改

和API签名认证的关系

这其实和API签名认证的过程有点像，API签名认证是在数据库字段中添加一个secretKey，然后根据前端传过来的字段拼起来根据相同的加密算法重新加密，再和数据库中的secretKey进行比对。

和传统的会话技术的对比

传统会话技术当你登录完成之后，在服务器端会生成一个session来记录你的登录态

当你登录之后，会给你的登录态设置一个值，下次访问其它接口的时候就直接检查你的登录态

传统的会话技术会将信息存储在服务器上，如果用户过多其实是有点怕存储不了的

但是传统的会话技术对用户的掌控能力更强，就是我可以直接在我的数据库中将session设置为失效，你直接就登录不了，不过对比于jwt，我们必须会设置一个过期时间，只有等过期时间过去了，你才不能登录。有利有弊。

整体的流程：

就是当你登录成功之后，系统会给你下发一个令牌，这个令牌肯定会比较复杂，拼接你的账号密码这些然后经过加密算法算出来一个字符串三个部分，三个部分就是我上面说的请求头，负载，签名。

这就是你的登录凭证了，当每次你需要调用其它接口的时候就需要这个登录凭证，说到这里也可以稍微提一下，就是我们每个方法之前都需要加一段这个判断逻辑嘛，其实可能不用，只需要配置一个全局拦截器就行。

我们从上面得流程中也能知道，我们需要在用户登录成功之后下发令牌：

先引入一个依赖：

        <!--        引入JWT令牌的依赖-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

代码：

 controller层：

@Slf4j
@RestController
@CrossOrigin
@RequestMapping("/user")
public class UserController {

    @Resource
    private NewsUserService newsUserService;

    @PostMapping("/login")
    public Result userLogin(@RequestBody UserLoginRequest userLoginRequest){
        log.info("登录接口："+userLoginRequest);
        UserLoginVO userLoginVO = newsUserService.login(userLoginRequest);
        System.out.println(userLoginVO.getToken());
        return Result.ok(userLoginVO);
    }
    
}

service层：

@Override
    public UserLoginVO login(UserLoginRequest userLoginRequest) {
        //1:取出参数查询数据进行校验
        final String userName = userLoginRequest.getUserName();
        final String userPwd = userLoginRequest.getUserPwd();
        LambdaQueryWrapper<NewsUser>  lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(NewsUser::getUsername,userName);
        final NewsUser user = this.getOne(lambdaQueryWrapper);
        //2:判断这个user是否为空
        //todo 全局异常处理器
        if(user == null){
            return null;
        }
        //3:判断这个密码是否和数据库中加密的密码一致
        if(StringUtils.isBlank(user.getUser_pwd())|| !MD5Util.encrypt(userPwd).equals(user.getUser_pwd())){
            return null;
        }
        //4:下发令牌
        Map<String,Object> claims = new HashMap<>();
        claims.put("username",user.getUsername());
        claims.put("userpassword",user.getUser_pwd());
        final String jwtToken = JwtUtils.createJwtToken(claims);
        System.out.println("jwtToken"+jwtToken);
        final UserLoginVO userLoginVO = new UserLoginVO();
        userLoginVO.setUid(user.getUid());
        userLoginVO.setToken(jwtToken);
        return userLoginVO;
    }

代码整体逻辑：

首先上来就是对前端传过来得参数进行校验

接着再从数据库中查出是否有这个用户

都确定无误之后，就开始生成令牌，这里得生成令牌我用了一个工具类JwtUtils。

生成令牌之后就要给这个登录用户发放令牌，这所谓得发放令牌就是将这个token封装在这个响应成功得实体中。

下面是响应成功得封装：

@Data
public class UserLoginVO {
    /**
     * 用户id
     */
    private Integer uid;


    /**
     * token
     */
    private String token;
}

jwt工具类：

public class JwtUtils {

    private static String salt = "abcdefg";//盐值
    private static Long expire = 43200000L;//12小时（过期时间）

    public static String createJwtToken(Map<String,Object> claims){
        final String jwt = Jwts.builder()
                .addClaims(claims)
                .signWith(SignatureAlgorithm.HS256, salt)
                .setExpiration(new Date(System.currentTimeMillis() + expire))
                .compact();
        return jwt;

    }

}

生成令牌我们调用这个Jwts.build方法

里面构建三个东西

一个是你得账号密码这些你想进行加密得东西（用Map包装起来）

 一个就是签名算法

还有一个是过期时间

小坑：

签名算法得key不能指定太短

JWT 生成token时报错：secret key byte array cannot be null or empty.

把签名算法得key或者盐值搞长点就行

---

我们现在已经把这个jwt令牌生成好了并且也下发给用户了，用户访问其它操作得时候需要带上这个令牌，下一步我们就需要去解析这个令牌了。

我们可以定义一个拦截器，我这里用得是AOP，其实我感觉用拦截器更好

拦截器和AOP得对比

拦截器：

• 拦截器通常用于请求处理链中，它会在控制器（Controller）方法被调用之前和之后执行。
• 拦截器是实现 HandlerInterceptor 接口的类，通过 Spring MVC 的 DispatcherServlet 配置来注册。

AOP：

• AOP 通过切面（Aspect）定义横切逻辑，可以在多个地方复用。具体的切面在代码中使用注解标注，Spring 会解析这些注解并自动织入到相应的地方。

 拦截器我在spingMVC那一篇中有写道

我们从上面的对比结果中可以得出，拦截器更多是用在Controller层的拦截，AOP是我们可以自己定义的。

再回顾我们的登录常见，我们是不是只需要在controller层进行一个拦截，就是在你调用其它方法的时候进行一个拦截就行。

不过话又说回来了，只要你AOP的范围选Controller层哪这个作用就和拦截器差不多了。

 说了这么多，我下面的案例是用AOP，我顺带也复习一下。

@Slf4j
@Aspect
@Component
public class LoginCheckInterceptor {

    @Resource
    private HttpServletRequest request;


    @Around("execution(* com.test.microheadline.controller..*(..))")
    public Object JwtTest(ProceedingJoinPoint point) throws Throwable {
        final String uri = request.getRequestURI();
        if(uri.contains("login")){
            return  point.proceed();
        }
        String jwt = request.getHeader("token");
        System.out.println(request);
        System.out.println("JWT令牌："+ jwt);
        final Claims claims = JwtUtils.parseJWT(jwt);
        return point.proceed();
    }
}

整体的代码逻辑：

定义一个切面类：@Aspect，并且交给IOC容器管理@Component

@Around("execution(* com.test.microheadline.controller..*(..))")，指定我们的作用范围（这里好像有更专业的词，我一时间文件了）是整个Controller

然后分析方法里面的具体逻辑:

首先我们需要从请求头中拿到jwt令牌

记住这个我们需要判断，这个路径是不是登录方法，如果是登录方法，我们都还没给他令牌，肯定

会报错

接着我们进行解析，也是调用jwt的工具类

public class JwtUtils {

    private static String salt = "abcdefg";//盐值
    private static Long expire = 43200000L;//12小时（过期时间）

    public static String createJwtToken(Map<String,Object> claims){
        final String jwt = Jwts.builder()
                .addClaims(claims)
                .signWith(SignatureAlgorithm.HS256, salt)
                .setExpiration(new Date(System.currentTimeMillis() + expire))
                .compact();
        return jwt;

    }

    public static Claims parseJWT(String jwt){
        final Claims claims = Jwts.parser()
                .setSigningKey(salt)
                .parseClaimsJws(jwt)
                .getBody();
        return claims;
    }

}

解析之后放行：return point.proceed();

这个的point是AOP的连接点，proceed就是让这个点执行下一步流程，就是放行（这里可能有点像断点）

小坑：

我们在用Knife4j进行测试的时候，我们发送这个请求的时候，这个文档不会给我们自动带上这个jwt令牌，所以我们需要登录过后获取到这个令牌之后，在这个全局变量里面设置一下