Redis的常用数据结构及使用场景

Redis常用五大数据结构

Redis中存储数据是以key-value的形式去存储的，其中key为String字符串类型，value的数据类型有string、hash、list、set、zset等这五种常用的。这五种数据结构在开发中基本上可以应对大部分场景的数据存储！下面分别来介绍value的五种数据结构的用法以及使用场景

〇key的底层存储方式：SDS

当我们使用命令set aaa 123等命令操作Redis时，也是会经过Redis客户端到Redis服务端的过程，这些命令相当于一个请求：

• redis客户端通过socket传输这些命令
• redis服务端通过io读取到这些请求命令，把所有的命令解析成一个字符串，并执行对应命令操作，然后再经过socket写回操作结果！

redis是使用c语言写的，但它底层在存放redis的key时，并没有用c语言原生的字符串数据结构，而是定义了一个属于redis的数据结构SDS(Simple Dynamic String)

struct sdshdr{
     //记录buf数组中已使用字节的数量
     //等于 SDS 保存字符串的长度
     int len;
     //记录 buf 数组中未使用字节的数量
     int free;
     //字节数组，用于保存字符串
     char buf[];
}

为什么要使用这样的一个数据结构来存储字符串呢？

1. 二进制安全的数据结构
   比如是操作命令是get aaa\0：获取aaa\0的值。如果是c语言的字符数组就会把\0吞掉，变为get aaa，而使用SDS就会完整的操作aaa\0，SDS把所有接受到的数据都转成字符串，即使是一些特殊字符！
2. SDS提供了内存预分配机制，避免频繁的内存分配
   如果是c语言，在修改一个key时，会分配一个新的字符数组，然后进行内存赋值，而SDS则采用预先分配机制，直接把字符串容量扩大两倍，key的长度变化时，直接在已分配的内存中修改即可，如果不够继续扩大2倍
3. 兼容c语言的函数库
   定制SDS数据结构并不是重复造轮子，该复用的还是要复用！

①String && 使用场景

String常用操作

命令	说明
SET key value	存入字符串键值对
MSET key value [key value …]	批量存储字符串键值对
SETNX key value	存入一个不存在的字符串键值对
GET key	获取一个字符串键值
MGET key [key …]	批量获取字符串键值
DEL key [key …]	删除一个键
EXPIRE key seconds	设置一个键的过期时间(秒)
INCR key	将key中储存的数字值加1
DECR key	将key中储存的数字值减1
INCRBY key increment	将key所储存的值加上increment
DECRBY key decrement	将key所储存的值减去decrement

String的使用场景

1. 单值缓存
   SET key value
   GET key
   使用上面两条命令可以做用户id存储、商品库存存储等等！

2. 对象缓存
   以缓存user对象为例，有以下两种方式

   ①：SET user:1 value(json格式数据)：把对象转json存入redis，也是当下常用的方式，获取数据需要做数据转换

   ②：MSET user:1:name zhuge user:1:balance 1888
   MGET user:1:name user:1:balance
   使用Mset命令，把对象拆开存储，每一个key只保存对象的一个字段信息，适用于经常修改user的某个字段的场景

3. 分布式锁
   SETNX product:10001 true //操作product:10001
   // 执行业务操作
   DEL product:10001 //删除product:10001

   其中SETNX key value 命令要求如果key已存在，则其他的setnx命令无法对当前key进行操作。

   在使用分布式锁时通常还会通过
   SET product:10001 true ex 10 nx 命令设置key的超时时间，防止死锁！

4. 计数器
   INCR 文章id
   可以使用INCR命令实现数量自增，可以用于文章阅读量、热度人数统计等，用户每点进去一次执行一次INCR命令！

5. 分布式系统全局序列号
   在分布式系统下，如果需要分库分表， mysql的数据库自增id已经无法满足分库分表下的id自增，这时就需要一个独立于数据库之外的中间件来实现id的分配。

   redis的INCR命令可以实现id、序列号的生成，但如果用户量非常大，每生成一个id、序列号都去redis会给redis添加不小的压力，我们可以一次性从redis中自增1000次，把序列号放入本地内存中，这1000个id用完了，再去redis再取1000个，可有效降低redis的压力！

②hash && 使用场景

hash的常用操作

命令	说明
HSET key field value	存储一个哈希表key的键值
HGET key field	获取哈希表key对应的field键值
HMSET key field value [field value …]	在一个哈希表key中存储多个键值对
HMGET key field [field …]	批量获取哈希表key中多个field键值
HSETNX key field value	存储一个不存在的哈希表key的键值
HDEL key field [field …]	删除哈希表key中的field键值
HLEN key	返回哈希表key中field的数量
HGETALL key	返回哈希表key中所有的键值
HINCRBY key field increment	为哈希表key中field键的值加上增量increment

