Token与JWT

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

四、SpringBoot整合JWT

 Gitee地址：​​https://gitee.com/zhang-zhixi/springboot-jwt​​

测试：

　　登录接口没有添加拦截器，可以正常进行登录。

登录成功返回token信息：

继续去请求/user/test接口，注意要带上token，将token放到请求头中，否则会在拦截器中出现错误：

token不正确也是会出现错误，只有正确的token才会放行请求：