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

已于 2023-10-09 15:11:37 修改
阅读量737 收藏
点赞数
分类专栏： Spring全家桶技术专区 Java开发专区 文章标签： json 前端 http java spring boot
于 2023-07-24 18:13:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pireley/article/details/131901676
版权

目录

引出

1.http协议的特点，无状态，被动请求；
2.session+cookie解决浏览器的无状态问题，但是分布式不适用；
3.Jwt，Json web token，token令牌入门，头部+载荷+签名；
4.Jwt的使用初步，如果过期，报错com.auth0.jwt.exceptions.TokenExpiredException；
5.应用：登陆验证的流程；

https://gitee.com/pet365/springboot-jwt-demo

从Http协议到session&cookie到Token

HTTP协议

特点

  • 无记忆性（无状态）

  • 请求响应

    短连接

    被动请求

session & cookie

session

Session: Session存在服务器端的对象。

cookie

Cookie就是存储在浏览器的一个对象(客户端)

为什么需要session & cookie?

本质上讲 ： http协议的问题（无记忆性)。

在这里插入图片描述

JavaEE传统解决长连接方案

在这里插入图片描述

在这里插入图片描述

问题：分布式不适用

  • 只适合于单体架构,集群/分布式架构的不合适
    • Session要进行同步，比较困难（网络抖动、延迟等），有状态的
    • Cookie: 不支持跨域，前后端分离
    • 移动端(很少使用cookie)，比如微信小程序不支持cookie

session需要同步

在这里插入图片描述

  • 对于多服务器集群，每台服务器都要读取Session，共享困难。

在这里插入图片描述

解决方案：令牌Token

在这里插入图片描述

加密技术是对信息进行编码和解码的技术，编码是把原来可读信息（又称明文）译成代码形式（又称密文），其逆过程就是解码（解密），加密技术的要点是加密算法，加密算法可以分为三类：

  • 对称加密，如AES
    • 基本原理：将明文分成N个组，然后使用密钥对各个组进行加密，形成各自的密文，最后把所有的分组密文进行合并，形成最终的密文。
    • 优势：算法公开、计算量小、加密速度快、加密效率高
    • 缺陷：双方都使用同样密钥，安全性得不到保证
  • 非对称加密，如RSA
    • 基本原理：同时生成两把密钥：私钥和公钥，私钥隐秘保存，公钥可以下发给信任客户端
      • 私钥加密，持有私钥或公钥才可以解密
      • 公钥加密，持有私钥才可解密
    • 优点：安全，难以破解
    • 缺点：算法比较耗时
  • 不可逆加密，如MD5，SHA
    • 基本原理：加密过程中不需要使用密钥，输入明文后由系统直接经过加密算法处理成密文，这种加密后的数据是无法被解密的，无法根据密文推算出明文。

RSA算法历史：

1977年，三位数学家Rivest、Shamir 和 Adleman 设计了一种算法，可以实现非对称加密。这种算法用他们三个人的名字缩写：RSA

目前流行的还有oauth2

Jwt，Json web token

JSON Web Token（令牌）

JSON Web Token (JWT) is an open standard (RFC 7519) that defines a compact压缩的 and self-contained自包含的 way for securely transmitting information安全传输 between parties as a JSON object。

This information can be verified and trusted because it is digitally signed. JWTs can be signed using a secret (with the HMAC algorithm) or a public/private key pair using RSA or ECDSA.

  • 基于JSON格式用于网络传输的令牌。
  • 紧凑的Claims声明格式。
  • Claim有索赔、声称、要求或者权利要求的含义。

jwt的结构

在这里插入图片描述

官网：https://jwt.io/

在这里插入图片描述

如果改前面的，最后的签名会改变，就知道被改动过了

在这里插入图片描述

Header

Header 部分是一个 JSON 对象，描述 JWT 的元数据。

在这里插入图片描述

加密算法

  • HSA256

    SHA（Secure Hash Algorithm，安全散列算法）是一个密码散列函数家族，由美国国家安全局（NSA）设计，并由美国国家标准与技术研究院（NIST）发布，是美国的政府标准。

    • 无论输入多长，都输出64个字符，共32字节（byte），256位（bit）
    • 输出只包含数字0`9`和字母`A`F，大小写不敏感

  • RSA256

    由美国麻 省理工 学院三 位学者 Riv est、Sh amir 及Adleman 研 究发 展出 一套 可实 际使用 的公 开金 钥密码系 统，那 就是RSA(Rivest-Shamir-Adleman)密码系统。

    RS256（带有SHA-256的 RSA 签名）是一种非对称算法，它使用公钥/私钥对：身份提供者拥有用于生成签名的私钥（秘密）密钥，而 JWT 的消费者获得公钥验证签名。由于与私钥相反，公钥不需要保持安全，因此大多数身份提供者都可以让消费者轻松获取和使用（通常通过元数据 URL）。

