1
@Configuration
2
@Slf4j
3
public class RedisConfiguration {
4

5
    @Bean
6
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
7
        log.info("开始创建redis模板对象...");
8
        RedisTemplate redisTemplate = new RedisTemplate();
9
        //设置redis的连接工厂对象
10
        redisTemplate.setConnectionFactory(redisConnectionFactory);
11
        //设置redis key的序列化器
12
        redisTemplate.setKeySerializer(new StringRedisSerializer());
13
        return redisTemplate;
14
    }
15
}

1
<dependency>
2
    <groupId>com.github.xingfudeshi</groupId>
3
    <artifactId>knife4j-openapi3-jakarta-spring-boot-starter</artifactId>
4
    <version>4.6.0</version>
5
</dependency>

1
springdoc:
2
  swagger-ui:
3
    path: /swagger-ui.html
4
    tags-sorter: alpha
5
    operations-sorter: alpha
6
  api-docs:
7
    path: /v3/api-docs
8
  group-configs:
9
    - group: 'default'
10
      paths-to-match: '/**'
11
      packages-to-scan: com.example.project.controller # 替换为你的Controller包路径

1
package com.shine.blog.config;
2

3
import io.swagger.v3.oas.models.OpenAPI;
4
import io.swagger.v3.oas.models.info.Contact;
5
import io.swagger.v3.oas.models.info.Info;
6
import org.springframework.context.annotation.Bean;
7
import org.springframework.context.annotation.Configuration;
8

9
@Configuration
10
public class Knife4jConfig {
11
    @Bean
12
    public OpenAPI customOpenAPI() {
13
        return new OpenAPI()
14
                .info(new Info()
15
                        .title("ShineBlog 后端接口文档")
16
                        .contact(new Contact().name("ShineAcZ").email("your@email.com"))
17
                        .version("1.0")
18
                        .description("基于 Spring Boot 3 + JWT + Redis 的博客系统接口文档"));
19
    }
20
}

1
@RestController
2
@RequestMapping("body")
3
@Tag(name = "body参数")
4
public class BodyController {
5

6
   @Operation(summary = "普通body请求")
7
   @PostMapping("/body")
8
   public ResponseEntity<FileResp> body(@RequestBody FileResp fileResp){
9
       return ResponseEntity.ok(fileResp);
10
   }
11

12
   @Operation(summary = "普通body请求+Param+Header+Path")
13
   @Parameters({
14
           @Parameter(name = "id",description = "文件id",in = ParameterIn.PATH),
15
           @Parameter(name = "token",description = "请求token",required = true,in = ParameterIn.HEADER),
16
           @Parameter(name = "name",description = "文件名称",required = true,in=ParameterIn.QUERY)
17
   })
18
   @PostMapping("/bodyParamHeaderPath/{id}")
19
   public ResponseEntity<FileResp> bodyParamHeaderPath(@PathVariable("id") String id,@RequestHeader("token") String token, @RequestParam("name")String name,@RequestBody FileResp fileResp){
20
       fileResp.setName(fileResp.getName()+",receiveName:"+name+",token:"+token+",pathID:"+id);
21
       return ResponseEntity.ok(fileResp);
22
   }
23
}

1
server:
2
  port: 8080
3
  servlet:
4
    context-path: /api

1
@Component
2
public class JwtUtils {
3

4
    // 秘钥：确保足够长
5
    private final String SECRET_STR = "your-super-secret-key-at-least-32-characters-long";
6
    private final SecretKey KEY = Keys.hmacShaKeyFor(SECRET_STR.getBytes(StandardCharsets.UTF_8));
7
    private final long EXPIRATION = 86400000; // 24小时
8

9
    // 生成 Token：传入用户唯一 ID
10
    public String createToken(Long userId) {
11
        return Jwts.builder()
12
                .setSubject(String.valueOf(userId)) // 将 ID 转为字符串存入 Subject
13
                .setIssuedAt(new Date())
14
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION))
15
                .signWith(KEY, SignatureAlgorithm.HS256)
16
                .compact();
17
    }
18

19
    // 解析 Token 获取用户 ID
