Spring Data Redis 教程

RedisTemplate 通用方法 (一)

前面章节介绍了 RedisTemplate 的 ops 方法、bound 方法、execute 核心方法、管道和序列化相关的方法,下面将介绍 RedisTemplate 常用的缓存操作方法,如:删除键、判断键是否存在、键设置过期时间、键移动等等方法。

删除键

使用 delete() 方法一次性删除一个或多个键,方法定义如下:

  • Long delete(Collection<K> keys)    删除给定的多个键

  • Boolean delete(K key)    删除给定的键

示例:

ValueOperations<String,String> ops = redisTemplate.opsForValue();
// 一次删除一个键
ops.set("delete-key1", "value1");
System.out.println("删除前 delete-key1=" + ops.get("delete-key1"));
redisTemplate.delete("delete-key1");
System.out.println("删除后 delete-key1=" + ops.get("delete-key1"));

// 一次删除多个键
ops.set("delete-key1", "value1");
ops.set("delete-key2", "value2");
ops.set("delete-key3", "value3");
System.out.println("删除前 delete-key1=" + ops.get("delete-key1"));
System.out.println("删除前 delete-key2=" + ops.get("delete-key2"));
System.out.println("删除前 delete-key3=" + ops.get("delete-key3"));
redisTemplate.delete(Arrays.asList("delete-key1", "delete-key2", "delete-key3"));
System.out.println("删除后 delete-key1=" + ops.get("delete-key1"));
System.out.println("删除后 delete-key2=" + ops.get("delete-key2"));
System.out.println("删除后 delete-key3=" + ops.get("delete-key3"));

运行示例,输出结果:

删除前 delete-key1=value1
删除后 delete-key1=null
删除前 delete-key1=value1
删除前 delete-key2=value2
删除前 delete-key3=value3
删除后 delete-key1=null
删除后 delete-key2=null
删除后 delete-key3=null

过期时间

可以通过 expire() 方法给指定的键设置过期时间,通过 getExpire() 方法获取指定键的过期时间。方法定义如下:

  • Boolean expire(K key, long timeout, TimeUnit unit)    为给定的键设置生存时间

  • Boolean expireAt(K key, Date date)    将给定键的过期时间设置为日期时间戳

  • Long getExpire(K key)    获取键的生存时间,单位:秒

  • Long getExpire(K key, TimeUnit timeUnit)    获取键的生存时间,并将其转换为给定的 TimeUnit 单位

示例:

ValueOperations<String,String> ops = redisTemplate.opsForValue();

// 1.设置过期时间为毫秒数
ops.set("expire-key1", "value1");
System.out.println("expire-key1 = " + ops.get("expire-key1"));
// 设置 expire-key1 过期时间为 50 秒
redisTemplate.expire("expire-key1", 50000, TimeUnit.MILLISECONDS);
Long exporeSecond = redisTemplate.getExpire("expire-key1");
System.out.println("expire-key1 expire " + exporeSecond + "s");

// 2.通过具体的 Date 设置过期时间
ops.set("expire-key2", "value2");
System.out.println("expire-key2 = " + ops.get("expire-key2"));
// 设置 expire-key2 过期时间为具体时间
Date expireDate = new Date(System.currentTimeMillis() + (60000 * 10L));
redisTemplate.expireAt("expire-key2", expireDate);
Long exporeMinute = redisTemplate.getExpire("expire-key2", TimeUnit.MINUTES);
System.out.println("expire-key2 expire " + exporeMinute + "m");

运行示例,输出结果:

expire-key1 = value1
expire-key1 expire 50s
expire-key2 = value2
expire-key2 expire 9m

判断键是否存在

通过 hasKey() 方法可以快速判断指定的键是否存在,方法声明如下:

  • Boolean hasKey(K key) 确定给定的密钥是否存在

示例:

ValueOperations<String,String> ops = redisTemplate.opsForValue();
// 一次删除一个键
ops.set("hasKey-key1", "value1");
System.out.println("hasKey-key1 = " + ops.get("hasKey-key1"));
System.out.println("hasKey-key2 = " + ops.get("hasKey-key2"));