Base64 + 图片编码

在这里插入图片描述

Base64是一种基于64个可打印字符来表示二进制数据的表示方法。Base64不是加密算法，只是一种编码方式，可以用Base64来简单的“加密”来保护某些数据，所以每 6 个比特为一个单元，对应某个可打印字符。

在这里插入图片描述

“hello” 编码

h—01101000 e —01100101

在这里插入图片描述

在这里插入图片描述

package com.tianju.redisDemo.jwt;

import org.apache.ibatis.logging.stdout.StdOutImpl;

import java.util.Base64;

public class JwtDemo {
    public static void main(String[] args) {
        String s = "h";
        // hz转成2进制：h-->ASCII值(10进制)-->2进制
        String bin = "0" + Integer.toBinaryString(s.charAt(0));
        System.out.println("h转换成2进制："+bin);
        System.out.println("截取前6位："+bin.substring(0, 6));
        // 进行base64编码
        String sBase64 = new String(Base64.getEncoder().encode(s.getBytes()));
        System.out.println(sBase64);
    }
}

Base64 在线编码解码 | Base64 加密解密 - Base64.us

在这里插入图片描述

在这里插入图片描述

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<img src="data:image/x-icon;base64,AAABAAEAEBAAAAEAIABoBAAAFgAAACgAAAAQAAAAIAAAAAEAIAAAAAAAQAQAABMLAAATCwAAAAAAAAAAAAAsLTD/CwsJ/xoeIf82QUn/Njw5/0ZGRf9LTFH/WVZX/1JVV/9iZmT/ZmNx/1dha/85Qkz/Jyct/w0HBf8OCgf/Cw0P/yEhIv87O0D/RjpI/0tBRv8uLCj/FxsS/x0eGP8bFhn/IyAl/y8xMv9xd3r/eoCJ/0NFVP8gHSX/CAUC/xQXG/8nKC//OjY4/z86Nv8RDRv/AAAZ/wAAGf8UEyL/MyEg/w8AAP8FAAD/DAgH/2hobv+FhZH/MzVA/xUSEv8+QUb/Ly43/ykiK/8BAT3/BARi/wEBaP8BAFj/LCRk/2NCO/80AAH/LAMD/x0BAf8BAAD/PDk+/2pucv82MjX/SUdY/0EvJ/8KCTH/BwWT/wcEpv8CAJr/AAF6/y0ue/+HSEz/XQAA/1EDB/8+Awb/HAEB/wgAAP9nZmr/Yl5l/01OUP8uJiX/AwN5/wMFzP8FCMj/Awa//wAArP8sMJX/lU9R/34AAP96Awb/VwME/y0EAP8XAAD/MCYp/3t6gP9cVk//JSdE/wECyP8ABu7/AQDx/wEA4v8AAMH/LTG4/6NcW/+WAAD/oQAC/5IDAf9UBQD/NwMA/x0EBf92eX7/eWNi/yQkY/8BAu3/AQD9/xwk6P9HUPD/EhPi/y4z1v+tZGD/nAAA/7UDA//RCAb/fgUB/1ICAf8mAAD/goiK/4RuZv8kHnf/AgH9/wAA9v9gce7/9//5/7+++P+Ji+3/qGZq/6MAAP+oAgn/rQcL/4YEBP9aAwH/KAEB/4+Kj/96dm3/IB5X/wYB+P8BAP3/HyXv/8bN9f//29vt/6teZv+dAAH/iwUA/3MCAf9gAwP/PgQD/xcAAP90bnX/Zm5y/yUiNP8GBcT/AgT//wAA/f8vL/L/eHfx/3J37P+tb2v/qwEA/5oBA/9sAwH/UAMD/ywBAf8mEhn/b212/11ugf9aR1D/AQFg/wUG9v8EAvz/BwD6/wAA5f8wNNT/pG1s/54AAP+NBAP/YwQB/zoCAv8NAAD/T01X/05OWP9Nb4T/Xl9f/0M1TP8AAJz/CArl/wIE6f8AALz/ODq0/7Jwbv93AAD/bgQD/0gEAP8WAAD/GxYZ/15aaP8pLDj/X5bB/2iHnP97c3n/KSg4/wMAfv8EAL7/AACc/zczoP+fYWb/YgAA/1EBAf8WAAD/HxMW/2hpdf87R1n/MTM9/zRtnf+Pxev/gpek/2pjZP9gX2z/JCNW/wAATf8bG1X/VT1C/xoAAP8gDg7/PDQ4/1pNVv9QSVr/SEtd/xIRGP9McYj/R3uU/4a+2f9Wbn//SVFQ/2lmXv9oYV//YlVd/2VVVP9eVlf/WFlf/0dKVv8zQUj/Q0xU/yAYIP8CAAT/gABseQAAMyAAAGRlAAAyNAAAdGUAAGluAAAxLAAAdXQAAG50AABBTQAAUFIAAEVTAABSXwAAVkUAADIzgAFSTw=="
style="width: 100px" height="100px">
</body>
</html>

