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

小鱼儿 2023-10-13 23:13 124阅读 0赞

#### 目录 ####

*  引出
 *  从Http协议到session&cookie到Token
 *   *  HTTP协议
     *  session & cookie
     *   *  session
         *  cookie
         *  为什么需要session & cookie?
     *  JavaEE传统解决长连接方案
     *  问题：分布式不适用
     *  解决方案：令牌Token
 *  Jwt，Json web token
 *   *  jwt的结构
     *  Header
     *   *  加密算法
         *  Base64 + 图片编码
     *  Payload 载荷：比如唯一的用户ID
     *   *  Registered claims
         *  Public claims
         *  Private claims
         *  Payload案例
     *  Signature：签名
 *  jwt使用初步
 *   *  导包
     *  生成token
     *  解析token
     *  获取token的内容
     *  验证token
     *  几种token验证的情况
     *   *  token的过期时间
         *  token的内容被改过
         *  token的载荷被更改
 *  Jwt的应用：登陆验证的流程
 *   *  用户表
     *  dao数据库
     *  service业务
     *  定义异常
     *   *  异常的拦截处理
     *  controller层
     *   *  swagger测试
     *  使用拦截器统一拦截方式
     *  Vo对象给前端
     *  DTO对象
     *   *  日期json问题
         *  枚举类型的json化
     *  application.yml配置文件
     *  pom文件
 *  总结

## 引出 ##

--------------------

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][https_gitee.com_pet365_springboot-jwt-demo]

## 从Http协议到session&cookie到Token ##

### HTTP协议 ###

特点

*  无记忆性（无状态）
 *  请求响应
    
    短连接
    
    被动请求

### session & cookie ###

#### session ####

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

#### cookie ####

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

#### 为什么需要session & cookie? ####

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

![在这里插入图片描述][d80cb26038c04f3287d6ae821232e700.png]

### JavaEE传统解决长连接方案 ###

![在这里插入图片描述][935533bbc45e47bfb761e0aeaa4a69e1.png]

![在这里插入图片描述][6338191fa2e24b18a7bae887b5a8b2e8.png]

### 问题：分布式不适用 ###

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

session需要同步

![在这里插入图片描述][e9bdd8ed0fbd47ad80101f6ff0639a35.png]

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

![在这里插入图片描述][6ebd7a10e043447e991f593736a4693e.png]

### 解决方案：令牌Token ###

![在这里插入图片描述][2ea5d6bf7b5044fabd1f7c191e1305eb.png]

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

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

RSA算法历史：

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

目前流行的还有oauth2

## Jwt，Json web token ##

**J**SON **W**eb **T**oken（令牌）

> **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的结构 ###

![在这里插入图片描述][7b11cef1500e4a9594c6aa2c0e3de99d.png]

[官网：https://jwt.io/][https_jwt.io]

![在这里插入图片描述][f0244b1f93bd4554b854efb185094539.png]

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

![在这里插入图片描述][0c0bfc9dcce0428fa45683876cec19cd.gif_pic_center]

### Header ###

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

![在这里插入图片描述][839ca82d68dc4198a0543bc42074d6f5.png]

#### 加密算法 ####

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

#### Base64 + 图片编码 ####

![在这里插入图片描述][39c4738733ed4a87bfc516964d206ffe.png]

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

![在这里插入图片描述][bd3572827e264c6e975a7a8c8587ba3e.png]

“hello” 编码

h—01101000 e —01100101

![在这里插入图片描述][9a84e8589daa47959237871138ad7204.png]

![在这里插入图片描述][6151d4d497e748eaaccb5a4841510c86.png]

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][Base64 _ _ Base64 _ - Base64.us]

![在这里插入图片描述][7d7bb6dc7d7d455f8bfff9118a52fb25.png]

![在这里插入图片描述][f94dc734a2b7444daa7fab2829efbfc2.png]