20
    public Long getUserId(String token) {
21
        Claims claims = Jwts.parserBuilder()
22
                .setSigningKey(KEY)
23
                .build()
24
                .parseClaimsJws(token)
25
                .getBody();
26
        return Long.parseLong(claims.getSubject()); // 返回 Long 类型 ID
27
    }
28
}

1
@Component
2
public class JwtFilter extends OncePerRequestFilter {
3
    @Autowired
4
    private JwtUtils jwtUtils;
5

6
    @Override
7
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
8
            throws ServletException, IOException {
9
        // 获取请求头中的Authorization
10
        String authHeader = request.getHeader("Authorization");
11

12
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
13
            String token = authHeader.substring(7);
14
            try {
15
                // 解析出用户 ID
16
                Long userId = jwtUtils.getUserId(token);
17

18
                // 将 ID 存入认证对象
19
                UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken(
20
                        userId, null, new ArrayList<>());
21
                SecurityContextHolder.getContext().setAuthentication(auth);
22
            } catch (Exception e) {
23
                // Token 无效或过期，不处理，Security 会自动拦截
24
            }
25
        }
26
        filterChain.doFilter(request, response);
27
    }
28
}

1
import io.swagger.v3.oas.annotations.media.Schema;
2
import lombok.Data;
3

4
// 1. 登录请求对象
5
@Data
6
@Schema(description = "用户登录请求参数")
7
public class LoginRequest {
8
    @Schema(description = "用户名", example = "admin", requiredMode = Schema.RequiredMode.REQUIRED)
9
    private String username;
10

11
    @Schema(description = "密码", example = "123456", requiredMode = Schema.RequiredMode.REQUIRED)
12
    private String password;
13
}
14

15
// 2. 刷新 Token 请求对象
16
@Data
17
@Schema(description = "刷新Token请求参数")
18
public class RefreshTokenRequest {
19
    @Schema(description = "长效刷新令牌", example = "eyJhbGciOiJIUzI1...", requiredMode = Schema.RequiredMode.REQUIRED)
20
    private String refreshToken;
21
}
22

23
// 3. 统一 Token 响应对象
24
@Data
25
@Schema(description = "认证响应信息")
26
public class TokenResponse {
27
    @Schema(description = "访问令牌 (短效)", example = "eyJhbGciOiJIUzI1...")
28
    private String accessToken;
29

30
    @Schema(description = "刷新令牌 (长效)", example = "eyJhbGciOiJIUzI1...")
31
    private String refreshToken;
32

33
    @Schema(description = "过期时间(秒)", example = "1800")
34
    private long expiresIn;
35
}

1
/**
2
 * JWT 工具类 * * @author ShineAcZ
3
 * @date 2026/1/10
4
 */@Component
5
public class JwtUtils {
6

7
    @Autowired
8
    JwtProperties jwtProperties;
9

10
    private Key key;
11

12
    // 2. 初始化 Key 对象
13
    // @PostConstruct 保证在 secret 注入后执行    @PostConstruct
14
    public void init() {
15
        // 使用 hmacShaKeyFor 替代 secretKeyFor
16
        // 必须使用 UTF-8 转换，防止乱码        this.key = Keys.hmacShaKeyFor(jwtProperties.getSecret().getBytes(StandardCharsets.UTF_8));
17
    }
18

19
    /**
20
     * 生成 Access Token     ** @param userId   用户UUID
21
     * @param username 用户名 (放入 payload 显示用)
22
     */    public String createAccessToken(String userId, String username) {
23
        return Jwts.builder()
24
                .setSubject(userId) // 标准字段 sub 存 UUID
25
                .claim("username", username) // 自定义字段存用户名
26
                .claim("type", "access")
27
                .setIssuedAt(new Date())
28
                .setExpiration(new Date(System.currentTimeMillis() + jwtProperties.getAccessExpire()))
29
                .signWith(key)
30
                .compact();
31
    }
32

33
    /**
34
     * 生成 Refresh Token     * 仅存储 UUID 即可     */    public String createRefreshToken(String userId) {
35
        return Jwts.builder()
36
                .setSubject(userId)
37
                .claim("type", "refresh")
38
                .setIssuedAt(new Date())
39
                .setExpiration(new Date(System.currentTimeMillis() + jwtProperties.getRefreshExpire()))
40
                .signWith(key)
41
                .compact();
42
    }
43

44
    public Claims parseToken(String token) {
45
        return Jwts.parserBuilder()
46
                .setSigningKey(key)
47
                .build()
48
                .parseClaimsJws(token)
49
                .getBody();
50
    }
51

52
    public boolean validateToken(String token) {
53
        try {
54
            parseToken(token);
55
            return true;
56
        } catch (Exception e) {
57
            return false;
58
        }
59
    }
60

61
    // 辅助方法：直接获取 UUID
62
    public String getUserId(String token) {
63
        return parseToken(token).getSubject();
64
    }
65

66
}

