L'utilisation de la clé générique Redis et la suppression par lots de chaînes (String) et de hachage (Hash)

1. Caractère générique Redis

Dans Redis, la clé de requête floue est autorisée.

Redis prend en charge 3 types de caractères génériques: *,?, []

*: Wildcard n'importe quel nombre de caractères.

?: Joker un seul caractère.

[]: Un certain caractère entre crochets génériques.

 

2. Commande Redis Keys

La commande Keys dans Redis: utilisée pour trouver toutes les clés qui correspondent à un modèle donné.

Valeur de retour: Liste des clés (Array) conformes au modèle donné.

[Exemple] Utilisez la commande Keys et les caractères génériques pour interroger dans Redis.

 

3. Utilisez les caractères génériques Redis en Java

Redis est une puissante base de données Dans les applications pratiques, quel que soit le cadre du site Web ou du système, Redis peut être introduit dans le projet.

Créez un projet SpringBoot et intégrez le framework Redis. Pour le processus de création, veuillez parcourir les articles de ce blog:

Article recommandé: "SpringBoot intègre Redis et implémente les classes d'outils Redis"

3.1 Redis utilise des caractères génériques pour les requêtes par lots

[Exemple] Utilisez les caractères génériques Redis pour les requêtes par lots dans les programmes Java.

/**
 * Redis工具类
 */
@Autowired
private RedisUtils redisUtils;

/**
 * Redis使用通配符进行查询
 * @author pan_junbiao
 */
@Test
public void queryTest()
{
    try
    {
        //Reids中添加数据，键格式：USER::用户ID
        redisUtils.set("USER::1","pan_junbiao的博客_01");
        redisUtils.set("USER::2","pan_junbiao的博客_02");
        redisUtils.set("USER::3","pan_junbiao的博客_03");

        //Redis键：使用 * 号通配符
        String patternKey = "USER::*";

        //使用Keys命令获取匹配的key集合。
        Set<String> keySet = redisUtils.keys(patternKey);
        for(String key : keySet)
        {
            //从key键中提取用户ID
            String userId = key.replaceAll("USER::*", "");

            //Redis根据key键，查询对应的值
            String value = redisUtils.get(key);

            //打印信息
            System.out.println("Key键：" + key + " 用户ID：" + userId + " 用户名称：" + value);
        }
    }
    catch (Exception ex)
    {
        ex.printStackTrace();
    }
}

Résultats de la:

 

3.2 Suppression par lots de String

(1) Ajoutez une méthode pour supprimer toutes les clés de chaîne par lots dans la classe d'outils Redis.

/**
 * 字符串（String）
 * 批量删除所有字符串键
 * 支持通配符*号等
 * @param key 键
 * @return 成功删除字段的数量
 * @author pan_junbiao
 */
public Long delAllByKey(String key) throws RedisException
{
    Jedis jedis = null;
    long result = 0;
    try
    {
        jedis = jedisPool.getResource();
        Set<String> keySet = jedis.keys(key);
        if (keySet != null && keySet.size() > 0)
        {
            String[] keyArray = keySet.toArray(new String[0]);
            result = jedis.del(keyArray);
        }
    }
    catch (Exception ex)
    {
        throw new RedisException(ex);
    }
    finally
    {
        //释放资源
        closeResource(jedis);
    }
    return result;
}

(2) Ecrire une méthode de test pour supprimer les clés de chaîne par lots.

/**
 * Redis工具类
 */
@Autowired
private RedisUtils redisUtils;

/**
 * Redis中字符串（String）的批量删除
 * @author pan_junbiao
 */
@Test
public void delStringTest()
{
    try
    {
        //Redis键：使用 * 号通配符
        String patternKey = "USER::*";

        //Reids中添加数据，键格式：USER::用户ID
        redisUtils.set("USER::1","pan_junbiao的博客_01");
        redisUtils.set("USER::2","pan_junbiao的博客_02");
        redisUtils.set("USER::3","pan_junbiao的博客_03");

        //Reids批量删除字符串（String）
        long result = redisUtils.delAllByKey(patternKey);
        System.out.println("批量删除字符串（String）的结果：" + result);
    }
    catch (Exception ex)
    {
        ex.printStackTrace();
    }
}

Résultats de la:

 

3.3 Suppression par lots de hachage (Hash)

