一、用户登录接口

请求参数：

用loginDTO来封装请求参数，要加上@RequestBody注解

响应参数：

由于data里内容较多，考虑将其封装到一个LoginUser的实体中，用户登陆后，需要生成jwtToken并返回给前端。

登录功能的service层具体实现步骤：

1.根据传进来的account或email到数据库里查，查出该用户的信息。若两者都不存在，则报错。

2.校验用户的是否存在及密码是否正确

3.生成jwt令牌。

4.修改最后登陆时间lastLoginAt

代码如下：

    @Override
    public Result<LoginVO> login(LoginDTO loginDTO) {
        User loginUser = null;
        //1.
        if(loginDTO.getAccount() == null && loginDTO.getEmail() == null){
            return ResultUtil.error("请提供用户名或邮箱！");
        }
        if(loginDTO.getAccount() == null && loginDTO.getEmail() != null){
             loginUser = userMapper.getUserByEmail(loginDTO.getEmail());
        }
        if(loginDTO.getEmail() == null && loginDTO.getAccount() != null){
             loginUser = userMapper.getUserByAccount(loginDTO.getAccount());
        }
        //2.
        if(loginUser == null){
            return ResultUtil.error("用户不存在！请注册！");
        }
        if( !loginDTO.getPassword().equals(loginUser.getPassword())){
            return ResultUtil.error("密码错误！");
        }
        //3.
        String token = jwtUtil.generateToken(loginUser.getUserId());
        loginUser.setLastLoginAt(LocalDateTime.now());
        LoginVO loginVO = new LoginVO();
        BeanUtils.copyProperties(loginUser, loginVO);
        return Result.success(loginVO , token);
    }

二、设计jwt工具类

一个jwt工具类应该包含以下几个功能：

1.生成jwt令牌

流程如下：

其中，claims是载荷，即往jwt令牌里存储的信息，后续可以通过jwt令牌获取这些信息。

使用jwts的builder()链式生成token，需要指定载荷、签发时间、过期时间、签名算法及密钥secret等信息。

2.从前端传来的jwt令牌里读取信息

    public Long getUserIdFromToken(String token) {
        try{Claims claims = Jwts.parser()
                .setSigningKey(secret)
                .parseClaimsJws(token)
                .getBody();
            Long userId = (Long) claims.get("userId");
            return userId;}
        catch(Exception e){
            return null;
        }
    }

一个天坑：

此处jwt再解析时，claims.get("userID")一定要先转换成字符串，再转换成Long，若直接使用（long），由于JWT的声明（claims）基于JSON标准，JSON不区分整数的具体类型（如Integer或Long）。当数值较小时，某些JWT实现（如JJWT）可能将其解析为Integer，而较大的数值解析为Long，直接强制类型转换会导致异常。

因此：使用Long.valueOf()来间接转换。

    public Long getUserIdFromToken(String token) {
        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
            
            return Long.valueOf(claims.get("userId").toString());
        } catch (Exception e) {
            return null;
        }
    }

3.校验jwt令牌是否有效

    //方法3. 检验令牌是否有效
    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(secret).parseClaimsJws(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

4.刷新jwt令牌

    public String refreshToken(Long userId) {
        return generateToken(userId);
    }

三、获取当前用户信息

请求：无，只需携带jwt令牌

响应如下：跟LoginUserVo是同样的

四、如何从请求中获取jwt令牌？

在第三个需求中，需要先读取jwt令牌，再从jwt令牌中读取userID信息。因此，需要从请求中获取jwt令牌。

这个需求的实现有几种方案：

1.使用threadlocal来存储和传递

2.使用request.setattribute

3.使用@RequestScope

此处选择第三种。

实现步骤：

1.定义 @RequestScope bean，需要加上@Component @RequestScope @Data 这几个注解。

这个类的作用就是每遇到一个个http请求，就会创建它，我们可以将一些数据存进去，以便后续使用。

创建时机​​：每个 HTTP 请求开始时，Spring 会创建一个新的 RequestContext 实例。

​​销毁时机​​：请求处理结束后，Spring 自动销毁该实例

@Data
@RequestScope
@Component
public class RequestContext {
    public Long userId;
    public String token;
    public Boolean isLogin;
}

RequestContext中，isLogin的作用：存储当前用户有无登录，若未登录，设置成false，只允许其访问登录和注册的服务。

2.在拦截器中注入并设置数据

3.将拦截器注册到WebConfig中

4. 在 Controller 或 Service 中使用数据​​

在需要访问请求级别数据的组件中，直接注入 RequestContext Bean。

五、拦截器怎么写

需求：每当遇到一个请求，就将他拦截下来，并从中读取jwt 令牌。

具体步骤：

1.定义一个类，它必须实现  HandlerInterceptor ，

2.重写preHandle这个方法，里面为 是否放行的逻辑

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // 对于每个请求进行拦截，获取请求头中的 token
        String token = request.getHeader("Authorization");
        // 然后对 token 进行处理，并将 token 携带的信息存储到，在请求周期中全局存在的 requestScopeData 中

        //0.token为null
        if(token == null){
            requestContext.setToken(null);
            requestContext.setUserId(null);
            requestContext.setIsLogin(false);
            return true; //不管有没有登录，或者jwt令牌合法与否，都放行，后续对这些isLogin为false的请求只开放登陆的权限
        }
        token = token.replace("Bearer", "");
        // 若令牌不合法，requestContext的登录状态设置成false
        if( ! jwtUtil.validateToken(token)){
            requestContext.setIsLogin(false);
        }else{
            requestContext.setIsLogin(true);
            requestContext.setToken(token);
            requestContext.setUserId(jwtUtil.getUserIdFromToken(token));
        }
        return true;
    }

3.配置拦截器

    //配置拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(tokenInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/login", "/error");
    }
}

六、今日踩坑小结

1.请求体若使用实体类封装 ， 必须加上@RequestBody ， 否则后端接受不到前端传来的数据

2.当前端传来的参数和方法参数不一致时使用@RequestParam注解，当然，前端传来多个参数时必须使用

@GetMapping("/user")
public String getUser(@RequestParam("id") Long userId) {
    // 通过 /user?id=123 访问时，userId=123
    return "user";
}

3.@PathVariable

4.@Param注解：mapper层定义的方法，当接受多个参数时，必须使用

// Mapper接口
public interface UserMapper {
    List<User> findUsersByConditions(
        @Param("name") String name,
        @Param("status") Integer status
    );
}