hash的使用场景

1. 电商购物车
   1）以用户id为key === cart:1001
   2）商品id为field === 10088
   3）商品数量为value === 1

   购物车操作
   1）添加商品 hset cart:1001 10088 1
   2）增加数量 hincrby cart:1001 10088 1
   3）商品总数 hlen cart:1001
   4）删除商品 hdel cart:1001 10088
   5）获取购物车所有商品 hgetall cart:1001

优点
1）同类数据归类整合储存，方便数据管理

2）相比string操作消耗内存与cpu更小
因为：string类型通过set key - val 的方式存储数据，通过对key进行hash运算决定当前key是存储在数组哪个位置。如果把hash类型的数据变成string类型来存储，则需要更多的key，同时在存放时也需要更多的hash(key)运算，消耗更多的cpu资源！

3）相比string储存更节省空间**
如果把hash类型的数据变成string类型来存储，将需要存储更多key，如果数据量很多的情况下，redis底层那么存储数据的数组将很快会被占满，占满就会进行扩容，加大内存消耗。由此可见，string结构与hash结构只存储一个key相比，需要更多的内存空间！

缺点
1）过期功能不能使用在field上，只能用在key上
redis的过期时间只能用在key上，而hash的key是一个大的概念，里面的map型结构才是重要数据，但过期时间只能用在外边的大key上，hash结构相比于string不能实现精准过期！

2）hash结构在Redis集群架构下不适合大规模使用
因为如果一个hash的key中的属性很多的话，只能存在一个redis节点上，那么这个节点压力会比其他节点压力大很多，造成redis集群下压力分配不均衡！

③list && 使用场景

list类似一个队列或栈

list的常用操作

命令	说明
LPUSH key value [value …]	将一个或多个值value插入到key列表的表头(最左边)
RPUSH key value [value …]	将一个或多个值value插入到key列表的表尾(最右边)
LPOP key	移除并返回key列表的头元素
RPOP key	移除并返回key列表的尾元素
LRANGE key start stop	返回列表key中指定区间内的元素，区间以偏移量start和stop指定
BLPOP key [key …] timeout	从key列表表头弹出一个元素，若列表中没有元素，阻塞等待timeout：秒，如果timeout=0,一直阻塞等待
BRPOP key [key …] timeout	从key列表表尾弹出一个元素，若列表中没有元素，阻塞等待timeout：秒，如果timeout=0,一直阻塞等待

list的使用场景