(1) Ajoutez une méthode pour supprimer toutes les clés de hachage par lots dans la classe d'outils Redis.

/**
 * 哈希（Hash）操作：
 * 批量删除所有哈希表字段
 * 支持通配符*号等
 * @param key 键
 * @return 成功删除字段的数量
 * @author pan_junbiao
 */
public Long hdelAllByKey(String key) throws RedisException
{
    Jedis jedis = null;
    long result = 0;
    try
    {
        jedis = jedisPool.getResource();
        Set<String> keySet = jedis.keys(key);
        if (keySet != null && keySet.size() > 0)
        {
            for (String itemKey : keySet)
            {
                Map<String, String> fieldMap = jedis.hgetAll(itemKey);
                if (fieldMap != null && fieldMap.size() > 0)
                {
                    String[] fieldArray = fieldMap.keySet().toArray(new String[0]);
                    result += jedis.hdel(itemKey, fieldArray);
                }
            }
        }
    }
    catch (Exception ex)
    {
        throw new RedisException(ex);
    }
    finally
    {
        //释放资源
        closeResource(jedis);
    }
    return result;
}

(2) Ecrire une méthode de test pour supprimer les clés de hachage par lots.

/**
 * Redis工具类
 */
@Autowired
private RedisUtils redisUtils;

/**
 * Redis中哈希（Hash）的批量删除
 * @author pan_junbiao
 */
@Test
public void delHashTest()
{
    try
    {
        //构建Redis键（格式：PJB_USER_INFO_::用户ID）
        String key1 = redisUtils.getRedisKey(RedisKeyEnum.USER_INFO,1); //键：PJB_USER_INFO_::1
        String key2 = redisUtils.getRedisKey(RedisKeyEnum.USER_INFO,2); //键：PJB_USER_INFO_::2
        String patternKey = redisUtils.getRedisKey(RedisKeyEnum.USER_INFO,"*"); //键：PJB_USER_INFO_::*

        //创建用户1：保存到Redis中，哈希（Hash）数据类型
        redisUtils.hset(key1,"userId",1);
        redisUtils.hset(key1,"userName","pan_junbiao的博客");
        redisUtils.hset(key1,"blogUrl","https://blog.csdn.net/pan_junbiao");
        redisUtils.hset(key1,"blogRemark","您好，欢迎访问 pan_junbiao的博客");

        //创建用户2：保存到Redis中，哈希（Hash）数据类型
        redisUtils.hset(key2,"userId",2);
        redisUtils.hset(key2,"userName","pan_junbiao的博客");
        redisUtils.hset(key2,"blogUrl","https://blog.csdn.net/pan_junbiao");
        redisUtils.hset(key2,"blogRemark","您好，欢迎访问 pan_junbiao的博客");

        //从Redis中读取数据，并打印
        System.out.println("用户ID：" + redisUtils.hget(key1,"userId"));
        System.out.println("用户名称：" + redisUtils.hget(key1,"userName"));
        System.out.println("博客地址：" + redisUtils.hget(key1,"blogUrl"));
        System.out.println("博客信息：" + redisUtils.hget(key1,"blogRemark"));

        System.out.println("\n用户ID：" + redisUtils.hget(key2,"userId"));
        System.out.println("用户名称：" + redisUtils.hget(key2,"userName"));
        System.out.println("博客地址：" + redisUtils.hget(key2,"blogUrl"));
        System.out.println("博客信息：" + redisUtils.hget(key2,"blogRemark"));

        //Reids批量删除哈希（Hash）
        long result = redisUtils.hdelAllByKey(patternKey);
        System.out.println("\n批量删除字符串（String）的结果：" + result);
    }
    catch (Exception ex)
    {
        ex.printStackTrace();
    }
}

Résultats de la:

Explication des résultats:

Le résultat de sortie est: 8. Parce que la méthode originale de Redis pour supprimer les données de hachage est: hdel (String key, String ... fields), ce qui signifie la suppression en fonction de la clé et des champs.

À partir de l'exemple ci-dessus, on peut voir qu'un total de 2 objets Hash sont créés, à savoir: 2 clés, chaque clé (clé) contient 4 champs (domaines), donc Redis supprime un total de 8 objets, c'est-à-dire le résultat est retourné pour: 8.