Token与JWT

Token视频课件地址：https://www.bilibili.com/video/BV1kE411J7JQ

JWT视频课件地址：https://www.bilibili.com/video/BV1i54y1m7cP

Token与JWT的区别？

Token 和 JWT (JSON Web Token) 都是用来在客户端和服务器之间传递身份验证信息的一种方式。但是它们之间有一些区别。

Token 是一个通用术词，可以指代任何用来表示身份的字符串。它可以是任何形式的字符串，并不一定是 JWT。
JWT 是一种特殊的 Token，它是一个 JSON 对象，被编码成字符串并使用秘密密钥进行签名。JWT 可以用来在身份提供者和服务提供者之间安全地传递身份信息，因为它可以被加密，并且只有拥有秘密密钥的方能解密。

总的来说，JWT 是一种特殊的 Token，它具有更强的安全性和可靠性。

Token

令牌的生成与存储

cokkie和token存储数据的区别

区别：

Cookies：

Cookies 存储在客户端，通常在 Web 浏览器中。
Cookies 可以存储少量数据（4KB 或更少）。
Cookies 会自动随客户端发出的每一个请求一起发送到服务器。
Cookies 可用于跟踪用户的浏览历史和偏好。

Tokens：

Tokens 由服务器生成并发送给客户端。
Tokens 可以存储比 Cookies 更多的数据。
Tokens 不会自动随客户端发出的每一个请求一起发送。客户端必须在请求头中包含 token 来验证请求。
Tokens 通常用于身份验证 API 请求，并将需要在客户端和服务端之间安全传输的用户信息存储起来。

通常来说，Cookies 更适合存储少量数据，并且这些数据需要随着每一个请求一起发送，而 Tokens 则更适合存储大量数据，并用于身份验证 API 请求。

Token可以简单理解为一串不会重复的字符串，简单的流程如下图所示：

UserDTO对象

@Data
public class UserDTO {
    @JsonProperty("user_name")
    private String userName;
    @JsonProperty(value = "user_pwd")
    private String userPwd;
}

UserController

@Resource
private RedisTemplate<String, Object> redisTemplate;
@RequestMapping(value = "/login", method = RequestMethod.POST)
public R userLogin(@RequestBody UserDTO user) {
    Map<String, Object> map = new HashMap<>(16);
    // TODO 此处模拟从数据库中查询数据
    if ("zhangsan".equals(user.getUserName()) && "123".equals(user.getUserPwd())) {
        // DTO转POJO
        User userPo = new User();
        BeanUtils.copyProperties(user, userPo);
        // 登录成功，生成token令牌
        String token = UUID.randomUUID().toString();
        redisTemplate.opsForValue().set(token, userPo, 30, TimeUnit.MINUTES);
        // 将token令牌给前端
        map.put("date", token);
        map.put("message", "登录成功");
        map.put("code", HttpStatus.SC_OK);
    } else {
        return R.error(HttpStatus.SC_INTERNAL_SERVER_ERROR, "登录失败,请检查用户名或密码");
    }
    return R.ok(map);
}

测试　　

执行登录请求，登录成功后端会生成token到Redis中，并将token响应给前端　

使用Token获取登录用户

　　前端发送请求必须要携带token，后端校验token，验证通过则执行接口查询，否则提示接口校验失败信息。

/**
 * 从token中获取用户登录信息
 *
 * @param request 请求
 * @return 用户信息
 */
@GetMapping("/getUserOfLogin")
public R getUserOfLogin(HttpServletRequest request) {
    Map<String, Object> map = new HashMap<>(16);
    String token = request.getHeader("token");
    // 从Redis中获取用户登录信息
    Object userToRedis = redisTemplate.opsForValue().get(token);
    if (userToRedis != null) {
        // 将token令牌给前端
        map.put("date", userToRedis);
        map.put("message", "登录成功");
        map.put("code", HttpStatus.SC_OK);
        return R.ok(map);
    }
    return R.error(HttpStatus.SC_UNAUTHORIZED, "token校验失败");
}

token不正确的情况：

前端：localStorage的使用

