Comment résoudre le problème du stockage des jetons utilisateur dans Redis

Redis stocke les jetons utilisateur

Lors de la conception d'un système similaire au commerce électronique, une exigence courante est que chaque page doit contenir des informations sur l'utilisateur connecté.

Il existe deux solutions courantes :

• Utiliser des cookies pour enregistrer

• Utiliser JWT pour enregistrer

Mais si le cache Redis est utilisé dans le système, il existe également une troisième solution : mettre en cache les jetons utilisateur. dans Redis.

Générez un jeton et stockez-le dans Redis lorsque vous vous connectez

//生成一个token对象,保存在redis中
redisTemplate.opsForHash().put("token","user",user);

Lorsque chaque page est générée, fournissez le jeton

//以JSON字符串形式返回token
@RequestMapping(value = "/getToken",method = RequestMethod.GET)
@ResponseBody
public User getToken(){
    User user = (User) redisTemplate.opsForHash().get("token", "user");
    return user;
}

//发送ajax请求，获取token
function get_token(){
    $.ajax({
        url:"getToken",
        type:"GET",
        dataType:"JSON",
        success:function(result){
            //将返回的用户信息保存在token中
            var token = result;
            //打印登录用户
            console.log(token);
            //打印登录用户的id
            console.log(token.id);
            document.getElementById('username').innerText = "用户名:"+token.username;
        }
    });
}

Lorsque vous vous déconnectez, supprimez le jeton

//注销
@RequestMapping("/logout")
public String logout(){
    redisTemplate.opsForHash().delete("token","user");
    return "/login";
}

Redis gère les problèmes de jetons

java—Traitement des jetons basé sur redis  

Tout d'abord, il est clair que token : token est un moyen de traiter les informations utilisateur pour l'interaction front-end et back-end après la connexion. Il existe deux manières principales, l'une est basée sur la session stockage, et l'autre est basé sur le stockage redis. Cet article explique uniquement comment utiliser redis en tant qu'utilisateur pour le traitement des informations.   

Pour chaque interaction d'informations après la connexion d'un utilisateur, si les informations utilisateur doivent être transmises, en particulier les identifiants utilisateur et autres, il est évidemment déconseillé d'interroger la base de données à chaque fois. Nous pouvons créer une base de données dans Redis après. connexion. L'espace est utilisé pour enregistrer les informations utilisateur, et nous le récupérerons depuis Redis chaque fois que nous aurons besoin d'informations utilisateur.

Créez d'abord RedisUtil

@Component

public class RedisUtil {

    @Autowired
    private RedisTemplate redisTemplate;   //key-value是对象的

    //判断是否存在key
    public boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    //从redis中获取值
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    //向redis插入值
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            redisTemplate.opsForValue().set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    //向redis插入值带过期时间 单位:分钟
    public boolean set(final String key, Object value, long time) {
        boolean result = false;
        try {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.MINUTES);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    //redis删除值
    public boolean del(final String key) {
        return redisTemplate.delete(key);
    }

    //批量删除某个字段开始的key
    public long batchDel(String key) {
        Set<String> set = redisTemplate.keys(key + "*");
        return redisTemplate.delete(set);
    }

}

Après avoir créé RedisUtil, stockez la valeur dans redis. À ce stade, il convient de noter que notre clé doit être discutée à l'avance avec le front-end, du nom de champ à utiliser et de la clé. doit être placé dans l'en-tête lorsque les demandes frontales sont transmises, la valeur est cryptée et renvoyée au front-end après la première connexion. Après avoir obtenu les informations d'en-tête, nous devons d'abord déchiffrer la valeur et utiliser la valeur comme valeur. clé pour obtenir les informations utilisateur.

@Component
public class UserUtil {
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private HttpServletRequest request;

    /**
     * 后台管理的登录id
     *
     * @return
     */
    public JsonResult getUser() {
        String header = request.getHeader("#与前端约定的统一字段#");
        //解密
        String decrypt = DESUtil.decrypt(header);
        if (!redisUtil.hasKey(decrypt))return JsonResult.error("未登录");
        User user = null;
        try {
            user = (User) redisUtil.get(decrypt);
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (decrypt == null) return JsonResult.error("权限不足");
        return JsonResult.success(user);
    }
}

Quand nous en avons besoin

        JsonResult jsonResult = userUtil.getUser();
        if (jsonResult.getCode() != 1) return jsonResult;
        //强转成对象。此处不用担心强转失败，因为存入的时候就是对象存储，只不过为了复用，存的是object类型
        User user= (User) jsonResult.getData();
        return JsonResult.success(#service层#);
    }

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!