Payload 载荷：比如唯一的用户ID

Payload 部分也是一个 JSON 对象，用来存放实际需要传递的数据。JWT 规定了7个官方字段，供选用。

Payload 也使用BASE64编码

Registered claims

这些是一组预先定义的声明，它们不是强制性的，但推荐使用，以提供一组有用的，可互操作的声明。 其中一些是：iss（发行者），exp（到期时间），sub（主题），aud（受众）等

序号名称解释
1iss (issuer)签发人
2exp (expiration time)过期时间
3sub (subject)主题
4aud (audience)受众（接收jwt的一方）
5nbf (Not Before)生效时间
6iat (Issued At)签发时间
7jti (JWT ID)jwt的唯一身份标识，
主要用来作为一次性token,
从而回避重放攻击

Public claims

这些可以由使用JWT的人员随意定义。

Private claims

这些是为了同意使用它们但是既没有登记，也没有公开声明的各方之间共享信息，而创建的定制声明。

Payload案例

{  "sub": "456781234",  "name": "Mr.zhang",  "admin": true}

Signature：签名

The signature is used to verify the message wasn’t changed along the way, and, in the case of tokens signed with a private key, it can also verify that the sender of the JWT is who it says it is.

Signature 部分是对前两部分的签名，防止数据篡改。

https://jwt.io/

Signature部分由编码后的Header、Payload和自定义的秘钥使用Header中指定的算法(HSA256)进行加密签名；

在这里插入图片描述

结构

在这里插入图片描述

jwt使用初步

在这里插入图片描述

导包

<!--        jwt的依赖-->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>4.3.0</version>
        </dependency>

生成token

package com.tianju.redisDemo.jwt;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;

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

public class JavaJwtTest {
    public static void main(String[] args) {
        // 定义头部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)) // 60s之后过期
                .sign(Algorithm.HMAC256(salt.getBytes()));
        System.out.println(token);

    }
}

获得token

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2ODk3NzY0MTUsInVzZXJuYW1lIjoidG9tIn0.kPmgw03j9g3EJAo2LLzXHd1b7H3uF5zF-0EDEaeonMY

在这里插入图片描述

解析token

DecodedJWT decode = JWT.decode(token);

获取token的内容

System.out.println("Header: " + decode.getHeader());
System.out.println("Payload: " + decode.getPayload());
System.out.println("Audience: " + decode.getAudience());
System.out.println("Signature: " + decode.getSignature());

验证token

JWTVerifier build = JWT.require(Algorithm.HMAC256(user.getPassword())).build();

获取信息

System.out.println(build.verify(token).getClaim("data"));

{“name”:”tomcat”,”username”:”tom”}

几种token验证的情况

token的过期时间

com.auth0.jwt.exceptions.TokenExpiredException

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);

        Thread.sleep(1000*5);

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

在这里插入图片描述

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"));
    }
}

在这里插入图片描述

token的载荷被更改

在这里插入图片描述

在这里插入图片描述

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的应用：登陆验证的流程

在这里插入图片描述

整体的流程：

第一步：产生30分钟有效时间的token；

第二步：在redis里面存储token，redis里面有效时间为60分钟；

第三步：token过期，但是Redis里面的token还没有过期，此时进行续期；

第四步：给原有的token续期，需要设置最大续期时间，目前用最大续期次数解决；

用户表

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

在这里插入图片描述

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<User> {

}

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 (username==null || password==null||
           "".equals(username)||"".equals(password)){
            // 抛出异常，USERNAME_IS_EMPTY_EXCEPTION
            throw new UsernameIsEmptyException("输入为空异常");
        }
        // 判断用户名是否存在
        LambdaQueryWrapper<User> 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;
    }
}