Boolean key1Flag = redisTemplate.hasKey("hasKey-key1");
if( null != key1Flag && key1Flag ) {
    System.out.println("hasKey-key1 键存在");
} else {
    System.out.println("hasKey-key1 键不存在");
}

Boolean key2Flag = redisTemplate.hasKey("hasKey-key2");
if( null != key2Flag && key2Flag ) {
    System.out.println("hasKey-key2 键存在");
} else {
    System.out.println("hasKey-key2 键不存在");
}

运行示例,输出结果:

hasKey-key1 = value1
hasKey-key2 = null
hasKey-key1 键存在
hasKey-key2 键不存在

根据模式获取匹配键

在 RedisTemplate 中,可以通过 keys() 方法获取匹配到的所有符合模式的键的集合。方法定义如下:

  • Set<K> keys(K pattern)     查找与给定模式匹配的所有键

keys 方法支持的匹配模式符号:

  • ? 匹配任意零个或一个字符,例如:h?llo 匹配 hello、hallo 和 hxllo

  • * 匹配任意零个或多个字符,例如:h*llo 匹配 hllo 和 heeeello

  • [] 匹配给定的字符集中的一个字符,例如:h [ae] llo 匹配 hello 和 hallo,但不匹配 hillo

  • [^] 匹配没有在给定字符集中的其他任何一个字符,例如:h[^e]llo 匹配 hallo, hbllo, ... 但不匹配 hello

  • - 定义一个范围,如:a-z 表示小写 a 到 z 的字符集,共 26 个小写字符。例如:h[a-b]llo 匹配 hallo 和 hbllo

示例:

ValueOperations<String,String> ops = redisTemplate.opsForValue();
// 准备数据
ops.set("keys1", "www.hxstrive.com");
ops.set("keys2", "doc.hxstrive.com");
ops.set("keys3", "linux.hxstrive.com");
ops.set("keys4", "api.hxstrive.com");

// 根据模式获取键
Set<String> keys = redisTemplate.keys("keys?");
if(null != keys) {
    System.out.println("keys? = " + Arrays.toString(keys.toArray(new String[]{})));
}

keys = redisTemplate.keys("keys[1-4]");
if(null != keys) {
    System.out.println("keys[1-4] = " + Arrays.toString(keys.toArray(new String[]{})));
}

keys = redisTemplate.keys("keys[1234]");
if(null != keys) {
    System.out.println("keys[1234] = " + Arrays.toString(keys.toArray(new String[]{})));
}

运行示例,输出结果:

keys? = [keys4, keys1, keys2, keys3]
keys[1-4] = [keys4, keys1, keys2, keys3]
keys[1234] = [keys4, keys1, keys2, keys3]

移动键

使用 move() 方法可以将指定的键移动到指定的数据库(默认 Redis 的数据库时 db0 ~ db15)。方法定义如下:

  • Boolean move(K key, int dbIndex)    将给定的键移动到指定的数据库。

示例:

ValueOperations<String,String> ops = redisTemplate.opsForValue();
ops.set("move-key", "hello world");
System.out.println("移动前 move-key = " + ops.get("move-key"));

// 将 move-key 键移动到 db10 数据库
redisTemplate.move("move-key", 10);
System.out.println("移动后 move-key = " + ops.get("move-key"));

运行示例,输出结果:

移动前 move-key = hello world
移动后 move-key = hello world

注意:move 方法执行成功后,被移动的键在源和目标数据库中都存在。

元素排序

可以使用 sort() 方法对查询的元素进行排序,方法定义如下:

  • List<V> sort(SortQuery<K> query)    对要查询的元素进行排序。

  • <T,S> List<T> sort(SortQuery<K> query, BulkMapper<T,S> bulkMapper, RedisSerializer<S> resultSerializer)    应用 BulkMapper 和 RedisSerializer 对查询元素进行排序。

  • <T> List<T> sort(SortQuery<K> query, BulkMapper<T,V> bulkMapper)    应用 BulkMapper 对查询元素进行排序。

  • Long sort(SortQuery<K> query, K storeKey)    对要查询的元素进行排序,并将结果存储在 storeKey中。

  • <T> List<T> sort(SortQuery<K> query, RedisSerializer<T> resultSerializer)    对应用RedisSerializer进行查询的元素进行排序。

