1. Comodín de Redis
En Redis, se permite la clave de consulta difusa.
Redis admite 3 tipos de comodines: *,?, []
*: Comodín para cualquier número de caracteres.
?: Comodín para un solo carácter.
[]: Cierto carácter entre corchetes comodín.
2. Comando Redis Keys
El comando Keys en Redis: se usa para encontrar todas las claves que coinciden con un patrón determinado.
Valor de retorno: lista de claves (matriz) que se ajustan al patrón dado.
[Ejemplo] Utilice el comando Keys y los comodines para realizar consultas en Redis.
3. Utilice comodines de Redis en Java
Redis es una base de datos poderosa En aplicaciones prácticas, independientemente del marco del sitio web o sistema, Redis se puede introducir en el proyecto.
Cree el proyecto SpringBoot e integre el marco de Redis. Para el proceso de creación, navegue por los artículos de este blog:
Artículo recomendado: "SpringBoot integra Redis e implementa clases de herramientas de Redis"
3.1 Redis usa comodines para consultas por lotes
[Ejemplo] Utilice comodines de Redis para consultas por lotes en programas 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();
}
}Resultados del:
3.2 Eliminación por lotes de cadenas
(1) Agregue un método para eliminar todas las claves de cadena en lotes en la clase de herramienta 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) Escriba un método de prueba para eliminar claves de cadena en lotes.
/**
* 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();
}
}Resultados del:
3.3 Eliminación por lotes de hash (Hash)
(1) Agregue un método para eliminar todas las claves Hash en lotes en la clase de herramienta 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) Escriba un método de prueba para eliminar claves hash en lotes.
/**
* 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();
}
}Resultados del:
Explicación de resultados:
El resultado de salida es: 8. Porque el método original de Redis para eliminar datos Hash es: hdel (String key, String ... campos), lo que significa eliminar según la clave y los campos.
En el ejemplo anterior, se puede ver que se crean un total de 2 objetos Hash, a saber: 2 claves, cada clave (clave) contiene 4 campos (dominios), por lo que Redis borra un total de 8 objetos, es decir, el resultado se devuelve por: 8.