1
UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken(
2
        userId, null, new ArrayList<>());
3

4
        SecurityContextHolder.getContext().setAuthentication(auth);

1
// 在 Controller 中获取当前用户 ID
2
String userId = (String) SecurityContextHolder.getContext().getAuthentication().getPrincipal();

1
/**
2
 * Jwt拦截过滤器 * * @author ShineAcZ
3
 * @date 2026/1/10
4
 */@Component
5
@Slf4j
6
public class JwtFilter extends OncePerRequestFilter {
7
    @Autowired
8
    private JwtUtils jwtUtils;
9

10
    private final ObjectMapper objectMapper = new ObjectMapper();
11

12
    @Override
13
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
14
            throws ServletException, IOException {
15
        // 获取请求头中的Authorization
16
        String authHeader = request.getHeader("Authorization");
17

18
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
19
            String token = authHeader.substring(7);
20
            try {
21
                // 解析 Token 并获取 Claims
22
                Claims claims = jwtUtils.parseToken(token);
23

24
                // 验证 Token 类型必须是 access
25
                String tokenType = claims.get("type", String.class);
26
                if (!"access".equals(tokenType)) {
27
                    log.warn("尝试使用非 Access Token 访问接口: type={}", tokenType);
28
                    writeErrorResponse(response, ErrorCode.TOKEN_INVALID, "请使用 Access Token 访问接口");
29
                    return;
30
                }
31

32
                // 提取用户 ID
33
                String userId = claims.getSubject();
34

35
                // 将 ID 存入认证对象
36
                UsernamePasswordAuthenticationToken auth = new UsernamePasswordAuthenticationToken(
37
                        userId, null, new ArrayList<>());
38
                SecurityContextHolder.getContext().setAuthentication(auth);
39

40
            } catch (io.jsonwebtoken.ExpiredJwtException e) {
41
                log.debug("Token 已过期: {}", e.getMessage());
42
                writeErrorResponse(response, ErrorCode.TOKEN_EXPIRED);
43
                return;
44
            } catch (io.jsonwebtoken.SignatureException e) {
45
                log.debug("Token 签名无效: {}", e.getMessage());
46
                writeErrorResponse(response, ErrorCode.TOKEN_INVALID, "Token 签名无效");
47
                return;
48
            } catch (io.jsonwebtoken.MalformedJwtException e) {
49
                log.debug("Token 格式错误: {}", e.getMessage());
50
                writeErrorResponse(response, ErrorCode.TOKEN_INVALID, "Token 格式错误");
51
                return;
52
            } catch (Exception e) {
53
                log.error("Token 验证失败: {}", e.getMessage(), e);
54
                writeErrorResponse(response, ErrorCode.TOKEN_INVALID);
55
                return;
56
            }
57
        }
58
        filterChain.doFilter(request, response);
59
    }
60

61
    /**
62
     * 写入错误响应     */    private void writeErrorResponse(HttpServletResponse response, ErrorCode errorCode) throws IOException {
63
        writeErrorResponse(response, errorCode, errorCode.getDescription());
64
    }
65

66
    /**
67
     * 写入错误响应 (自定义描述)     */    private void writeErrorResponse(HttpServletResponse response, ErrorCode errorCode, String description)
68
            throws IOException {
69
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED); // 401
70
        response.setContentType("application/json;charset=UTF-8");
71

