accessToken

1、介绍

accessToken，通常是用于身份验证和授权的令牌,它可以用于前端和后端，具体使用方式取决于应用程序的架构和需求。

1. 前端应用
   accessToken通常用于向后端API发送请求时进行身份验证和授权。
   （1）前端应用程序会在用户登录成功后获取accessToken；
   （2）并将accessToken存储在本地;
   （3）然后在每次请求API时，将accessToken作为请求头或参数发送给后端；
   （4）后端会验证accessToken的有效性，并根据权限决定是否允许请求。
2. 后端应用
   accessToken通常用于验证客户端的身份和权限
   （1）后端应用程序会接收到前端发送的accessToken；
   （2）对accesToken进行验证；
   （3）验证方式：
   1）通过访问授权服务器进行验证；
   2）通过解析和验证accessToken的签名来确保其有效性。

2、后端生成accessToken

2.1 生成accessToken基本思想

accessToken通常是由后端生成的
在前后端分离的架构中，前端通过向后端发送用户名和密码等凭证（安全的身份验证机制）进行身份验证，后端验证成功后会生成一个唯一的accessToken（其通常是一个加密的字符串，用于标识用户的身份和权限），并将其存储在后端服务器数据库中或（作为一个临时的令牌）返回给前端，前端将其保存到本地。

前端在后续的请求中携带这个accessToken,后端通过验证accessToken的有效性来确认用户的身份和权限；

2.2 生成accessToken基本步骤

后端生成accessToken的过程通常是为了实现用户认证和授权功能，生成accessToken常见的方式：
（1）用户登录：用户在前端提供用户名和密码进行登录；
（2）后端验证：后端接收到用户的登录请求后，会验证用户提供的用户名和密码是否正确；
（3）生成accessToken：如果验证（用户名和密码等均正确）通过，后端会生成一个唯一的accessToken，并将其与用户信息关联起来，accessToken可以是一个随机字符串或使用加密算法生成的token；
（4）返回accessToken：后端将生成的accessToken返回给前端，前端可以将其保存在本地，以便后续的请求中使用；
（5）鉴权：前端在后续的请求中携带accessToken，后端会对accessToken进行验证，以确定请求是否来自己经登录过的用户。

2.3 后端生成accessToken具体实现

3、后端返回给前端accessToken

4、后端验证accessToken

后端生成accessToken
后端返回给前端accessToken
后端验证accessToken

5、注意点

（1）accessToken的有效性：accessToken通常具有一定的有效期限制，以确保安全性，一旦accessToken过期，客户端需要重新进行身份验证，并获取新的accessToken；
（2）确保accessToken安全性：可使用加密算法（HMAC-SHA256）将用户身份信息和必要信息（过期时间和权限）与一个密钥进行加密；

问题：

1. 什么是过期时间，权限？
2. 如何使用用户登录信息+过期时间+权限，生成accessToken？
3. 生成的accessToken保存到哪里（前端和后端都要保存吗）？
   redis中
4. 保存到数据库，如何保存，保存后，用户再次发起请求如何验证？
   返回给前端、后端保留到redis，从redis中获取并进行验证
5. 如何验证过期时间
6. 前端传过来的accessToken是什么样的？

6、实现生成token并保存到redis具体代码

6.1 依赖

 <!-- redis 缓存操作:提供了一些自动配置和默认的Redis连接工厂 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

<!--        JWT依赖-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

6.2 生成token的工具类

package com.XXXX.util;

import com.alibaba.fastjson.JSONObject;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

/**
 * 生成accessToken(用户id+登录用户名+角色)
 */
public class TokenUtil {
    private static final String ALGORITHM = "HmacSHA256";
    private static final String SECRET_KEY = "cccccc";

    public static String generateAccessToken(Integer id,String username, String roleName) {
        try {
            // 创建一个随机的密钥
            byte[] secretKeyBytes = SECRET_KEY.getBytes(StandardCharsets.UTF_8);
            SecretKeySpec secretKeySpec = new SecretKeySpec(secretKeyBytes, ALGORITHM);

            // 创建JSON对象
            JSONObject json = new JSONObject();
            json.put("id",id);
            json.put("username", username);
            json.put("role", roleName);

            // 将JSON对象转换为字符串
            String jsonString = json.toString();

            // 使用密钥对字符串进行加密
            Mac hmacSha256 = Mac.getInstance(ALGORITHM);
            hmacSha256.init(secretKeySpec);
            byte[] encryptedBytes = hmacSha256.doFinal(jsonString.getBytes(StandardCharsets.UTF_8));

            // 将加密后的字节数组进行Base64编码
            String accessToken = Base64.getEncoder().encodeToString(encryptedBytes);

            return accessToken;
        } catch (Exception  e) {
            e.printStackTrace();
        }
        return null;
    }
}

6.3 redis相关工具

package com.XXXX.util.redis;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }
}

6.4 生成token并保存到redis

/**
     * 生成token并保存到redis中
     *
     * @param manager
     * @return
     */
    @PostMapping("/access")
    @ResponseBody
    public R accessToken(@RequestBody Manager manager) {
        String id = String.valueOf(manager.getId());
        long expireTimeInSeconds = 10;  //设置时效（秒为单位）
//        1.生成accessToken
        String s = TokenUtil.generateAccessToken(manager.getId(), manager.getUsername(), manager.getRoleName());
//        2.存入accessToken
        redisTemplate.opsForValue().set(id, s, expireTimeInSeconds, TimeUnit.SECONDS);
        Object o = redisTemplate.opsForValue().get(id);
        System.out.println("redis:" + o);


        logger.info(s.toString());
        System.out.println("token:" + s);
        return R.ok("成功");
    }

    /**
     * 验证redis中的数据的时效性
     *
     * @param manager
     * @return
     */
    @PostMapping("/redisTime")
    @ResponseBody
    public R timeToken(@RequestBody Manager manager) {
        String id = String.valueOf(manager.getId());
        Object o = redisTemplate.opsForValue().get(id);
        System.out.println("验证时效：" + o);
        return R.ok(o);
    }