localStorage和sessionStorage是前端进行存储数据的两大对象，localStorage和sessionStorage是两种用于在浏览器端存储数据的技术。它们的主要区别在于数据的生命周期不同：

localStorage存储的数据是永久性的，除非你手动删除它，否则它会一直存在，即使你关闭浏览器或者离开网站。
sessionStorage存储的数据是临时性的，只存在于当前会话中（即当前浏览器窗口或标签页）。当你关闭浏览器窗口或切换到其他标签页时，sessionStorage中的数据会被清空。

这两种存储方式都是通过JavaScript接口来使用的，并且在使用方式上也有很多相似之处。例如，你可以使用setItem()方法来存储数据，使用getItem()方法来获取数据，使用removeItem()方法来删除单个数据项，或者使用clear()方法来清空所有数据。

<script>
    // 在localStorage中存储一个名为"username"的数据项
    localStorage.setItem("username", "John");
    // 在sessionStorage中存储一个名为"userid"的数据项
    sessionStorage.setItem("userid", "123456");
    // 从localStorage中获取名为"username"的数据项
    let username = localStorage.getItem("username");
    console.log("username", username);
    // 从sessionStorage中获取名为"userid"的数据项
    let userid = sessionStorage.getItem("userid");
    console.log("userid", userid);
    // 清空localStorage中的数据
    localStorage.clear();
</script>

这样我们可以在每次登录成功后将token数据放到localStorage中去，然后每次请求后端接口携带token进行请求即可。

JWT

一、什么是JWT

JSON Web Token

JSON Web Token (JWT)是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的。

1.1 什么时候你应该用JSON Web Token

下列场景中使用JSON Web Token是很有用的：

Authorization (授权) : 这是使用JWT的最常见场景。一旦用户登录，后续每个请求都将包含JWT，允许用户访问该令牌允许的路由、服务和资源。单点登录是现在广泛使用的JWT的一个特性，因为它的开销很小，并且可以轻松地跨域使用。
Information Exchange (信息交换) : 对于安全的在各方之间传输信息而言，JSON Web Tokens无疑是一种很好的方式。因为JWT可以被签名，例如，用公钥/私钥对，你可以确定发送人就是它们所说的那个人。另外，由于签名是使用头和有效负载计算的，您还可以验证内容没有被篡改。

1.2 认证流程

在这里插入图片描述

首先，前端通过Web表单将自己的用户名和密码发送到后端的接口。这一过程一般是一个HTTP POST请求。建议的方式是通过SSL加密的传输(https协议) ，从而避免敏感信息被嗅探。
后端核对用户名和密码成功后，将用户的id等其他信息作为JWT Payload (负载)，将其与头部分别进行Base64编码拼接后签名，形成一个JWT(Token)。形成的JWT就是一个形同11. zzz. xxx的字符串。token head . payload . singurater
后端将JWT字符串作为登录成功的返回结果返回给前端。前端可以将返回的结果保存在localStorage或sessionStorage上，退出登录时前端删除保存的JWT即可。
前端在每次请求时将JWT放入HTTP Header中的Authorization位。 (解决XSS和XSRF问题)
后端检查是否存在，如存在验证JWT的有效性。例如，检查签名是否正确;检查Token是否过期;检查Token的接收方是否是自己(可选)
验证通过后后端使用JWT中包含的用户信息进行其他逻辑操作，返回相应结果。

1.3 JWT优势在哪?

简洁(Compact):可以通过URL，POST参数或者在HTTP header发送，因为数据量小，传输速度也很快自包含(Self-contained):负载中包含了所有用户所需要的信息，避免了多次查询数据库
因为Token是以JSON加密的形式保存在客户端的，所以JWT是跨语言的，原则上任何web形式都支持。
不需要在服务端保存会话信息，特别适用于分布式微服务。

1.4 JWT具体包含信息

header 标头通常由两部分组成:令牌的类型(即JWT) 和所使用的签名算法，例如HMAC SHA256或RSA。它会使用Base64 编码组成JWT 结构的第一部分。注意:Base64是一种编码，也就是说，它是可以被翻译回原来的样子来的。它并不是一种加密过程

{
    "alg" : "HS256"
    "typ" : "JWT"
}