1. 模拟分布式系统数据结构

   ①：Stack(栈) = LPUSH（左边放） + LPOP（左边取）
   ②：Queue(队列）= LPUSH（左边放） + RPOP（右边取）
   ③：Blocking MQ(阻塞队列）= LPUSH（左边放） + BRPOP（右边阻塞取：没有数据就阻塞！）

   问：那么redis实现的数据结构和jdk中提供的数据结构有什么区别呢？

   答：jdk提供的数据结构仅在本服务中有用，如果在分布式环境下，则需要借助redis等中间件，模拟数据结构来统一管理数据。

2. 微博、朋友圈、公众号等，关注的文章列表展示

假如 小明 关注了 中国青年报、三太子敖丙 等大V的订阅号，当这些大V发布订阅号时，通过推或拉的方式把消息LPUSH放入redis中属于小明的list中。其中key为msg:{小明_ID}。当小明要获取大V们发的消息时，使用LRANGE 命令从队列中获取指定个数的订阅号信息！！

①：MacTalk发微博，消息ID为10010
LPUSH msg:{小明_ID} 10010

②：备胎说车发微博，消息ID为10086
LPUSH msg:{小明_ID} 10086

③：查看最新微博消息
LRANGE msg:{小明_ID} 0 4

这里有一个问题，大V发了消息的是怎么存储在粉丝的redis中呢？一般有两种处理方案！

①：推，博主发了消息，通过线程先推送到在线粉丝的队列中，其他不在线的等系统空闲时慢慢推过去。

②：拉，如果粉丝太多，推的方案还是要很长时间去处理，还有一种方案就是拉。每一个粉丝上线后就去关注的博主那里，拉取他发的最新的消息，在使用LRANGE取出即可！

④set && 使用场景

set是一个集合，key不允许重复，如果重复设置key，则设置无效

set的常用操作

命令	说明
SADD key member [member …]	往集合key中存入元素，元素存在则忽略，若key不存在则新建
SREM key member [member …]	从集合key中删除元素
SMEMBERS key	获取集合key中所有元素
SCARD key	获取集合key的元素个数
SISMEMBER key member	判断member元素是否存在于集合key中
SRANDMEMBER key [count]	从集合key中选出count个元素，元素不从key中删除
SPOP key [count]	从集合key中选出count个元素，元素从key中删除

set的运算操作

命令	说明
SINTER key [key …]	交集运算
SINTERSTORE destination key [key …]	将交集结果存入新集合destination中
SUNION key [key …]	并集运算
SUNIONSTORE destination key [key …]	将并集结果存入新集合destination中
SDIFF key [key …]	差集运算
SDIFFSTORE destination key [key …]	将差集结果存入新集合destination中

set的使用场景

1. 抽奖活动

1）点击参与抽奖加入集合
SADD key {userlD}

2）查看参与抽奖所有用户
SMEMBERS key

3）随机抽取count名中奖者
SRANDMEMBER key [count] ------元素不从集合中删除
SPOP key [count] ------ 元素从集合中删除

2. 朋友圈点赞

当某人在朋友圈发布消息，可用set来点赞展示

1）点赞
SADD like:{消息ID} {用户ID}

2）取消点赞
SREM like:{消息ID} {用户ID}

3）检查用户是否点过赞
SISMEMBER like:{消息ID} {用户ID}

4）获取点赞的用户列表
SMEMBERS like:{消息ID}

5）获取点赞用户数
SCARD like:{消息ID}

3. 利用set的交、并、差集实现微博、微信关注模型

关注模型如下图：

首先了解一下set的集合操作，假如有三个集合
set1：（a、b、c）
set2：（b、c、d）
set3：（c、d、e）

三个集合的
交集为：SINTER set1 set2 set3 ==> { c }
并集为：SUNION set1 set2 set3 ==> { a,b,c,d,e }
差集为：SDIFF set1 set2 set3 ==> { a }
差集计算方式：set1 - （set2并set3） = {a、b、c} - {b、c、d、e} = {a} 只保留a中单独存在的元素

共同关注A的人：可以用交集来实现
我可能认识的人：可以使用差集来实现，把我关注的人求差集
我关注的人也关注A：可以使用SISMEMBER 命令查看A是否在我关注的人的关注列表中，如果存在把这个人返回

⑤zset && 使用场景

zset相比于set多一个score 分值，正是根据这个分值进行排序，所以zset才能展示有序的数据

zset的常用操作

命令	说明
ZADD key score member [[score member]…]	往有序集合key中加入带分值元素
ZREM key member [member …]	从有序集合key中删除元素
ZSCORE key member	返回有序集合key中元素member的分值
ZINCRBY key increment member	为有序集合key中元素member的分值加上increment
ZCARD key	返回有序集合key中元素个数
ZRANGE key start stop [WITHSCORES]	正序获取有序集合key从start下标到stop下标的元素
ZREVRANGE key start stop [WITHSCORES]	倒序获取有序集合key从start下标到stop下标的元素

zset的运算操作

命令	说明
ZUNIONSTORE destkey numkeys key [key …]	并集计算
ZINTERSTORE destkey numkeys key [key …]	交集计算

zset的使用场景

1. 实现热搜排行榜

①：点击 “美国选举” 新闻时，为其分值+1
ZINCRBY hotNews:20190819 1 美国选举

②：展示当日排行前十
ZREVRANGE hotNews:20190819 0 9 WITHSCORES

③：七日搜索榜单计算
取7天的key求并集放入新的key=hotNews:20190813-20190819中，就得出这7天中的访问量排行榜
ZUNIONSTORE hotNews:20190813-20190819 7
hotNews:20190813 hotNews:20190814… hotNews:20190819

④：展示七日排行前十
根据上边的并集，从新的key=hotNews:20190813-20190819中取出前10名
ZREVRANGE hotNews:20190813-20190819 0 9 WITHSCORES

Redis常用五大数据结构

package com.huakai.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @author huakai
 */
@Component
public class RedisUtil {


    @Autowired
    @Qualifier("myRedisTemplate")
    private RedisTemplate<String, Object> redisTemplate;
    // =============================common============================

    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     */
    public boolean expire(String key, long time) {
        try {
            if (time >= 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }


    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return Optional.ofNullable(redisTemplate.getExpire(key, TimeUnit.SECONDS)).orElse(0L);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return Optional.ofNullable(redisTemplate.hasKey(key)).orElse(false);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    /**
     * 删除缓存
     *
     * @param keys 可以传一个值 或多个
     */
    public boolean del(List<String> keys) {
        if (keys.size() > 0) {
            final Long aLong = Optional.ofNullable(redisTemplate.delete(keys)).orElse(0L);
            return aLong > 0;
        }
        return false;
    }

    // ============================String=============================

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return Optional.ofNullable(redisTemplate.opsForValue().increment(key, delta)).orElse(0L);
    }

    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return Optional.ofNullable(redisTemplate.opsForValue().increment(key, -delta)).orElse(0L);
    }

    public long decr(String key) {
        return Optional.ofNullable(redisTemplate.opsForValue().increment(key)).orElse(0L);
    }

    // ================================hash=================================

    /**
     * HashGet
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hKeys(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 获取hashKey的长度
     *
     * @param key 键
     * @return 哈桑Key的大小
     */
    public Long hlen(String key) {
        Long size = 0L;
        try {
            size = Optional.of(redisTemplate.opsForHash()).map(o -> o.size(key)).orElse(0L);
        } catch (Exception e) {
            e.printStackTrace();
            return 0L;
        }
        return size;
    }

    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 向一张hash表中放入多条数据,如果不存在将创建
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    // ===============================list=================================


    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     */
    public Object lGet(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list指定范围的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     */
    public List<Object> lRange(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     *
     * @param key 键
     */
    public long lLen(String key) {
        try {
            return Optional.ofNullable(redisTemplate.opsForList().size(key)).orElse(0L);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     */
    public boolean lUpdate(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            return Optional.ofNullable(redisTemplate.opsForList().remove(key, count, value)).orElse(0L);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     */
    public Set<Object> sMember(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sIsMember(String key, Object value) {
        return Optional.ofNullable(redisTemplate.opsForSet().isMember(key, value)).orElse(false);
    }

    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sAdd(String key, Object... values) {
        return Optional.ofNullable(redisTemplate.opsForSet().add(key, values)).orElse(0L);
    }

    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetWithTime(String key, long time, Object... values) {
        try {
            if (time > 0) {
                expire(key, time);
            }
            return Optional.ofNullable(redisTemplate.opsForSet().add(key, values)).orElse(0L);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 随机移除并返回一个元素
     *
     * @param key 键
     * @return 被移除的元素
     */
    public Object sPop(String key) {
        return redisTemplate.opsForSet().pop(key);
    }

    /**
     * 随机返回指定长度的count个元素
     *
     * @param key   键
     * @param count 返回元素的个数
     * @return 返回的元素
     */
    public List<Object> sRandMember(String key, long count) {
        return redisTemplate.opsForSet().randomMembers(key, count);
    }

    /**
     * 两个set集合求交集
     *
     * @param key1 其中一个set的key
     * @param key2 另一个set的key
     * @return 两个set的差集
     */
    public Set<Object> sDiff(String key1, String key2) {
        return redisTemplate.opsForSet().difference(key1, key2);
    }

    /**
     * 两个set集合求交集
     *
     * @param key1 其中一个set的key
     * @param key2 另一个set的key
     * @return 两个set的交集
     */
    public Set<Object> Sinter(String key1, String key2) {
        return redisTemplate.opsForSet().intersect(key1, key2);
    }

    /**
     * 两个set集合求并集
     *
     * @param key1 其中一个set的key
     * @param key2 另一个set的key
     * @return 两个set的并集
     */
    public Set<Object> sUnion(String key1, String key2) {
        return redisTemplate.opsForSet().union(key1, key2);
    }

    /**
     * 获取set缓存的长度
     *
     * @param key 键
     */
    public long sGetSetSize(String key) {
        return Optional.ofNullable(redisTemplate.opsForSet().size(key)).orElse(0L);
    }

    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        return Optional.ofNullable(redisTemplate.opsForSet().remove(key, values)).orElse(0L);
    }

    // ============================sorted set=============================

    /**
     * 添加元素到zSet集合当中去
     * @param key 键
     * @param value 值
     * @param score 分数
     * @return 是否添加成功
     */
    public boolean zAdd(String key, Object value, double score) {
        return Optional.ofNullable(redisTemplate.opsForZSet().add(key, value, score)).orElse(false);
    }

    /**
     * 返回指定分数范围的数据
     * @param key 键
     * @param start 起始位置
     * @param end 结束位置
     * @return 指定分数范围内的zSet
     */
    public Set<Object> zRange(String key,long start,long end){
        return redisTemplate.opsForZSet().range(key,start,end);
    }
}