Jwt（Json web token）——从Http协议到session+cookie到Token &amp； Jwt介绍 &amp； Jwt的应用：登陆验证的流程_jwt

本文链接：https://blog.csdn.net/2401_87109598/article/details/142170763


![在这里插入图片描述](https://img-blog.csdnimg.cn/f8f95d2d07694058837ccc89c868080f.png)


#### token的内容被改过



> 
> com.auth0.jwt.exceptions.JWTDecodeException
> 
> 
>

package com.tianju.redisDemo.jwt;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class JavaJwtTest1 {
public static void main(String[] args) throws InterruptedException {
// 定义头部header
Map<String,Object> header = new HashMap<>();
header.put(“alg”, “HS256”);

    // 私钥
    String salt = "pet";

    String token = JWT.create()
            .withHeader(header)
            .withClaim("username", "tom")
            .withExpiresAt(new Date(System.currentTimeMillis() + 1000 \* 3)) // 60s之后过期
            .sign(Algorithm.HMAC256(salt.getBytes()));
    System.out.println(token);

    token = token.replaceAll("[a-zA-Z]","X");


    JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("pet")).build();
    DecodedJWT verify = jwtVerifier.verify(token);
    System.out.println(verify.getClaim("username"));
}

}


![在这里插入图片描述](https://img-blog.csdnimg.cn/de8f8d72420242b08d5e839446230295.png)


#### token的载荷被更改


![在这里插入图片描述](https://img-blog.csdnimg.cn/d2af33d10c044fb0aefbd10dbf55ed1f.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/8f7c351cd5a643f6a78d1ba32f3b0fec.png)

package com.tianju.redisDemo.jwt;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

public class JavaJwtTest1 {
public static void main(String[] args) throws InterruptedException {
// 定义头部header
Map<String,Object> header = new HashMap<>();
header.put(“alg”, “HS256”);

    // 私钥
    String salt = "pet";

    String token = JWT.create()
            .withHeader(header)
            .withClaim("username", "tom")
            .withExpiresAt(new Date(System.currentTimeMillis() + 1000 \* 60 \* 30)) //
            .sign(Algorithm.HMAC256(salt.getBytes()));
    System.out.println("登陆成功产生token："+token);

// token = token.replaceAll(“[a-zA-Z]”,“X”);

    String hackToken = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2ODk3Nzk1MjMsInVzZXJuYW1lIjoicGV0In0.laRjGZsM5nq8IYPBMSYCbMdxyFMiXaZXKg9F7WL-n-Q";

    System.out.println("被改过的token："+hackToken);
    JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256("pet")).build();
    DecodedJWT verify = jwtVerifier.verify(hackToken);
    System.out.println(verify.getClaim("username"));
    System.out.println("签名："+ verify.getSignature());
}

}


## Jwt的应用：登陆验证的流程


![在这里插入图片描述](https://img-blog.csdnimg.cn/33e4888f638148908f3c10cfd81cd8aa.png)



> 
> 整体的流程：
> 
> 
> 第一步：产生30分钟有效时间的token；
> 
> 
> 第二步：在redis里面存储token，redis里面有效时间为60分钟；
> 
> 
> 第三步：token过期，但是Redis里面的token还没有过期，此时进行续期；
> 
> 
> 第四步：给原有的token续期，需要设置最大续期时间，目前用最大续期次数解决；
> 
> 
> 


### 用户表



> 
> 用户名、密码、电话号码、邮箱
> 
> 
> 


![在这里插入图片描述](https://img-blog.csdnimg.cn/78832746df334aa9a9def01adae7489a.png)


user.java实体类

package com.tianju.redisDemo.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName(“user_owner”)
public class User {
@TableId(value = “id”,type = IdType.AUTO)
private Integer id;
@TableField(“username”)
private String username;

@TableField("realname")
private String realName;

@TableField("password")
private String password;

@TableField("tel")
private String tel;

@TableField("security\_key")
private String securityKey;

@TableField("create\_time")
private Date createTime;

}


### dao数据库


UserMapper.java文件

package com.tianju.redisDemo.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.tianju.redisDemo.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper {

}


### service业务



> 
> 处理登陆业务：抛出异常：
> 
> 
> （1）throw new UsernameIsEmptyException(“输入为空异常”);
> 
> 
> （2）throw new UsernameNotFoundException(“用户名不存在异常”); 后面用布隆过滤器
> 
> 
> （3）throw new UsernameOrPasswordErrorException(“用户名或者密码错误异常”);
> 
> 
>

package com.tianju.redisDemo.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.tianju.redisDemo.dao.UserMapper;
import com.tianju.redisDemo.entity.User;
import com.tianju.redisDemo.exception.UsernameIsEmptyException;
import com.tianju.redisDemo.exception.UsernameNotFoundException;
import com.tianju.redisDemo.exception.UsernameOrPasswordErrorException;
import com.tianju.redisDemo.service.IUserService;
import com.tianju.redisDemo.vo.UserVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;

@Service
@Transactional
@Slf4j
public class UserServiceImpl implements IUserService {

@Autowired
private UserMapper userMapper;

@Autowired
private StringRedisTemplate stringRedisTemplate;

@Override
public List<UserVo> queryAll() {
    List<UserVo> userVolist = new LinkedList<>();
    List<User> userList = userMapper.selectList(null);
    for (User user : userList) {
        userVolist.add(
                new UserVo(user.getUsername(), user.getRealName(), user.getCreateTime())
        );
    }
    return userVolist;

}


/\*\*

* 登陆的业务
* @param username
* @param password
*/
@Override
public User login(String username, String password) {
if (usernamenull || passwordnull||
“”.equals(username)||“”.equals(password)){
// 抛出异常，USERNAME_IS_EMPTY_EXCEPTION
throw new UsernameIsEmptyException(“输入为空异常”);
}
// 判断用户名是否存在
LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(User::getUsername,username);
User user = userMapper.selectOne(lambdaQueryWrapper);

    if (Objects.isNull(user)){
        // 用户名不存在
        // 抛出异常：USERNAME\_NOT\_FOUND\_EXCEPTION
        throw new UsernameNotFoundException("用户名不存在异常");
    }

    if (!user.getPassword().equals(password)){
        // 密码不对
        // 抛出异常：USERNAME\_OR\_PASSWORD\_ERROR\_EXCEPTION
        throw  new UsernameOrPasswordErrorException("用户名或者密码错误异常");
    }

    log.debug("用户名{}登陆系统成功",username);
    return user;
}

}


### 定义异常


![在这里插入图片描述](https://img-blog.csdnimg.cn/6b1cd67203cf405ea0e75a728699474f.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/4ac2829b35724d13990dd47fe4e8c004.png)

package com.tianju.redisDemo.exception;

/**
* 非法用户
*/
public class IllegalUserException extends RuntimeException{
public IllegalUserException(String message) {
super(message);
}
}

package com.tianju.redisDemo.exception;

/**
* 用户名。或者密码未输入异常
*/
public class UsernameIsEmptyException extends RuntimeException{
public UsernameIsEmptyException(String message) {
super(message);
}
}

package com.tianju.redisDemo.exception;

/**
* 用户未登录
*/
public class UserNotLoginException extends RuntimeException{
public UserNotLoginException(String message) {
super(message);
}
}


#### 异常的拦截处理



> 
> controller层调用service时，会抛出异常，捕获controller层的异常，进行处理，返回响应
> 
> 
>

package com.tianju.redisDemo.exception.handle;

import com.auth0.jwt.exceptions.TokenExpiredException;
import com.tianju.redisDemo.dto.HttpResp;
import com.tianju.redisDemo.dto.ResultCode;
import com.tianju.redisDemo.exception.*;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.Date;

/**
* 拦截controller层的异常，捕获异常，进行处理；
* 用户登陆异常
*/
@RestControllerAdvice
public class UserExceptionHandler {

@ExceptionHandler(UsernameIsEmptyException.class)
public HttpResp usernameIsEmptyHandler(UsernameIsEmptyException e){
    return new HttpResp(ResultCode.USER\_LOGIN\_ERROR,new Date(),e.getMessage());
}
@ExceptionHandler(UsernameNotFoundException.class)
public HttpResp usernameNotFoundHandler(UsernameNotFoundException e){
    return new HttpResp(ResultCode.USER\_LOGIN\_ERROR,new Date(),e.getMessage());
}
@ExceptionHandler(UsernameOrPasswordErrorException.class)
public HttpResp usernameOrPasswordErrorHandler(UsernameOrPasswordErrorException e){
    return new HttpResp(ResultCode.USER\_LOGIN\_ERROR,new Date(),e.getMessage());
}

@ExceptionHandler(UserNotLoginException.class)
public HttpResp userNotLoginHandler(UserNotLoginException e){
    return new HttpResp(ResultCode.USER\_LOGIN\_ERROR,new Date(),e.getMessage());
}
@ExceptionHandler(IllegalUserException.class)
public HttpResp illegalUserHandler(IllegalUserException e){
    return new HttpResp(ResultCode.USER\_LOGIN\_ERROR,new Date(),e.getMessage());
}

// @ExceptionHandler(TokenExpiredException.class)
// public HttpResp tokenExpiredHandler(TokenExpiredException e){
// return new HttpResp(ResultCode.USER_LOGIN_ERROR,new Date(),e.getMessage());
// }

@ExceptionHandler(UserNeedRenewTokenException.class)
public HttpResp userNeedRenewTokenHandler(UserNeedRenewTokenException e){
    return new HttpResp(ResultCode.USER\_LOGIN\_ERROR,new Date(),e.getMessage());
}

}


![在这里插入图片描述](https://img-blog.csdnimg.cn/6b1cd67203cf405ea0e75a728699474f.png)


### controller层


UserController.java文件

package com.tianju.redisDemo.controller;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.tianju.redisDemo.dto.HttpResp;
import com.tianju.redisDemo.dto.ResultCode;
import com.tianju.redisDemo.entity.User;
import com.tianju.redisDemo.service.IUserService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import io.swagger.models.auth.In;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@Api(tags = “用户Api”)
@RestController
@RequestMapping(“/api/user”)
@Slf4j
public class UserController {

@Autowired
private StringRedisTemplate stringRedisTemplate;

@Autowired
private IUserService userService;

@Value("${lifespanToken}")
private Integer lifespanToken;

@Value("${lifespanRedis}")
private Integer lifespanRedis;

@ApiOperation(value = "login",notes = "用户登陆api")
@ApiImplicitParams({
        @ApiImplicitParam(name = "username",required = true),
        @ApiImplicitParam(name = "password",required = true)
})
@PostMapping("/login")
public HttpResp login(String username, String password, HttpServletResponse response,HttpServletRequest request){
    User user = userService.login(username, password);// 这里有可能出现异常
    // 能走到这一步，说明登陆成功，产生token

    // 第一步：产生30分钟有效时间的token
    String securityKey = user.getSecurityKey();
    String token = createToken(username, securityKey);

    // 存入redis里面，用户名和秘钥，以token为键，所以只要token被改动，就会认为非法用户
    stringRedisTemplate.opsForHash().put(token, "username", username);
    stringRedisTemplate.opsForHash().put(token, "securityKey", securityKey);

    // redis过期晚一点，双token机制
    // 第二步：在redis里面存储token，redis里面有效时间为60分钟；
    stringRedisTemplate.expireAt(token, new Date(System.currentTimeMillis()+lifespanRedis));

    // 3.token要给前端
    response.addHeader("bm\_token",token);

    // 在session里面存续期的次数
    request.getSession().setAttribute("renewTokenTimes", 0);
    return HttpResp.results(ResultCode.USER\_LOGIN\_SUCCESS,new Date(),token);

}

/\*\*

* 产生token对象
* @param username 用户名
* @param securityKey 安全码
* @return
*/
private String createToken(String username,String securityKey){
Map<String,Object> header = new HashMap<>();
header.put(“alg”, “HS256”);
// 链式写法
return JWT.create()
.withHeader(header)
.withClaim(“username”, username)
// .withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 3)) // 60*30
// 第一步：产生30分钟有效时间的token
.withExpiresAt(new Date(System.currentTimeMillis() + lifespanToken)) // 60*30
.sign(Algorithm.HMAC256(securityKey.getBytes()));
}

@ApiOperation(value = "findAll",notes = "用户登陆api")
@GetMapping("/findAll")
public HttpResp findAll(){
    // 使用拦截器处理没有token的情况
    return HttpResp.results(ResultCode.USER\_FIND\_SUCCESS,new Date(),userService.queryAll());
}

}


#### swagger测试


![在这里插入图片描述](https://img-blog.csdnimg.cn/fe7ef12c5c2340a3bafed7e3d143500a.png)  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/ed73fbb5dd9b41e7b0797418565488a9.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/d541d165409f467b85b7171375616cdb.png)


![在这里插入图片描述](https://img-blog.csdnimg.cn/abefc2658fc6459abeff8d78a8ab9e94.png)


### 使用拦截器统一拦截方式



> 
> AuthInterceptor.java文件  
>  TokenExpiredException异常
> 
> 
> 


![在这里插入图片描述](https://img-blog.csdnimg.cn/bf368ce7a2fe4d1bbb2f560be3392f8f.png)

package com.tianju.redisDemo.interceptor;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.tianju.redisDemo.exception.IllegalUserException;
import com.tianju.redisDemo.exception.UserNeedRenewTokenException;
import com.tianju.redisDemo.exception.UserNotLoginException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

@Slf4j
@Component
public class AuthInterceptor implements HandlerInterceptor {

@Autowired
private StringRedisTemplate stringRedisTemplate;

@Value("${lifespanToken}")
private Integer lifespanToken;

@Value("${lifespanRedis}")
private Integer lifespanRedis;

@Value("${MAX\_RENEW\_TOKEN\_TIME}")
private Integer MAX\_RENEW\_TOKEN\_TIME;// 最大续期次数

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    String token = request.getHeader("bm\_token");
    if (token==null || "".equals(token)){
        throw new UserNotLoginException("用户没有登陆");
    }
    // 如何获取token
    String securityKey = (String) stringRedisTemplate.opsForHash().get(token, "securityKey");
    if (securityKey==null){
        throw new IllegalUserException("非法用户");
    }

    // 过期异常，篡改异常

    JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(securityKey)).build();
    try {
        // 如果token过期，会抛出com.auth0.jwt.exceptions.TokenExpiredException
        DecodedJWT decodedJWT = jwtVerifier.verify(token);
    } catch (TokenExpiredException e) { // token过期，redis没有过期
        // 第三步：token过期，但是Redis里面的token还没有过期，此时进行续期
        String username = (String) stringRedisTemplate.opsForHash().get(token, "username");

        // 方案一：产生新的token给前端；

// String newToken = removeTokenMakeNewToken(token, username, securityKey);
// response.addHeader(“bm_token”,token);

        // 方案二：给原有的token续期，需要设置最大续期时间
        Integer renewTokenTimes = (Integer) request.getSession().getAttribute("renewTokenTimes");
        request.getSession().setAttribute("renewTokenTimes",renewTokenTimes+1);

        // 产生一个新的token，更新redis
        log.info( ">>>>>>>>>"+username+"的token过期，即将进行续期，续期次数："+renewTokenTimes);

        if (renewTokenTimes<MAX\_RENEW\_TOKEN\_TIME){
            System.out.println("我输续期");
            stringRedisTemplate.expireAt(token, new Date(System.currentTimeMillis()+lifespanRedis));
        }
        else {
            System.out.println("不再续期");
            throw new UserNeedRenewTokenException("达到最大续期次数，需要重新登陆");
        }
    }
    return true;
}

private String removeTokenMakeNewToken(String token,String username,String securityKey){
    // 1.产生新的token
    Map<String,Object> header = new HashMap<>();
    header.put("alg", "HS256");
    // 链式写法
    String newToken = JWT.create()
            .withHeader(header)
            .withClaim("username", username)

// .withExpiresAt(new Date(System.currentTimeMillis() + 1000 * 3)) // 60*30
.withExpiresAt(new Date(System.currentTimeMillis() + lifespanToken)) // 60*30
.sign(Algorithm.HMAC256(securityKey.getBytes()));

    // 2.更新redis
    stringRedisTemplate.opsForHash().delete(token,"\*"); // 删除之前的token
    stringRedisTemplate.opsForHash().put(newToken, "username", username);
    stringRedisTemplate.opsForHash().put(newToken, "securityKey", securityKey);
    // redis过期晚一点，双token机制
    stringRedisTemplate.expireAt(newToken, new Date(System.currentTimeMillis()+lifespanRedis));

    // 3.新的token还要给前端
    return newToken;

// response.addHeader(“bm_token”,token);
}
}


![在这里插入图片描述](https://img-blog.csdnimg.cn/368910c6971446018f582426195326a1.png)



> 
> 配置拦截器 @Configuration
> 
> 
>

package com.tianju.redisDemo.config;

import com.tianju.redisDemo.interceptor.AuthInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

@Configuration
public class BmMvcConfig implements WebMvcConfigurer {

@Resource
private AuthInterceptor authInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
    registry.addInterceptor(authInterceptor)
            .addPathPatterns("/api/\*\*")
            .excludePathPatterns("/api/user/login");
}

}


### Vo对象给前端



> 
> 只给前端部分数据信息
> 
> 
>

package com.tianju.redisDemo.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserVo {
private String username;
private String name;
private Date createTime;
}


### DTO对象


#### 日期json问题



> 
> [@JsonFormat]( )(timezone = “GMT+8”)
> 
> 
> 


HttpResp.java文件

package com.tianju.redisDemo.dto;

import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.*;

import java.io.Serializable;
import java.util.Date;

/**
* 返回给前端的响应
* @param
*/
@ApiModel(“DTO返回数据”)
@Data
@NoArgsConstructor
@AllArgsConstructor
public class HttpResp implements Serializable {
private ResultCode resultCode;
@ApiModelProperty(“time”)
@JsonFormat(pattern = “yyyy-MM-dd hh:mm:ss”,timezone = “GMT+8”)
private Date time;
@ApiModelProperty(“results”)
private T result;

public static <T> HttpResp <T> results(
        ResultCode resultCode,
        Date time,
        T results){

    HttpResp httpResp = new HttpResp();
    httpResp.setResultCode(resultCode);
    httpResp.setTime(time);
    httpResp.setResult(results);
    return httpResp;
}

}


#### 枚举类型的json化



> 
> [@JsonFormat]( )(shape = JsonFormat.Shape.OBJECT)
> 
> 
> @Getter
> 
> 
> 


ResultCode.java枚举类

package com.tianju.redisDemo.dto;

import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;

/**
* 枚举类型，http请求的返回值
*/
// 枚举类型的json化，需要有get方法
@JsonFormat(shape = JsonFormat.Shape.OBJECT)
@Getter
public enum ResultCode {
BOOK_RUSH_SUCCESS(20010,“图书抢购成功”),
BOOK_RUSH_ERROR(3001,“图书抢购失败”),
LUA_SCRIPT_ERROR(3002,“Lua脚本操作失败”),
USER_FIND_ERROR(40010,“非法请求，布隆过滤器不通过”),
USER_FIND_SUCCESS(20010,“查询用户名成功”),
USER_LOGIN_ERROR(40030,“用户登陆失败”),
USER_LOGIN_SUCCESS(20020,“用户登陆成功”),
;

@ApiModelProperty("状态码")
private Integer code;

@ApiModelProperty("提示信息")
private String msg;

private ResultCode(Integer code,String msg){
    this.code =code;
    this.msg = msg;
}

}


### application.yml配置文件

server:
port: 9099

token的过期时间是30分钟；redis的过期时间是90分钟

lifespanToken: 6000 # 1000*60*30
lifespanRedis: 20000 # 1000*60*90
MAX_RENEW_TOKEN_TIME: 1 # 最大续期次数

spring:

redis的相关配置

redis:
host: localhost
port: 6379
database: 0

mysql的相关配置

datasource:
druid:
url: jdbc:mysql://127.0.0.1/community?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true
username: root
password: 123
driver-class-name: com.mysql.cj.jdbc.Driver

日志需要配置一下

logging:
level:
com.tianju.redisDemo: debug

mybatis-plus的日志

mybatis-plus:
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

knife需要允许

knife4j:
enable: true


### pom文件

<?xml version="1.0" encoding="UTF-8"?>

4.0.0

<groupId>org.tianju.jwt</groupId>
<artifactId>jwt_demo</artifactId>
<version>1.0-SNAPSHOT</version>

<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<!-- 起步依赖-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.6.13</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- redis的包-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>

    <!-- 图片验证码-->
    <dependency>
        <groupId>com.oopsguy.kaptcha</groupId>
        <artifactId>kaptcha-spring-boot-starter</artifactId>
        <version>1.0.0-beta-2</version>
    </dependency>

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

ncy>
org.springframework.boot
spring-boot-starter-data-redis

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>

    <!-- 图片验证码-->
    <dependency>
        <groupId>com.oopsguy.kaptcha</groupId>
        <artifactId>kaptcha-spring-boot-starter</artifactId>
        <version>1.0.0-beta-2</version>
    </dependency>

[外链图片转存中…(img-uwq9ckyu-1726111497326)]
[外链图片转存中…(img-1uoEANMW-1726111497327)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。