Payload 令牌的第二部分是有效负载，其中包含声明。声明是有关实体(通常是用户)和其他数据的声明。同样的，它会使用Base64 编码组成JWT结构的第二部分

{
    "sub" : "HS256"
    "name" : "wang"
    "admin" : "true"
}

Signature 前面两部分都是使用Base64进行编码的，即前端可以解开知道里面的信息。Signature 需要使用编码后的header和payload以及我们提供的一个密钥，然后使用header 中指定的签名算法(HS256) 进行签名。签名的作用是保证JWT没有被篡改过。

HMACSHA256(base64Ur1Encode(header) + "." + base64Ur1Encode(payload) , secret);

二、演示JWT加密过程

1、pom依赖

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

    <!--引入mybatis-->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.2.2</version>
    </dependency>

    <!--引入jwt-->
    <dependency>
        <groupId>com.auth0</groupId>
        <artifactId>java-jwt</artifactId>
        <version>4.2.1</version>
    </dependency>

    <!--引入mysql-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

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

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

2、测试令牌的创建与获取

// @SpringBootTest
class SpringbootJwtApplicationTests {

    //令牌获取
    @Test
    void contextLoads() {
        Map<String, Object> map = new HashMap<>();

        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.SECOND, 2000);

        String token = JWT.create().withHeader(map) //header
                .withClaim("userId", 21)//payload
                .withClaim("username", "xiaochen")//payload
                .withExpiresAt(instance.getTime())//指定令牌的过期时间
                .sign(Algorithm.HMAC256("!Q@W#E$R"));//签名
        System.out.println(token);
    }

    //令牌验证:根据令牌和签名解析数据
    //常见异常：
    //SignatureVerificationException 签名不一致异常
    //TokenExpiredException 令牌过期异常
    //AlgorithmMismatchException 算法不匹配异常
    //InvalidClaimException 失效的payload异常
    @Test
    void test() {
        String token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2NzIwNjM4OTYsInVzZXJJZCI6MjEsInVzZXJuYW1lIjoieGlhb2NoZW4ifQ.wDUepBf8JAlacAr-4-ZJbC5BPjL4lLN52Ci7RK1z5cc";
        DecodedJWT decode = JWT.decode(token);
        System.out.println("用户Id：" + decode.getClaim("userId").asInt());
        System.out.println("用户名：" + decode.getClaim("username"));
        System.out.println("过期时间：" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(decode.getExpiresAt()));
        //用户Id：21
        //用户名："xiaochen"
        //过期时间：2022-12-26 22:11:36
    }
}

三、JWT工具类的封装

application.properties

#JWT令牌-密钥
emos.jwt.secret=abc123456
#令牌过期时间（天）
emos.jwt.expire=5

JWTUtil

package com.zhixi.utils;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import org.springframework.beans.factory.annotation.Value;

import java.util.Calendar;
import java.util.Map;
/**
 * @ClassName JWTUtil
 * @Author zhangzhixi
 * @Description jwt工具类
 * @Date 2022/8/18 16:42
 * @Version 1.0
 */
@SuppressWarnings("all")
@Component
public class JWTUtil {

    //密钥
    private static String secret;

    //过期时间（天）
    private static int expire;

    @Value("${emos.jwt.secret}")
    public void setSecret(String secret) {
        JWTUtil.secret = secret;
    }

    @Value("${emos.jwt.expire}")
    public void setExpire(int expire) {
        JWTUtil.expire = expire;
    }

    /**
     * 生成token
     */
    public static String createToken(Map<String, String> map) {
        JWTCreator.Builder builder = JWT.create();

        //payload（存储的键值对）
        map.forEach(builder::withClaim);

        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.DATE, expire);
        // 指定令牌的过期时间
        builder.withExpiresAt(instance.getTime());

        // JWT令牌
        return builder.sign(Algorithm.HMAC256(secret));
    }

    /**
     * 验证token+获取token中的 payload
     */
    public static DecodedJWT verify(String token) {
        //如果有任何验证异常，此处都会抛出异常
        DecodedJWT decodedJWT = JWT.require(Algorithm.HMAC256(secret)).build().verify(token);
        return decodedJWT;
    }
}