Redis 是完全开源的，遵守 BSD 协议，是一个高性能的 key-value 数据库。
Redis 与其他 key - value 缓存产品有以下三个特点：
1.支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
2.可以用作数据库、缓存和消息中间件。Redis 支持五种常见对象类型：
字符串（String）、哈希（Hash）、列表（List）、集合（Set）以及有序集合（Zset）。
3.支持数据的备份，即master-slave模式的数据备份。
下面我们来实现一下每种数据类型的简单认识：
1.String
String类型，也就是我们经常遇到的字符串类型，是Redis中最简单的存储类型。按照
上面所说，区分redis中数据类型主要依据就是value的类型不同。所以，对于string类
型，其value就是字符串类型。
根据字符串的格式不同，又可以分为3类：
string：普通字符串
int：整数类型，可以做自增、自减操作
float：浮点类型，可以做自增、自减操作
不过，不管是哪种格式，底层都是字节数组形式存储，只不过是编码方式不同。字符串类型的最大空间不能超过512m。如果Value是一个Java对象，例如一个User对象，则可以将对象序列化为JSON字符串后存储。
常见的命令有：
新增/覆盖redisKey redisValue
redisTemplate.opsForValue().set(redisKey, redisValue);
新增/覆盖redisKey redisValue 和过期时间
redisTemplate.opsForValue().set(redisKey, redisValue, timeout, timeUnit);
新增/覆盖redisKey redisValue 和过期时间
redisTemplate.opsForValue().set(redisKey, redisValue, duration);
设置redisKey跟redisValue的值，如果redisKey不存在则新增，返回true，存在则不做任何处理，返回false
redisTemplate.opsForValue().setIfAbsent(redisKey, redisValue);
设置redisKey redisValue并加入过期时间，如果redisKey不存在则新增，返回true，存在则不做任何处理，返回false
redisTemplate.opsForValue().setIfAbsent(redisKey, redisValue, timeout, timeUnit);
设置redisKey redisValue并加入过期时间，如果redisKey不存在则新增，返回true，存在则不做任何处理，返回false
redisTemplate.opsForValue().setIfAbsent(redisKey, redisValue, duration);
设置redisKey redisValue的值，如果redisKey不存在则不做任何处理，返回false，存在则覆盖重写redisValue的值，返回true
redisTemplate.opsForValue().setIfPresent(redisKey, redisValue);
设置redisKey redisValue并加入过期时间，如果redisKey不存在则不做任何处理，返回false，存在则覆盖重写redisValue的值，返回true
redisTemplate.opsForValue().setIfPresent(redisKey, redisValue, timeout, timeUnit);
设置redisKey redisValue并加入过期时间，如果redisKey不存在则不做任何处理，返回false，存在则覆盖重写redisValue的值，返回true
redisTemplate.opsForValue().setIfPresent(redisKey, redisValue, duration);
批量设置redisKey跟redisValue的值，hashKey对应redisKey，hashValue对应redisValue
redisTemplate.opsForValue().multiSet(redisHashMap);
批量设置redisKey跟redisValue的值，hashKey对应redisKey，hashValue对应redisValue，如果某一个redisKey存在则不做任何处理，返回false，都不存在则新增对应的redisKey redisValue，返回true
redisTemplate.opsForValue().multiSetIfAbsent(redisHashMap);
根据redisKey获取redisValue的值
redisTemplate.opsForValue().get(redisKey);
如果redisKey存在则先获取redisValue，再覆盖重写redisValue的值，不存在则先新增，再获取redisValue
redisTemplate.opsForValue().getAndSet(redisKey, redisValue);
根据集合Collection redisKeys批量获取redisValue
redisTemplate.opsForValue().multiGet(redisKeys);
将redisKey对应的redisValue默认加上1，前提需要保证redisValue为整型数字，不存在则新增
redisTemplate.opsForValue().increment(redisKey);
将redisKey对应的redisValue加上incrementLong数据，前提需要保证redisValue为整型数字，不存在则新增
redisTemplate.opsForValue().increment(redisKey, incrementLong);
将redisKey对应的redisValue加上incrementDouble数据，前提需要保证redisValue为数字，不存在则新增
redisTemplate.opsForValue().increment(redisKey, incrementDouble);
将redisKey对应的redisValue默认减去1，前提需要保证redisValue为整型数字，不存在则新增
redisTemplate.opsForValue().decrement(redisKey);
将redisKey对应的redisValue减去decrementLong数据，前提需要保证redisValue为整型数字，不存在则新增
redisTemplate.opsForValue().decrement(redisKey, decrementLong);
如果redisKey存在则在redisValue后面加上新的字符串并覆盖旧值，不存在则新增
redisTemplate.opsForValue().append(redisKey, newString);
截取redisKey的对应redisValue。注意：redisKey对应的redisValue为字符串时会算上 "" 这个符号
redisTemplate.opsForValue().get(redisKey, startIndex, endIndex);
根据偏移量offset的值，覆盖重写redisValue的值。注意：redisKey对应的redisValue为字符串时offset会算上 "" 这个符号。 不注意的话，获取redisKey值会出现序列化问题
redisTemplate.opsForValue().set(redisKey, redisValue, offset);
获取指定redisValue长度
redisTemplate.opsForValue().size(redisKey);
redisKey对应的redisValue对应的ASCII码，在offset的位置(从左向右数)变为redisValue(这里的redisValue是boolean类型的也是就二进制的0和1的意思)
redisTemplate.opsForValue().setBit(redisKey, offset, value);
获取redisKey对应的redisValue对应的ASCII码指定偏移量上的位(bit)，如果是0则返回false，1则返回true
redisTemplate.opsForValue().getBit(redisKey, offset);
获得集合中复合BitFieldSubCommands的结果
List<Long> result = redisTemplate.opsForValue().bitField(redisKey, bitFieldSubCommands);
2.哈希（Hash）
Hash类型，也叫散列，其value是一个无序字典，类似于Java中的HashMap结构。
Hash结构可以将对象中的每个字段独立存储，可以针对单个字段做CRUD。当需要修改对象某个字段的时候，非常方便。
常见的命令有：
删除redisKey对应的hashKey
redisTemplate.opsForHash().delete(redisKey, hashKey);
判断redisKey是否有对应的hashKey
redisTemplate.opsForHash().hasKey(redisKey, hashKey);
获取redisKey中hashKey的值hashValue
redisTemplate.opsForHash().get(redisKey, hashKey);
根据集合Collection hashKeys批量获取hashValue
redisTemplate.opsForHash().multiGet(redisKey, hashKeys);
将redisKey hashKey对应的hashValue加上incrementLong，前提需要保证hashValue为整型数字，不存在则新增
redisTemplate.opsForHash().increment(redisKey, hashKey, incrementLong);
将redisKey hashKey对应的hashValue加上incrementDouble，前提需要保证hashValue为数字，不存在则新增
redisTemplate.opsForHash().increment(redisKey, hashKey, incrementDouble);
根据redisKey查询所有hashKey
redisTemplate.opsForHash().keys(redisKey);
获取redisKey hashKey对应的hashValue的长度
redisTemplate.opsForHash().lengthOfValue(redisKey, hashKey);
获取redisKey对应的Map的数据个数
redisTemplate.opsForHash().size(redisKey);
批量新增/覆盖Map值，Map的key对应hashKey，Map的value对应hashValue
redisTemplate.opsForHash().putAll(redisKey, redisHashMap);
新增/覆盖hashKey hashValue
redisTemplate.opsForHash().put(redisKey, hashKey, hashValue);
新增/覆盖hashKey hashValue，如果hashKey不存在则新增，返回true，存在则不做任何处理，返回false
redisTemplate.opsForHash().putIfAbsent(redisKey, hashKey, hashValue);
根据redisKey查询所有hashValue
redisTemplate.opsForHash().values(redisKey);
获取redisKey的Map
redisTemplate.opsForHash().entries(redisKey);
根据遍历条件scanOptions遍历redisKey对应的Map, 注意一定要关闭游标(cursor.close()), 不然连接会一直增长
redisTemplate.opsForHash().scan(redisKey, scanOptions);
3.列表（List）
List列表，和我们平常理解的List列表是一样的。Redis中的List类型与Java中的LinkedList类似，可以看做是一个双向链表结构。既可以支持正向检索和也可以支持反向检索。
特征也与LinkedList类似，对于redis中的List有以下特性：
有序
元素可以重复
插入和删除快
查询速度一般
常见的命令有：
获取redisKey对应List，从开始索引startIndex到结束索引endIndex截取值
redisTemplate.opsForList().range(redisKey, startIndex, endIndex);
获取redisKey对应List，从开始索引startIndex到结束索引endIndex截取值并覆盖旧值
redisTemplate.opsForList().trim(redisKey, startIndex, endIndex);
获取redisKey对应List的数据个数
redisTemplate.opsForList().size(redisKey);
从redisKey对应List左边插入数据redisValue
redisTemplate.opsForList().leftPush(redisKey, redisValue);
从redisKey对应List左边批量插入数组redisValueArray中的数据
redisTemplate.opsForList().leftPushAll(redisKey, redisValueArray);
从redisKey对应List左边批量插入集合Collection redisValues中的数据
redisTemplate.opsForList().leftPushAll(redisKey, redisValues);
redisKey存在则从redisKey对应List左边插入数据redisValue，不存在则不处理
redisTemplate.opsForList().leftPushIfPresent(redisKey, redisValue);
redisKey对应List存在targetRedisValue则在第一个targetRedisValue左边插入数据redisValue,不存在则不处理
redisTemplate.opsForList().leftPush(redisKey, targetRedisValue, redisValue);
从redisKey对应List右边插入数据redisValue
redisTemplate.opsForList().rightPush(redisKey, redisValue);
从redisKey对应List右边批量插入数组redisValueArray中的数据
redisTemplate.opsForList().rightPushAll(redisKey, redisValueArray);
从redisKey对应List右边批量插入集合Collection redisValues中的数据
redisTemplate.opsForList().rightPushAll(redisKey, redisValues);
redisKey存在则从redisKey对应List右边插入数据redisValue，不存在则不处理
redisTemplate.opsForList().rightPushIfPresent(redisKey, redisValue);
redisKey对应List存在targetRedisValue则在第一个targetRedisValue左边插入数据redisValue,不存在则不处理
redisTemplate.opsForList().rightPush(redisKey, targetRedisValue, redisValue);
从redisKey对应List索引为index的值替换为redisValue
redisTemplate.opsForList().set(redisKey, index, redisValue);
移除count个redisKey对应List中值为redisValue的数据
redisTemplate.opsForList().remove(redisKey, count, redisValue);
获取redisKey对应List中索引为index的数据
redisTemplate.opsForList().index(redisKey, index);
移除并获取redisKey对应List左边第一个数据
redisTemplate.opsForList().leftPop(redisKey);
设置等待时间移除并获取redisKey对应List左边第一个数据，如果超过等待的时间仍没有元素则不处理
redisTemplate.opsForList().leftPop(redisKey, timeOut, timeUnit);
设置等待时间移除并获取redisKey对应List左边第一个数据，如果超过等待的时间仍没有元素则不处理
redisTemplate.opsForList().leftPop(redisKey, duration);
移除并获取redisKey对应List右边第一个数据
redisTemplate.opsForList().rightPop(redisKey);
设置等待时间移除并获取redisKey对应List右边第一个数据，如果超过等待的时间仍没有元素则不处理
redisTemplate.opsForList().rightPop(redisKey, timeOut, timeUnit);
设置等待时间移除并获取redisKey对应List右边第一个数据，如果超过等待的时间仍没有元素则不处理
redisTemplate.opsForList().rightPop(redisKey, duration);
移除并获取redisKey对应List右边第一个数据，然后从targetRedisKey对应List左边插入redisKey移除的数据
redisTemplate.opsForList().rightPopAndLeftPush(redisKey, targetRedisKey);
设置等待时间移除并获取redisKey对应List右边第一个数据，然后从targetRedisKey对应List左边插入redisKey移除的数据，如果超过等待的时间redisKey仍没有元素则不处理
redisTemplate.opsForList().rightPopAndLeftPush(redisKey, targetRedisKey, timeOut, timeUnit);
设置等待时间移除并获取redisKey对应List右边第一个数据，然后从targetRedisKey对应List左边插入redisKey移除的数据，如果超过等待的时间redisKey仍没有元素则不处理
redisTemplate.opsForList().rightPopAndLeftPush(redisKey, targetRedisKey, duration);
4.集合（Set）
Redis的Set结构与Java中的HashSet类似，可以看做是一个value为null的HashMap。因为也是一个hash表，因此具备与HashSet类似的特征：
无序
元素不可重复
查找快
支持交集、并集、差集等功能
常见的命令如下：
批量插入数组redisValueArray中的数据
redisTemplate.opsForSet().add(redisKey, redisValueArray);
从redisKey对应Set批量移除数组redisValueArray中的数据
redisTemplate.opsForSet().remove(redisKey, redisValueArray);
随机移除redisKey对应Set中一个数据
redisTemplate.opsForSet().pop(redisKey);
随机移除redisKey对应Set中count个数据
redisTemplate.opsForSet().pop(redisKey, count);
将redisKey对应Set中值为redisValue的数据移动到targetRedisKey下，redisValue不存在则不处理
redisTemplate.opsForSet().move(redisKey, redisValue, targetRedisKey);
获取redisKey对应Set数据个数
redisTemplate.opsForSet().size(redisKey);
判断redisKey对应Set是否包含redisValue
redisTemplate.opsForSet().isMember(redisKey, redisValue);
获取redisKey对应Set和otherRedisKey对应Set的交集数据
redisTemplate.opsForSet().intersect(redisKey, otherRedisKey);
获取redisKey对应Set和集合redisKeys对应Set的共同交集数据
redisTemplate.opsForSet().intersect(redisKey, redisKeys);
获取集合redisKeys对应Set的共同交集数据
redisTemplate.opsForSet().intersect(redisKeys);
获取redisKey对应Set和otherRedisKey对应Set的交集数据存储到targetRedisKey，如果targetRedisKey已存在则覆盖
redisTemplate.opsForSet().intersectAndStore(redisKey, otherRedisKey, targetRedisKey);
获取redisKey对应Set和集合redisKeys对应Set的共同交集数据存储到targetRedisKey，如果targetRedisKey已存在则覆盖
redisTemplate.opsForSet().intersectAndStore(redisKey, redisKeys, targetRedisKey);
获取集合redisKeys对应Set的共同交集数据存储到targetRedisKey，如果targetRedisKey已存在则覆盖
redisTemplate.opsForSet().intersectAndStore(redisKeys, targetRedisKey);
获取redisKey对应Set和otherRedisKey对应Set的并集数据
redisTemplate.opsForSet().union(redisKey, otherRedisKey);
获取redisKey对应Set和集合redisKeys对应Set的共同并集数据
redisTemplate.opsForSet().union(redisKey, redisKeys);
获取集合redisKeys对应Set的共同并集数据
redisTemplate.opsForSet().union(redisKeys);
获取redisKey对应Set和otherRedisKey对应Set的并集数据存储到targetRedisKey，如果targetRedisKey已存在则覆盖
redisTemplate.opsForSet().unionAndStore(redisKey, otherRedisKey, targetRedisKey);
获取redisKey对应Set和集合redisKeys对应Set的共同并集数据存储到targetRedisKey，如果targetRedisKey已存在则覆盖
redisTemplate.opsForSet().unionAndStore(redisKey, redisKeys, targetRedisKey);
获取集合redisKeys对应Set的共同并集数据存储到targetRedisKey，如果targetRedisKey已存在则覆盖
redisTemplate.opsForSet().unionAndStore(redisKeys, targetRedisKey);
获取redisKey对应Set不包含otherRedisKey对应Set的数据
redisTemplate.opsForSet().difference(redisKey, otherRedisKey);
获取redisKey对应Set不包含集合redisKeys对应Set的数据
redisTemplate.opsForSet().difference(redisKey, redisKeys);
获取集合redisKeys中第一个redisKey对应Set不包含集合redisKeys中其他redisKey对应Set的数据
redisTemplate.opsForSet().difference(redisKeys);
获取redisKey对应Set不包含otherRedisKey对应Set的数据存储到targetRedisKey，如果targetRedisKey已存在则覆盖
redisTemplate.opsForSet().differenceAndStore(redisKey, otherRedisKey, targetRedisKey);
获取redisKey对应Set不包含集合redisKeys对应Set的数据存储到targetRedisKey，如果targetRedisKey已存在则覆盖
redisTemplate.opsForSet().differenceAndStore(redisKey, redisKeys, targetRedisKey);
获取集合redisKeys中第一个redisKey 对应Set不包含集合redisKeys中 其他redisKey 对应Set的数据存储到targetRedisKey，如果targetRedisKey已存在则覆盖
redisTemplate.opsForSet().differenceAndStore(redisKeys, targetRedisKey);
获取redisKey对应Set的所有数据
redisTemplate.opsForSet().members(redisKey);
随机获取redisKey对应Set中的一个数据
redisTemplate.opsForSet().randomMember(redisKey);
随机获取redisKey对应Set中count个数据，然后去重
redisTemplate.opsForSet().distinctRandomMembers(redisKey, count);
随机获取redisKey对应Set中count个数据
redisTemplate.opsForSet().randomMembers(redisKey, count);
根据遍历条件scanOptions遍历redisKey对应的Set，注意一定要关闭游标(cursor.close())，不然连接会一直增长
redisTemplate.opsForSet().scan(redisKey, scanOptions);
- ZSet
Redis的ZSet是一个可排序的set集合，与Java中的TreeSet有些类似，但底层数据结构却差别很大。TreeSet底层是使用红黑树来进行实现的，对于ZSet中的每一个元素都带有一个score属性，可以基于score属性对元素排序（默认从小到大），底层的实现是一个跳表（SkipList）加 hash表。
ZSet具备下列特性：
可排序
元素不重复
查询速度快
常见的命令如下：
往redisKey添加数据, redisValue不存在则添加，存在则修改score
redisTemplate.opsForZSet().add(redisKey, redisValue, score);
批量往redisKey添加数据, redisValue不存在则添加，存在则修改score
redisTemplate.opsForZSet().add(redisKey, zSetOperationsSet);
移除redisKey中存在于redisValues的值
redisTemplate.opsForZSet().remove(redisKey, redisValues);
将redisKey中redisValue对应的score加上传递的score, redisValue不存在则不处理
redisTemplate.opsForZSet().incrementScore(redisKey, redisValue, score);
获取redisKey中从第一位元素到redisValue位置有多少个元素（不包含redisValue）,redisValue不存在则返回null
redisTemplate.opsForZSet().rank(redisKey, redisValue);
将redisKey对应redisValues倒序, 然后获取redisKey中从第一位元素到redisValue位置有多少个元素（不包含redisValue）, redisValue不存在则返回null
redisTemplate.opsForZSet().reverseRank(redisKey, redisValue);
在redisKey对应redisValues中按索引从startIndex到endIndex截取redisValue
redisTemplate.opsForZSet().range(redisKey, startIndex, endIndex);
在redisKey对应redisValues中按索引从startIndex到endIndex截取redisValue和score
redisTemplate.opsForZSet().rangeWithScores(redisKey, startIndex, endIndex);
在redisKey对应redisValues中按排序从startScore到endScore截取redisValue
redisTemplate.opsForZSet().rangeByScore(redisKey, startScore, endScore);
在redisKey对应redisValues中按排序从startScore到endScore截取redisValue和score
redisTemplate.opsForZSet().rangeByScoreWithScores(redisKey, startScore, endScore);
在redisKey对应redisValues中先按排序从startScore到endScore截取redisValue, 再按索引从startIndex开始截取count个元素
redisTemplate.opsForZSet().rangeByScore(redisKey, startScore, endScore, startIndex, count);
在redisKey对应redisValues中先按排序从startScore到endScore截取redisValue和score, 再按索引从startIndex开始截取count个元素
redisTemplate.opsForZSet().rangeByScoreWithScores(redisKey, startScore, endScore, startIndex, count);
将redisKey对应redisValues倒序, 然后按索引从startIndex到endIndex截取redisValue
redisTemplate.opsForZSet().reverseRange(redisKey, startIndex, endIndex);
将redisKey对应redisValues倒序, 然后按索引从startIndex到endIndex截取redisValue和score
redisTemplate.opsForZSet().reverseRangeWithScores(redisKey, startIndex, endIndex);
将redisKey对应redisValues倒序, 然后按排序从startScore到endScore截取redisValue
redisTemplate.opsForZSet().reverseRangeByScore(redisKey, startScore, endScore);
将redisKey对应redisValues倒序, 然后按排序从startScore到endScore截取redisValue和score
redisTemplate.opsForZSet().reverseRangeByScoreWithScores(redisKey, startScore, endScore);
将redisKey对应redisValues倒序, 然后先按排序从startScore到endScore截取redisValue, 再按索引从startIndex开始截取count个元素
redisTemplate.opsForZSet().reverseRangeByScore(redisKey, startScore, endScore, startIndex, count);
将redisKey对应redisValues倒序, 然后先按排序从startScore到endScore截取redisValue和score, 再按索引从startIndex开始截取count个元素
redisTemplate.opsForZSet().reverseRangeByScoreWithScores(redisKey, startScore, endScore, startIndex, count);
在redisKey对应redisValues中按排序从startScore到endScore获取元素个数
redisTemplate.opsForZSet().count(redisKey, startScore, endScore);
获取redisKey对应redisValues元素个数
redisTemplate.opsForZSet().size(redisKey);
获取redisKey对应redisValues元素个数
redisTemplate.opsForZSet().zCard(redisKey);
获取redisKey中redisValue对应的score
redisTemplate.opsForZSet().score(redisKey, redisValue);
在redisKey对应redisValues中按索引从startIndex到endIndex移除redisValue
redisTemplate.opsForZSet().removeRange(redisKey, startIndex, endIndex);
在redisKey对应redisValues中按排序从startScore到endScore移除redisValue
redisTemplate.opsForZSet().removeRangeByScore(redisKey, startScore, endScore);
获取redisKey对应zSet和otherRedisKey对应zSet的并集数据存储到targetRedisKey, 如果targetRedisKey已存在则覆盖
redisTemplate.opsForZSet().unionAndStore(redisKey, otherRedisKey, targetRedisKey);
获取redisKey对应zSet和集合redisKeys对应zSet的共同并集数据存储到targetRedisKey, 如果targetRedisKey已存在则覆盖
redisTemplate.opsForZSet().unionAndStore(redisKey, redisKeys, targetRedisKey);
获取redisKey对应zSet和集合redisKeys对应zSet的共同并集数据存储到targetRedisKey, 如果redisValue重复则按照合计规则redisZSetCommandsAggregate对score进行处理
redisTemplate.opsForZSet().unionAndStore(redisKey, redisKeys, targetRedisKey, redisZSetCommandsAggregate);
先按照权重规则redisZSetCommandsWeights处理score也就是(score = score * weight), redisKey是按顺序对应weight的。 然后获取redisKey对应zSet和集合redisKeys对应zSet的共同并集数据存储到targetRedisKey, 如果redisValue重复则按照合计规则redisZSetCommandsAggregate对score进行处理
redisTemplate.opsForZSet().unionAndStore(redisKey, redisKeys, targetRedisKey, redisZSetCommandsAggregate, redisZSetCommandsWeights);
获取redisKey对应zSet和otherRedisKey对应zSet的交集数据存储到targetRedisKey，如果targetRedisKey已存在则覆盖
redisTemplate.opsForZSet().intersectAndStore(redisKey, otherRedisKey, targetRedisKey);
获取redisKey对应zSet和集合redisKeys对应zSet的共同交集数据存储到targetRedisKey，如果targetRedisKey已存在则覆盖
redisTemplate.opsForZSet().intersectAndStore(redisKey, redisKeys, targetRedisKey);
获取redisKey对应zSet和集合redisKeys对应zSet的共同交集数据存储到targetRedisKey, 按照合计规则redisZSetCommandsAggregate对score进行处理
redisTemplate.opsForZSet().intersectAndStore(redisKey, redisKeys, targetRedisKey, redisZSetCommandsAggregate);
先按照权重规则redisZSetCommandsWeights处理score也就是(score = score * weight), redisKey是按顺序对应weight的。 然后获取redisKey对应zSet和集合redisKeys对应zSet的共同交集数据存储到targetRedisKey, 按照合计规则redisZSetCommandsAggregate对score进行处理
redisTemplate.opsForZSet().intersectAndStore(redisKey, redisKeys, targetRedisKey, redisZSetCommandsAggregate, redisZSetCommandsWeights);
根据遍历条件scanOptions遍历redisKey对应的zSet, 注意一定要关闭游标(cursor.close()), 不然连接会一直增长
redisTemplate.opsForZSet().scan(redisKey, scanOptions);
根据范围条件redisZSetCommandsRange(是针对redisValue值进行比较处理的)获取redisKey对应的zSet中符合条件的redisValues, 亲测只有redisValue为数字时才可以使用该方法
redisTemplate.opsForZSet().rangeByLex(redisKey, redisZSetCommandsRange);
根据范围条件redisZSetCommandsRange(是针对redisValue值进行比较处理的)和限制条件redisZSetCommandsLimit获取redisKey对应的zSet中符合条件的redisValues, 亲测只有redisValue为数字时才可以使用该方法
redisTemplate.opsForZSet().rangeByLex(redisKey, redisZSetCommandsRange, redisZSetCommandsLimit);
6.不区分数据类型
常见的命令有：
删除redisKey
redisTemplate.delete(redisKey2);
批量删除redisKeys
redisTemplate.delete(redisKeys);
判断是否包含redisKey
redisTemplate.hasKey(redisKey);
判断redisKeys存在个数
redisTemplate.countExistingKeys(redisKeys);
设置redisKey过期时间
redisTemplate.expire(redisKey, timeOut, timeUnit);
设置redisKey过期时间
redisTemplate.expireAt(redisKey, date);
获取redisKey过期时间
redisTemplate.getExpire(redisKey);
获取redisKey过期时间
redisTemplate.getExpire(redisKey, timeUnit);
根据传入的正则表达式返回所有的key（不建议使用，redis单线程模式会造成堵塞）
redisTemplate.keys(pattern);
取消指定key的过期时间
redisTemplate.persist(redisKey);
移动指定的redisKey到dbIndex数据库中
redisTemplate.move(redisKey, dbIndex);
从键空间随机获取一个redisKey
redisTemplate.randomKey();
将指定oldKey改成目标newKey，oldKey不存在会报错，newKey已存在则会被删除
redisTemplate.rename(oldKey, newKey);
将指定oldKey改成目标newKey，oldKey不存在会报错，newKey不存在，返回true，存在则不处理，返回false
redisTemplate.renameIfAbsent(oldKey, newKey);
获取指定redisKey的redisValue数据类型
redisTemplate.type(redisKey);
序列化指定redisKey的redisValue
byte[] bytes = redisTemplate.dump(redisKey);
反序列化bytes存储到指定的redisKey, 并设置过期时间（replace为false时, redisKey不能已存在, 否则会报键繁忙 BUSYKEY Target key name already exists）
redisTemplate.restore(redisKey, bytes, timeToLive, timeUnit, replace);