定义异常

在这里插入图片描述

在这里插入图片描述

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());
    }
}

在这里插入图片描述

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测试

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

使用拦截器统一拦截方式

AuthInterceptor.java文件
TokenExpiredException异常

在这里插入图片描述

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);
    }
}

在这里插入图片描述

配置拦截器 @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 <T>
 */
@ApiModel("DTO返回数据")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class HttpResp<T> 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"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <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>


        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.11</version>
        </dependency>

<!--        mysql相关的包-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.18</version>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3.1</version>
        </dependency>


        <!--        jwt的依赖-->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>4.3.0</version>
        </dependency>

        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>knife4j-openapi2-spring-boot-starter</artifactId>
            <version>4.0.0</version>
        </dependency>

    </dependencies>

</project>

总结

1.http协议的特点，无状态，被动请求；
2.session+cookie解决浏览器的无状态问题，但是分布式不适用；
3.Jwt，Json web token，token令牌入门，头部+载荷+签名；
4.Jwt的使用初步，如果过期，报错com.auth0.jwt.exceptions.TokenExpiredException；
5.应用：登陆验证的流程；

Arya's Blog
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
http认证JWT
weixin_45346239的博客
07-04 928
http认证JWT
【JavaWeb】Cookie和Session的使用场景
zzbzxzzdf的博客
06-30 729
Cookie 和 Session都是网页中常用的状态保持的技术，它们可以帮助网站识别用户身份，保存用户状态等，什么是 Cookie ？什么是 Session ？他们具体是什么？他们有什么区别和联系，本文将为你详细解惑，一起来看看叭~
JWT（JSON Web Token）和 HTTP（Hypertext Transfer Protocol）区别是什么
m0_74772114的博客
12-25 84
JWT 和 HTTP 是两种不同的技术
HTTP---会话机制JWT( JSON Web Token)
qq591009234的博客
04-22 461
3.会话机制JWT( JSON Web Token)会话机制（翻译：令牌） 3.1.JWT是一个非常轻巧的规范 3.2.这个规范允许我们使用JWT在用户和服务器之间传递安全可靠的信息 3.3.是服务端生成的一串字符串，作为客户端进行请求的一个标识,由三部分组成，它们之间用圆点(.)连接。 3.4.一个典型的JWT看起来是这个样子的：xxxxx.yyyyy.zzzzz 1.头部（Header）：用...
http——http基础知识——JWT详解——背诵总结
小白龙白龙马的博客
12-26 102
php-jwt:JWT（JSON Web Token）生成器、解析器、验证器和验证器的 PHP 实现
05-29
PHP-JWT 是一个用 PHP 编程语言编写的包，用于编码（生成）、解码（解析）、验证和验证 JWT（JSON Web 令牌）。 它提供了一个流畅、易于使用和面向对象的界面。 由确认。 文档 版本号 2.xx (LTS) 1.xx（不支持） ...
php实现JWT(json web token)鉴权实例详解
01-03
JWT是json web token缩写。它将用户信息加密到token里，服务器不保存任何用户信息。服务器通过使用保存的密钥验证token的正确性，只要正确即通过验证。基于token的身份验证可以替代传统的cookie+session身份验证方法...
JWT(json web token加密算法) for C# dll 文件，亲测可用
07-02
JSON Web Token（JWT）是一种开放的标准（RFC 7519），定义了一种紧凑的、自包含的方式来安全地在各方之间传输信息作为一个JSON对象。这个信息可以被验证和信任，因为它是数字签名的。JWT可用于身份验证、授权，以及...
koa+jwt实现token验证与刷新功能
01-01
JSON Web Token (JWT)是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的。 本文只讲Koa2 + jwt的使用，不了解...
HTTP基本认证和JWT鉴权
weixin_30414245的博客
11-30 536
一、HTTP基本认证 Basic Authentication——当浏览器访问使用基本认证的网站的时候， 浏览器会提示你输入用户名和密码。 http auth的过程： ·客户端发送http请求 ·服务器发现配置了http auth，于是检查request里面有没有"Authorization"的http header ·如果有，则判断Authorization里面的内容是否在用...
Jwt
玉姬的博客
10-12 767
JWT是什么 JSON Web Token (JWT)，它是目前最流行的跨域身份验证解决方案 为什么使用JWT JWT的精髓在于：“去中心化”，数据是保存在客户端的。 JWT的工作原理 是在服务器身份验证之后，将生成一个JSON对象并将其发送回用户，示例如下： {“UserName”: “Chongchong”,“Role”: “Admin”,“Expire”: “2018-08-08 20:1...
Jwt（Json web token）——从Http协议到session+cookie到Token &amp； Jwt介绍 &amp； Jwt的应用：登陆验证的流程_jwt
最新发布
2401_84563465的博客
05-16 736
jwt的依赖// 定义头部header获取信息// 定义头部header// 定义头部header// 定义头部header@Data@Mapper@Service@Slf4j* 登陆的业务。
单点登录（SSO）、JWT、HTTP详解及实例演示
BaiKnow的博客
02-07 3666
单点登录（JWT） 作者：pox21s 1.HTTP 1.1 概述 超文本传输协议（Hyper Text Transfer Protocol，HTTP）是一个简单的请求 - 响应协议，它通常运行在TCP之上。（1） 所谓的"协议"实际上就是双方约定好的"格式"让双方都能看得懂的东西，交互实际上就是"请求"和"响应"。 （1）：在HTTP/3 使用的就是 UDP 协议 1.2 发展 HTTP/1.0 HTTP/1.0 成为最重要的面向事务的应用层协议。该协议对每一次请求/响应建立并拆除一次连接。默认
HTTP API 认证技术详解（三）：JWT Authentication
路多辛的所思所想
01-15 1281
JWT（JSON Web Tokens）是一种开放标准（RFC 7519），定义了一种紧凑的、自包含的格式，用于实现网络应用程序中的身份验证和授权机制。
JWT（JSON WEB TOKEN）
S_ZaiJiangHu的博客
08-26 749
（4）JWT 的最大缺点是，由于服务器不保存 session 状态，因此无法在使用过程中废止某个 token，或者更改 token 的权限。也就是说，一旦 JWT 签发了，在到期之前就会始终有效，除非服务器部署额外的逻辑。单机当然没有问题，如果是服务器集群，或者是跨域的服务导向架构，就要求 session 数据共享，每台服务器都能够读取 session。算出签名以后，把 Header、Payload、Signature 三个部分拼成一个字符串，每个部分之间用"点"（.）分隔，就可以返回给用户。......
HTTP会话保持技术：Cookie、Session、Token、JWT
Happy_lifer的博客
05-08 1100
JWT 是 JSON Web Token 的缩写，JWT 本身没有定义任何技术实现，它只是定义了一种基于 Token 的会话管理的规则，涵盖 Token 需要包含的标准内容和 Token 的生成过程。
Jwt（Json web token）——从Http协议到session+cookie到Token &amp； Jwt介绍 &amp； Jwt的应用：登陆验证的流程_jwt(1)
2401_84563465的博客
05-16 558
获取信息// 定义头部header// 定义头部header// 定义头部header@Data@Mapper@Service@Slf4j* 登陆的业务*/@Overridenull||
身份认证——session认证机制与JWT认证机制（入门到使用）
世界和我们都不该止步于此
04-19 4415
首先我们要了解什么是身份认证（Authentication）？ 身份认证也叫身份验证或者鉴权，指通过一定的手段来完成对用户身份的验证 我们会使用session和JWT认证机制进行开发，那么我们在什么情况下使用这俩个认证机制呢？ 推荐在服务端渲染开发情况下使用session认证机制 在前后端分离的Web开发环境下使用JWT认证机制 目录 一.session认证机制 1.HTTP协议的无状态性 2.Cookie突破HTTP无状态的限制 3.Cookie的缺点 4.提高身份认证的安全性 5.
几种常用的认证机制
诚的博客
12-14 1625
HTTP Basic Auth HTTP Basic Auth在HTTP中，基本认证是一种用来允许Web浏览器或其他客户端程序在请求时提供用户名和口令形式的身份凭证的一种登录验证方式，通常用户名和明码会通过HTTP头传递。 在发送之前是以用户名追加一个冒号然后串接上口令，并将得出的结果字符串再用Base64算法编码。 例如 用户名是Aladdin、口令是open sesame，则拼接后的结果就是Aladdin:open sesame， 然后再将其用Base64编码，得到QWxhZGRpbjpvc.
Web应用认证技术探索：从Cookie到JWT
"这篇研究论文探讨了Web应用程序的认证技术，着重分析了传统方法如Cookie和会话的优缺点，并引入了OAuth2.0框架下的Json Web Token (JWT)作为新的认证方案。" Web应用程序认证技术是确保网络应用安全的重要组成部分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Arya's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值