Die Verwendung des Redis-Platzhalterschlüssels und das Batch-Löschen von Strings (String) und Hash (Hash)

1. Redis Wildcard

In Redis ist der Fuzzy-Abfrageschlüssel zulässig.

Redis unterstützt 3 Arten von Platzhaltern: *,?, []

*: Platzhalter beliebig viele Zeichen.

?: Platzhalter ein einzelnes Zeichen.

[]: Ein bestimmtes Zeichen in Platzhalterklammern.

 

2. Befehl Redis Keys

Der Befehl Schlüssel in Redis: wird verwendet, um alle Schlüssel zu finden, die einem bestimmten Muster entsprechen.

Rückgabewert: Liste der Schlüssel (Array), die dem angegebenen Muster entsprechen.

[Beispiel] Verwenden Sie den Befehl Keys und Platzhalter, um in Redis abzufragen.

 

3. Verwenden Sie Redis-Platzhalter in Java

Redis ist eine leistungsstarke Datenbank. In praktischen Anwendungen kann Redis unabhängig vom Rahmen der Website oder des Systems in das Projekt eingeführt werden.

Erstellen Sie ein SpringBoot-Projekt und integrieren Sie das Redis-Framework. Für den Erstellungsprozess durchsuchen Sie bitte die Artikel in diesem Blog:

Empfohlener Artikel: "SpringBoot integriert Redis und implementiert Redis-Toolklassen"

3.1 Redis verwendet Platzhalter für die Stapelabfrage

[Beispiel] Verwenden Sie Redis-Platzhalter für Stapelabfragen in Java-Programmen.

/**
 * 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();
    }
}

Ergebnisse der:

 

3.2 Batch-Löschung von String

(1) Fügen Sie eine Methode zum Löschen aller Zeichenfolgenschlüssel in Stapeln in der Redis-Werkzeugklasse hinzu.

/**
 * 字符串（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) Schreiben Sie eine Testmethode zum Löschen von Zeichenfolgenschlüsseln in Stapeln.

/**
 * 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();
    }
}

Ergebnisse der:

 

3.3 Batch-Löschung von Hash (Hash)

(1) Fügen Sie eine Methode zum Löschen aller Hash-Schlüssel in Stapeln in der Redis-Toolklasse hinzu.

/**
 * 哈希（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) Schreiben Sie eine Testmethode zum Löschen von Hash-Schlüsseln in Stapeln.

/**
 * 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();
    }
}

Ergebnisse der:

Erklärung der Ergebnisse:

Das Ausgabeergebnis ist: 8. Weil Redis 'ursprüngliche Methode zum Löschen von Hash-Daten lautet: hdel (String key, String ... fields), was bedeutet, dass nach Schlüssel und Feldern gelöscht wird.

Aus dem obigen Beispiel ist ersichtlich, dass insgesamt 2 Hash-Objekte erstellt werden, nämlich: 2 Schlüssel, jeder Schlüssel (Schlüssel) enthält 4 Felder (Domänen), sodass Redis insgesamt 8 Objekte löscht, dh das Ergebnis wird zurückgegeben für: 8.