示例:

@Test
public void contextLoads() {
    String sortKey = "sortKey";

    redisTemplate.delete(sortKey);
    if (!redisTemplate.hasKey(sortKey)) {
        for (int i = 0; i < 10; i++) {
            redisTemplate.boundSetOps(sortKey).add(String.valueOf(i));
            String hashKey = "hash" + i,
                    strId = String.valueOf(i),
                    strName = getRandomStr(),
                    strSite = getRandomStr();
            redisTemplate.boundHashOps(hashKey).put("_id", strId);
            redisTemplate.boundHashOps(hashKey).put("Name", strName);
            redisTemplate.boundHashOps(hashKey).put("Site", strSite);

            System.out.printf("%s : {\"_id\": %s, \"Name\": %s, \"Site\", %s}\n",
                    hashKey, strId, strName, strSite);
        }
    }

    SortQuery<String> sortQuery = SortQueryBuilder.sort(sortKey)
            // 根据 name 进行排序
            .by("hash*->Name")
            // 获取排序后的数据
            .get("hash*->_id")
            .get("hash*->Name")
            .get("hash*->Site").build();
    List<String> sortRslt = redisTemplate.sort(sortQuery);

    for (int i = 0; i < sortRslt.size(); ) {
        System.out.printf("{\"_id\": %s, \"Name\": %s, \"Site\", %s}\n",
                sortRslt.get(i), sortRslt.get(i+1), sortRslt.get(i+2));
        i += 3;
    }
}

private String getRandomStr() {
    return String.valueOf(new Random().nextInt(100));
}

运行示例,输出结果:

hash0 : {"_id": 0, "Name": 45, "Site", 30}
hash1 : {"_id": 1, "Name": 55, "Site", 10}
hash2 : {"_id": 2, "Name": 71, "Site", 61}
hash3 : {"_id": 3, "Name": 18, "Site", 72}
hash4 : {"_id": 4, "Name": 8, "Site", 95}
hash5 : {"_id": 5, "Name": 7, "Site", 60}
hash6 : {"_id": 6, "Name": 89, "Site", 70}
hash7 : {"_id": 7, "Name": 79, "Site", 71}
hash8 : {"_id": 8, "Name": 6, "Site", 77}
hash9 : {"_id": 9, "Name": 42, "Site", 90}
{"_id": 8, "Name": 6, "Site", 77}
{"_id": 5, "Name": 7, "Site", 60}
{"_id": 4, "Name": 8, "Site", 95}
{"_id": 3, "Name": 18, "Site", 72}
{"_id": 9, "Name": 42, "Site", 90}
{"_id": 0, "Name": 45, "Site", 30}
{"_id": 1, "Name": 55, "Site", 10}
{"_id": 2, "Name": 71, "Site", 61}
{"_id": 7, "Name": 79, "Site", 71}
{"_id": 6, "Name": 89, "Site", 70}

排序运行原理可以了解 Redis 的 sort 命令。

确定键数据类型

可以使用 type 方法确定指定键存储的数据类型,方法定义如下:

  • DataType type(K key)    确定 Key 中存储的类型。

示例:

ValueOperations<String,String> ops = redisTemplate.opsForValue();
ops.set("type-key", "hello world");
System.out.println("type-key = " + ops.get("type-key"));

DataType dataType = redisTemplate.type("type-key");
System.out.println(dataType.code());
System.out.println(dataType.name());
System.out.println(dataType.getClass());
System.out.println(dataType.getDeclaringClass());

运行示例,输出结果:

type-key = hello world
string
STRING
class org.springframework.data.redis.connection.DataType
class org.springframework.data.redis.connection.DataType


说说我的看法
全部评论(
没有评论
关于
本网站属于个人的非赢利性网站,转载的文章遵循原作者的版权声明,如果原文没有版权声明,请来信告知:hxstrive@outlook.com
公众号