前面章节介绍了 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