72
        Result<Void> result = new Result<>(errorCode, description);
73
        String jsonResponse = objectMapper.writeValueAsString(result);
74

75
        response.getOutputStream().write(jsonResponse.getBytes(StandardCharsets.UTF_8));
76
        response.getOutputStream().flush();
77
    }
78
}

1
@Override
2
public TokenVO login(UserLoginDTO userLoginDTO) {
3
    // 1. 校验
4
    if (userLoginDTO == null) {
5
        throw new BusinessException(ErrorCode.PARAM_ERROR, "参数不能为空");
6
    }
7
    if (StrUtil.hasBlank(userLoginDTO.getEmail(), userLoginDTO.getPassword())) {
8
        throw new BusinessException(ErrorCode.PARAM_ERROR, "参数不能为空");
9
    }
10
    // 邮箱必须合法
11
    if (!ReUtil.isMatch(RegexConstant.EMAIL_REGEX, userLoginDTO.getEmail())) {
12
        throw new BusinessException(ErrorCode.PARAM_ERROR, "邮箱格式错误");
13
    }
14
    // 密码不能小于8位 不能超过20位 并且必须有至少一位字母
15
    if (!ReUtil.isMatch(RegexConstant.PASSWORD_REGEX, userLoginDTO.getPassword())) {
16
        throw new BusinessException(ErrorCode.PARAM_ERROR, "密码不合法");
17
    }
18

19
    // 2. 对密码进行加密
20
    String encryptPassword = DigestUtils.md5DigestAsHex((SALT + userLoginDTO.getPassword()).getBytes());
21

22
    // 3. 查询用户是否存在
23
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
24
    queryWrapper.eq("email", userLoginDTO.getEmail());
25
    User user = usersMapper.selectOne(queryWrapper);
26
    if (user == null) {
27
        throw new BusinessException(ErrorCode.USER_NOT_FOUND, "用户不存在");
28
    }
29

30
    // 4. 密码是否正确
31
    if (!Objects.equals(user.getPassword(), encryptPassword)) {
32
        throw new BusinessException(ErrorCode.PARAM_ERROR, "密码错误");
33
    }
34

35
    // 5. 生成双Token
36
    String accessToken = jwtUtils.createAccessToken(user.getUserId());
37
    String refreshToken = jwtUtils.createRefreshToken(user.getUserId());
38
    long expiresIn = jwtProperties.getAccessExpire() / 3600;
39

40
  // 6. redis 存储 Refresh Token
41
String refreshKey = RedisConstant.REFRESH_TOKEN_KEY + user.getUserId();
42
redisTemplate.opsForValue().set(refreshKey, refreshToken, jwtProperties.getRefreshExpire(),
43
        java.util.concurrent.TimeUnit.MILLISECONDS);
44

45

46
    TokenVO tokenVO = new TokenVO();
47
    tokenVO.setAccessToken(accessToken);
48
    tokenVO.setRefreshToken(refreshToken);
49
    tokenVO.setExpiresIn(expiresIn);
50
    return tokenVO;
51
}

1
@Operation(summary = "用户登录", description = "使用邮箱和密码进行登录，成功后返回访问令牌对象")
2
@PostMapping("/login")
3
public Result<TokenVO> login(@RequestBody UserLoginDTO userLoginDTO) {
4
    if (userLoginDTO == null) {
5
        throw new BusinessException(ErrorCode.PARAM_ERROR, "参数不能为空");
6
    }
7
    TokenVO tokenVO = userService.login(userLoginDTO);
8
    return ResultUtils.success(tokenVO);
9
}