<!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`（受众）等

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

#### 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)进行加密签名；

![在这里插入图片描述][9f7b8820be68408c88d83aa8b7378fa0.png]

> 结构

![在这里插入图片描述][0fa8bf3baca443efb7d6d169500f0ec1.png]

## jwt使用初步 ##

![在这里插入图片描述][77c44ad9ba8d46cb9144d1daa5788f44.png]

### 导包 ###

<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

![在这里插入图片描述][b95a109ecc314f568fa24cc587027f54.png]

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

![在这里插入图片描述][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"));
        }
    }

![在这里插入图片描述][de8f8d72420242b08d5e839446230295.png]

#### token的载荷被更改 ####

![在这里插入图片描述][d2af33d10c044fb0aefbd10dbf55ed1f.png]

![在这里插入图片描述][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的应用：登陆验证的流程 ##

![在这里插入图片描述][33e4888f638148908f3c10cfd81cd8aa.png]

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

### 用户表 ###

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

![在这里插入图片描述][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<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;
        }
    }

### 定义异常 ###

![在这里插入图片描述][6b1cd67203cf405ea0e75a728699474f.png]

![在这里插入图片描述][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());
        }
    }

![在这里插入图片描述][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测试 ####

![在这里插入图片描述][fe7ef12c5c2340a3bafed7e3d143500a.png]  
![在这里插入图片描述][ed73fbb5dd9b41e7b0797418565488a9.png]

![在这里插入图片描述][d541d165409f467b85b7171375616cdb.png]

![在这里插入图片描述][abefc2658fc6459abeff8d78a8ab9e94.png]

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

> AuthInterceptor.java文件  
> TokenExpiredException异常

![在这里插入图片描述][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);
        }
    }

![在这里插入图片描述][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][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][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>
    
            
            <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>
    
    
            <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>
    
    
            
            <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.maven打包springboot项目，jar包；  
2.windows安装java环境，以及运行jar包；  
3.Linux安装java环境，以及运行jar包；  
4.运行jar包template might not exist报错及解决；

[https_gitee.com_pet365_springboot-jwt-demo]: https://gitee.com/pet365/springboot-jwt-demo
[d80cb26038c04f3287d6ae821232e700.png]: https://img-blog.csdnimg.cn/d80cb26038c04f3287d6ae821232e700.png
[935533bbc45e47bfb761e0aeaa4a69e1.png]: https://img-blog.csdnimg.cn/935533bbc45e47bfb761e0aeaa4a69e1.png
[6338191fa2e24b18a7bae887b5a8b2e8.png]: https://img-blog.csdnimg.cn/6338191fa2e24b18a7bae887b5a8b2e8.png
[e9bdd8ed0fbd47ad80101f6ff0639a35.png]: https://img-blog.csdnimg.cn/e9bdd8ed0fbd47ad80101f6ff0639a35.png
[6ebd7a10e043447e991f593736a4693e.png]: https://img-blog.csdnimg.cn/6ebd7a10e043447e991f593736a4693e.png
[2ea5d6bf7b5044fabd1f7c191e1305eb.png]: https://img-blog.csdnimg.cn/2ea5d6bf7b5044fabd1f7c191e1305eb.png
[Link 1]: https://baike.baidu.com/item/%E5%AF%86%E9%92%A5
[RFC 7519]: https://tools.ietf.org/html/rfc7519
[7b11cef1500e4a9594c6aa2c0e3de99d.png]: https://img-blog.csdnimg.cn/7b11cef1500e4a9594c6aa2c0e3de99d.png
[https_jwt.io]: https://jwt.io/
[f0244b1f93bd4554b854efb185094539.png]: https://img-blog.csdnimg.cn/f0244b1f93bd4554b854efb185094539.png
[0c0bfc9dcce0428fa45683876cec19cd.gif_pic_center]: https://img-blog.csdnimg.cn/0c0bfc9dcce0428fa45683876cec19cd.gif#pic_center
[839ca82d68dc4198a0543bc42074d6f5.png]: https://img-blog.csdnimg.cn/839ca82d68dc4198a0543bc42074d6f5.png
[SHA-256]: https://link.zhihu.com/?target=https%3A//en.wikipedia.org/wiki/SHA-256
[Link 2]: https://link.zhihu.com/?target=https%3A//en.wikipedia.org/wiki/Public-key_cryptography
[39c4738733ed4a87bfc516964d206ffe.png]: https://img-blog.csdnimg.cn/39c4738733ed4a87bfc516964d206ffe.png
[bd3572827e264c6e975a7a8c8587ba3e.png]: https://img-blog.csdnimg.cn/bd3572827e264c6e975a7a8c8587ba3e.png
[9a84e8589daa47959237871138ad7204.png]: https://img-blog.csdnimg.cn/9a84e8589daa47959237871138ad7204.png
[6151d4d497e748eaaccb5a4841510c86.png]: https://img-blog.csdnimg.cn/6151d4d497e748eaaccb5a4841510c86.png
[Base64 _ _ Base64 _ - Base64.us]: https://base64.us/
[7d7bb6dc7d7d455f8bfff9118a52fb25.png]: https://img-blog.csdnimg.cn/7d7bb6dc7d7d455f8bfff9118a52fb25.png
[f94dc734a2b7444daa7fab2829efbfc2.png]: https://img-blog.csdnimg.cn/f94dc734a2b7444daa7fab2829efbfc2.png
[9f7b8820be68408c88d83aa8b7378fa0.png]: https://img-blog.csdnimg.cn/9f7b8820be68408c88d83aa8b7378fa0.png
[0fa8bf3baca443efb7d6d169500f0ec1.png]: https://img-blog.csdnimg.cn/0fa8bf3baca443efb7d6d169500f0ec1.png
[77c44ad9ba8d46cb9144d1daa5788f44.png]: https://img-blog.csdnimg.cn/77c44ad9ba8d46cb9144d1daa5788f44.png
[b95a109ecc314f568fa24cc587027f54.png]: https://img-blog.csdnimg.cn/b95a109ecc314f568fa24cc587027f54.png
[f8f95d2d07694058837ccc89c868080f.png]: https://img-blog.csdnimg.cn/f8f95d2d07694058837ccc89c868080f.png
[de8f8d72420242b08d5e839446230295.png]: https://img-blog.csdnimg.cn/de8f8d72420242b08d5e839446230295.png
[d2af33d10c044fb0aefbd10dbf55ed1f.png]: https://img-blog.csdnimg.cn/d2af33d10c044fb0aefbd10dbf55ed1f.png
[8f7c351cd5a643f6a78d1ba32f3b0fec.png]: https://img-blog.csdnimg.cn/8f7c351cd5a643f6a78d1ba32f3b0fec.png
[33e4888f638148908f3c10cfd81cd8aa.png]: https://img-blog.csdnimg.cn/33e4888f638148908f3c10cfd81cd8aa.png
[78832746df334aa9a9def01adae7489a.png]: https://img-blog.csdnimg.cn/78832746df334aa9a9def01adae7489a.png
[6b1cd67203cf405ea0e75a728699474f.png]: https://img-blog.csdnimg.cn/6b1cd67203cf405ea0e75a728699474f.png
[4ac2829b35724d13990dd47fe4e8c004.png]: https://img-blog.csdnimg.cn/4ac2829b35724d13990dd47fe4e8c004.png
[fe7ef12c5c2340a3bafed7e3d143500a.png]: https://img-blog.csdnimg.cn/fe7ef12c5c2340a3bafed7e3d143500a.png
[ed73fbb5dd9b41e7b0797418565488a9.png]: https://img-blog.csdnimg.cn/ed73fbb5dd9b41e7b0797418565488a9.png
[d541d165409f467b85b7171375616cdb.png]: https://img-blog.csdnimg.cn/d541d165409f467b85b7171375616cdb.png
[abefc2658fc6459abeff8d78a8ab9e94.png]: https://img-blog.csdnimg.cn/abefc2658fc6459abeff8d78a8ab9e94.png
[bf368ce7a2fe4d1bbb2f560be3392f8f.png]: https://img-blog.csdnimg.cn/bf368ce7a2fe4d1bbb2f560be3392f8f.png
[368910c6971446018f582426195326a1.png]: https://img-blog.csdnimg.cn/368910c6971446018f582426195326a1.png
[JsonFormat]: https://github.com/JsonFormat