1
@Override
2
public TokenVO refreshToken(RefreshTokenDTO refreshToken) {
3
    // 1. 校验
4
    if (refreshToken == null || StrUtil.isBlank(refreshToken.getRefreshToken())) {
5
        throw new BusinessException(ErrorCode.PARAM_ERROR, "参数不能为空");
6
    }
7

8
    // 2. 解析 Refresh Token
9
    String userId;
10
    try {
11
        userId = jwtUtils.parseToken(refreshToken.getRefreshToken()).getSubject();
12
    } catch (Exception e) {
13
        throw new BusinessException(ErrorCode.TOKEN_INVALID, "Refresh Token 无效");
14
    }
15

16
    // 3. 从 Redis 获取存储的 Refresh Token
17
    String refreshKey = RedisConstant.REFRESH_TOKEN_KEY + userId;
18
    String storedRefreshToken = redisTemplate.opsForValue().get(refreshKey);
19
    if (StrUtil.isBlank(storedRefreshToken) ||
20
            !storedRefreshToken.equals(refreshToken.getRefreshToken())) {
21
        throw new BusinessException(ErrorCode.TOKEN_INVALID, "Refresh Token 无效");
22
    }
23

24
    // 4. 生成新的双 Token
25
    String newAccessToken = jwtUtils.createAccessToken(userId);
26
    String newRefreshToken = jwtUtils.createRefreshToken(userId);
27
    long expiresIn = jwtProperties.getAccessExpire() / 3600;
28

29
    // 5. 更新 Redis 中的 Refresh Token
30
    redisTemplate.opsForValue().set(refreshKey, newRefreshToken, jwtProperties.getRefreshExpire(),
31
            java.util.concurrent.TimeUnit.MILLISECONDS);
32

33
    TokenVO tokenVO = new TokenVO();
34
    tokenVO.setAccessToken(newAccessToken);
35
    tokenVO.setRefreshToken(newRefreshToken);
36
    tokenVO.setExpiresIn(expiresIn);
37
    return tokenVO;
38
}

1
    @Operation(summary = "刷新访问令牌", description = "使用刷新令牌获取新的访问令牌")
2
    @PostMapping("/refresh-token")
3
    public Result<TokenVO> refreshToken(
4
            @Parameter(description = "刷新令牌", required = true) @RequestBody RefreshTokenDTO refreshTokenDTO) {
5
        if (refreshTokenDTO == null || refreshTokenDTO.getRefreshToken().isEmpty()) {
6
            throw new BusinessException(ErrorCode.PARAM_ERROR, "刷新令牌不能为空");
7
        }
8
        TokenVO tokenVO = userService.refreshToken(refreshTokenDTO);
9
        return ResultUtils.success(tokenVO);
10
    }

1
@Override
2
public void logout() {
3
    // 使用抛异常的版本,确保用户已登录(如果没登录 这里会被过滤)
4
    String userId = jwtUtils.getUserIdFromContext();
5

6
    // 删除 Refresh Token
7
    String refreshKey = RedisConstant.REFRESH_TOKEN_KEY + userId;
8
    try {
9
        redisTemplate.delete(refreshKey);
10
        log.info("用户 {} 登出成功", userId);
11
    } catch (Exception e) {
12
        log.error("删除 Refresh Token 失败: userId={}", userId, e);
13
        // 继续执行,不影响登出流程
14
    }
15

16
    // 清理 SecurityContext
17
    SecurityContextHolder.clearContext();
18
}

1
@PostMapping("/logout")
2
@Operation(summary = "用户登出")
3
public Result<Boolean> logout() {
4
    try {
5
        // 直接退出 如果不抛异常就直接返回成功
6
        userService.logout();
7
        return ResultUtils.success();
8
    } catch (BusinessException e) {
9
        if (e.getCode() == ErrorCode.UNAUTHORIZED.getCode()) {
10
            return ResultUtils.error(ErrorCode.UNAUTHORIZED);
11
        }
12
        throw e;
13
    }
14
}

1
    @Operation(summary = "测试接口", description = "用于测试Token验证是否通过")
2
    @GetMapping("/hello")
3
    public Result<String> hello() {
4
        return ResultUtils.success("如果看到这个表明token验证通过");
5
    }

1
POST http://localhost:8080/api/user/login
2
Content-Type: application/json
3

4
{
5
  "email": "a1223030128@163.com",
6
  "password": "a12345678"
7
}

1
{
2
  "code": 0,
3
  "data": {
4
    "accessToken": "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiI3MTIwZTlhZS1jMjYwLTQ1YzUtOTEwNC0zZWRiODdhNmQ4YjUiLCJ0eXBlIjoiYWNjZXNzIiwiaWF0IjoxNzY4MDY2Mzc0LCJleHAiOjE3NjgwNjk5NzR9.16MK6JLtjTovdj3RFWmefFAAttxrJFtOKuPCTO2iOWw",
5
    "refreshToken": "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiI3MTIwZTlhZS1jMjYwLTQ1YzUtOTEwNC0zZWRiODdhNmQ4YjUiLCJ0eXBlIjoicmVmcmVzaCIsImlhdCI6MTc2ODA2NjM3NCwiZXhwIjoxNzY4NjcxMTc0fQ.wHnMiu_nlWVUkuMzu1Wve9b2bHmqnfM-Y46xQomOsmY",
6
    "expiresIn": 3600
7
  },
8
  "message": "ok",
9
  "description": ""
10
}

1
GET http://localhost:8080/api/user/hello
2
Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiI3MTIwZTlhZS1jMjYwLTQ1YzUtOTEwNC0zZWRiODdhNmQ4YjUiLCJ0eXBlIjoiYWNjZXNzIiwiaWF0IjoxNzY4MDY3MDU0LCJleHAiOjE3NjgwNzA2NTR9.jtUIrNjD0CMI38vtx_E0yZA7-Q4Q0t9wy8Kt3LR19Lw

1
{
2
  "code": 0,
3
  "data": "如果看到这个表明token验证通过",
4
  "message": "ok",
5
  "description": ""
6
}

1
POST http://localhost:8080/api/user/refresh-token
2
Content-Type: application/json
3
Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiI3MTIwZTlhZS1jMjYwLTQ1YzUtOTEwNC0zZWRiODdhNmQ4YjUiLCJ0eXBlIjoicmVmcmVzaCIsImlhdCI6MTc2ODA2NzA1NCwiZXhwIjoxNzY4NjcxODU0fQ.Wrruv3z2gCygn0GZNseRB-H576FyB6Jvef-fUX5tIqI
4

5
{
6
  "refreshToken": "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiI3MTIwZTlhZS1jMjYwLTQ1YzUtOTEwNC0zZWRiODdhNmQ4YjUiLCJ0eXBlIjoicmVmcmVzaCIsImlhdCI6MTc2ODA2NzA1NCwiZXhwIjoxNzY4NjcxODU0fQ.Wrruv3z2gCygn0GZNseRB-H576FyB6Jvef-fUX5tIqI"
7
}

1
{
2
  "code": 0,
3
  "data": {
4
    "accessToken": "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiI3MTIwZTlhZS1jMjYwLTQ1YzUtOTEwNC0zZWRiODdhNmQ4YjUiLCJ0eXBlIjoiYWNjZXNzIiwiaWF0IjoxNzY4MDY3MzY1LCJleHAiOjE3NjgwNzA5NjV9.OQR3bbw9BzCnBIUowjBC-zTVUaMvaY9ME_AvhbjVu0c",
5
    "refreshToken": "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiI3MTIwZTlhZS1jMjYwLTQ1YzUtOTEwNC0zZWRiODdhNmQ4YjUiLCJ0eXBlIjoicmVmcmVzaCIsImlhdCI6MTc2ODA2NzM2NSwiZXhwIjoxNzY4NjcyMTY1fQ.EZfgLq1Brma2foH-g3wUlWQA55tdLH2Z_aUqblrVinI",
6
    "expiresIn": 1000
7
  },
8
  "message": "ok",
9
  "description": ""
10
}

1
GET http://localhost:8080/api/user/hello
2
Authorization: Bearer eyJhbGci1iJIUzI1NiJ9.eyJzdWIiOiI3MTIwZTlhZS1jMjYwLTQ1YzUtOTEwNC0zZWRiODdhNmQ4YjUiLCJ0eXBlIjoicmVmcmVzaCIsImlhdCI6MTc2ODA2NzA1NCwiZXhwIjoxNzY4NjcxODU0fQ.Wrruv3z2gCygn0GZNseRB-H576FyB6Jvef-fUX5tIqI

1
{
2
  "code": 20301,
3
  "data": null,
4
  "message": "Token无效",
5
  "description": "Token 格式错误"
6
}