对 Redis 5种数据结构的常用操作进一步封装 RedisUtil

  1. import java.time.Duration;
  2. import java.util.Collection;
  3. import java.util.Date;
  4. import java.util.List;
  5. import java.util.Map;
  6. import java.util.Set;
  7. import java.util.concurrent.TimeUnit;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.cache.annotation.CachingConfigurerSupport;
  11. import org.springframework.data.redis.connection.DataType;
  12. import org.springframework.data.redis.core.StringRedisTemplate;
  13. import org.springframework.stereotype.Component;
  15. /**
  16.  * 对 Redis 5种数据结构进一步封装操作
  17.  * 1. String 可以是字符串、整数或者浮点数
  18.  * 2. List 一个链表，链表上的每个节点都包含了一个字符串
  19.  * 3. Set 包含字符串的无序集合，并且被包含的每个字符串都是独一无二的、各不相同
  20.  * 4. Hash 包含键值对的无序散列表
  21.  * 5. Zset 字符串成员与浮点数分值之间的有序映射，元素的排列顺序由分值的大小决定
  22.  *
  23.  */
  24. @Component
  25. public class RedisUtil extends CachingConfigurerSupport{
  27.     @Autowired
  28.     private StringRedisTemplate stringRedisTemplate;
  30.     public StringRedisTemplate getStringRedisTemplate() {
  31.         return stringRedisTemplate;
  32.     }
  34.     // ==================== key 常用相关操作 ==================== //
  36.     /**
  37.      * 【Key】 删除 key
  38.      * @param key
  39.      * @return 成功删除存在的key时为 true
  40.      */
  41.     public Boolean delete(String key) {
  42.         return stringRedisTemplate.delete(key);
  43.     }
  45.     /**
  46.      * 【Key】 批量删除 key
  47.      * @param keys
  48.      * @return 返回成功删除的数量
  49.      */
  50.     public Long delete(Collection<String> keys) {
  51.         return stringRedisTemplate.delete(keys);
  52.     }
  54.     /**
  55.      * 【Key】 序列化 key
  56.      * @param key
  57.      * @return
  58.      */
  59.     public byte[] dump(String key) {
  60.         return stringRedisTemplate.dump(key);
  61.     }
  63.     /**
  64.      * 【Key】 是否存在 key
  65.      * @return
  66.      */
  67.     public Boolean hasKey(String key) {
  68.         return stringRedisTemplate.hasKey(key);
  69.     }
  71.     /**
  72.      * 【Key】 设置 key 过期时间
  73.      * @param key
  74.      * @param timeout
  75.      * @param unit 时间单位, 天:TimeUnit.DAYS 小时:TimeUnit.HOURS 分钟:TimeUnit.MINUTES 秒:TimeUnit.SECONDS 毫秒:TimeUnit.MILLISECONDS
  76.      * @return
  77.      */
  78.     public Boolean expire(String key, long timeout, TimeUnit unit) {
  79.         return stringRedisTemplate.expire(key, timeout, unit);
  80.     }
  82.     /**
  83.      * 【Key】 设置 key 过期时间
  84.      * @param key
  85.      * @param date
  86.      * @return
  87.      */
  88.     public Boolean expireAt(String key, Date date) {
  89.         return stringRedisTemplate.expireAt(key, date);
  90.     }
  92.     /**
  93.      * 【Key】 获取 key 的剩余过期时间
  94.      * @param key
  95.      * @param timeUnit 
  96.      * @return
  97.      */
  98.     public Long getExpire(String key, TimeUnit timeUnit) {
  99.         return stringRedisTemplate.getExpire(key, timeUnit);
  100.     }
  102.     /**
  103.      * 【Key】 获取 key 的剩余过期时间
  104.      * @param key
  105.      * @return
  106.      */
  107.     public Long getExpire(String key) {
  108.         return stringRedisTemplate.getExpire(key);
  109.     }
  111.     /**
  112.      * 【Key】 移除 key 的过期时间， key 将不会过期
  113.      * @param key
  114.      * @return
  115.      */
  116.     public Boolean persist(String key) {
  117.         return stringRedisTemplate.persist(key);
  118.     }
  120.     /**
  121.      * 【Key】 查找匹配的 key
  122.      * @param pattern
  123.      * @return
  124.      */
  125.     public Set<String> keys(String pattern) {
  126.         return stringRedisTemplate.keys(pattern);
  127.     }
  129.     /**
  130.      * 【Key】 将当前 Redis 数据库分片中的 key 移到指定的数据库分片中
  131.      * @param key
  132.      * @param dbIndex Redis 数据库分片索引
  133.      * @return
  134.      */
  135.     public Boolean move(String key, int dbIndex) {
  136.         return stringRedisTemplate.move(key, dbIndex);
  137.     }
  139.     /**
  140.      * 【Key】 从当前 Redis 数据库分片中随机返回一个 key
  141.      * @return
  142.      */
  143.     public String randomKey() {
  144.         return stringRedisTemplate.randomKey();
  146.     }
  148.     /**
  149.      * 【Key】 重命名 key 的名称
  150.      * @param oldKey 当前 key 名称
  151.      * @param newKey 新的 key 名称
  152.      */
  153.     public void rename(String oldKey, String newKey) {
  154.         stringRedisTemplate.rename(oldKey, newKey);
  155.     }
  157.     /**
  158.      * 【Key】 仅当 newKey 不存在时，将 oldKey 重命名为 newKey
  159.      * @param oldKey
  160.      * @param newKey
  161.      * @return
  162.      */
  163.     public Boolean renameIfAbsent(String oldKey, String newKey) {
  164.         return stringRedisTemplate.renameIfAbsent(oldKey, newKey);
  165.     }
  167.     /**
  168.      * 【Key】 返回 key 所储存的值的类型
  169.      * @param key
  170.      * @return
  171.      */
  172.     public DataType type(String key) {
  173.         return stringRedisTemplate.type(key);
  174.     }
  177.     // ==================== String 常用相关操作 ==================== //
  179.     /**
  180.      * 【String】 设置指定 key 的值
  181.      * @param key
  182.      * @param value
  183.      */
  184.     public void set(String key, String value) {
  185.         stringRedisTemplate.opsForValue().set(key, value);
  186.     }
  188.     /**
  189.      * 【String】 只有在 key 不存在时才设置 key 的值
  190.      * @param key
  191.      * @param value
  192.      */
  193.     public Boolean setIfAbsent(String key, String value) {
  194.         return stringRedisTemplate.opsForValue().setIfAbsent(key, value);
  195.     }
  197.     /**
  198.      * 【String】 设置指定 key 的值，并指定过期时间
  199.      * @param key
  200.      * @param value
  201.      * @param timeout
  202.      */
  203.     public void set(String key, String value, Duration timeout) {
  204.         stringRedisTemplate.opsForValue().set(key, value, timeout);
  205.     }
  207.     /**
  208.      * 【String】 只有在 key 不存在时才设置 key 的值，并指定过期时间
  209.      * @param key
  210.      * @param value
  211.      * @param timeout
  212.      */
  213.     public Boolean setIfAbsent(String key, String value, Duration timeout) {
  214.         return stringRedisTemplate.opsForValue().setIfAbsent(key, value, timeout);
  215.     }
  217.     /**
  218.      * 【String】 设置指定 key 的值，并指定过期时间
  219.      * @param key
  220.      * @param value
  221.      * @param timeout
  222.      * @param unit 时间单位, 天:TimeUnit.DAYS 小时:TimeUnit.HOURS 分钟:TimeUnit.MINUTES 秒:TimeUnit.SECONDS 毫秒:TimeUnit.MILLISECONDS
  223.      */
  224.     public void set(String key, String value, long timeout, TimeUnit unit) {
  225.         stringRedisTemplate.opsForValue().set(key, value, timeout, unit);
  226.     }
  228.     /**
  229.      * 【String】 只有在 key 不存在时才设置 key 的值，并指定过期时间
  230.      * @param key
  231.      * @param value
  232.      * @param timeout
  233.      * @param unit
  234.      */
  235.     public Boolean setIfAbsent(String key, String value, long timeout, TimeUnit unit) {
  236.         return stringRedisTemplate.opsForValue().setIfAbsent(key, value, timeout, unit);
  237.     }
  239.     /**
  240.      * 【String】 批量设置 key-value 对
  241.      * @param map
  242.      */
  243.     public void multiSet(Map<String, String> map) {
  244.         stringRedisTemplate.opsForValue().multiSet(map);
  245.     }
  247.     /**
  248.      * 【String】 批量设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在
  249.      * @param map
  250.      */
  251.     public Boolean multiSetIfAbsent(Map<String, String> map) {
  252.         return stringRedisTemplate.opsForValue().multiSetIfAbsent(map);
  253.     }
  255.     /**
  256.      * 【String】 获取 key 的长度
  257.      * @param key
  258.      * @return
  259.      */
  260.     public Long size(String key) {
  261.         return stringRedisTemplate.opsForValue().size(key);
  262.     }
  264.     /**
  265.      * 【String】 增加(自增长), 负数则为自减
  266.      * @param key
  267.      * @param delta
  268.      * @return 返回自增或自减后的值
  269.      */
  270.     public Long increment(String key, long delta) {
  271.         return stringRedisTemplate.opsForValue().increment(key, delta);
  272.     }
  274.     /**
  275.      * 【String】 增加(自增长), 负数则为自减
  276.      * @param key
  277.      * @param delta
  278.      * @return 返回自增或自减后的值
  279.      */
  280.     public Double increment(String key, double delta) {
  281.         return stringRedisTemplate.opsForValue().increment(key, delta);
  282.     }
  284.     /**
  285.      * 【String】 追加值到末尾
  286.      * @param key
  287.      * @param value
  288.      * @return
  289.      */
  290.     public Integer append(String key, String value) {
  291.         return stringRedisTemplate.opsForValue().append(key, value);
  292.     }
  294.     /**
  295.      * 【String】 获取指定 key 的值
  296.      * @param key
  297.      * @return
  298.      */
  299.     public String get(String key) {
  300.         return stringRedisTemplate.opsForValue().get(key);
  301.     }
  303.     /**
  304.      * 【String】 返回存储在字符串值的子串key，由偏移确定start和end（两者都包括）
  305.      * 0表示第一个字符，1表示第二个字符，-1表示最后一个字符，-2表示倒数第二个字符，依此类推
  306.      * @param key
  307.      * @param start
  308.      * @param end
  309.      * @return
  310.      */
  311.     public String get(String key, long start, long end) {
  312.         return stringRedisTemplate.opsForValue().get(key, start, end);
  313.     }
  315.     /**
  316.      * 【String】 设置key到value，并返回 key 的旧值
  317.      * @param key
  318.      * @param value
  319.      * @return
  320.      */
  321.     public String getAndSet(String key, String value) {
  322.         return stringRedisTemplate.opsForValue().getAndSet(key, value);
  323.     }
  325.     /**
  326.      * 【String】 批量获取 key 的值
  327.      * @param keys
  328.      * @return
  329.      */
  330.     public List<String> multiGet(Collection<String> keys) {
  331.         return stringRedisTemplate.opsForValue().multiGet(keys);
  332.     }
  334.     // ==================== List 常用相关操作 ==================== //
  336.     /**
  337.      * 【List】 获取 key 的 index 索引的值
  338.      * @param key
  339.      * @param index
  340.      * @return
  341.      */
  342.     public String lIndex(String key, long index) {
  343.         return stringRedisTemplate.opsForList().index(key, index);
  344.     }
  346.     /**
  347.      * 【List】 获取 key 列表指定范围内的值
  348.      * @param key
  349.      * @param start 开始位置，0表示第一位
  350.      * @param end 结束位置，-1表示最后一位
  351.      * @return
  352.      */
  353.     public List<String> lRange(String key, long start, long end) {
  354.         return stringRedisTemplate.opsForList().range(key, start, end);
  355.     }
  357.     /**
  358.      * 【List】 将一个值插入到列表头部
  359.      * @param key
  360.      * @param value
  361.      * @return 返回列表的长度
  362.      */
  363.     public Long lLeftPush(String key, String value) {
  364.         return stringRedisTemplate.opsForList().leftPush(key, value);
  365.     }
  367.     /**
  368.      * 【List】 在 key 列表中的指定的值（pivot）的前一位添加指定的值（value），仅当 pivot 存在时有效
  369.      * @param key
  370.      * @param pivot
  371.      * @param value
  372.      * @return 返回列表的长度
  373.      */
  374.     public Long lLeftPush(String key, String pivot, String value) {
  375.         return stringRedisTemplate.opsForList().leftPush(key, pivot, value);
  376.     }
  378.     /**
  379.      * 【List】 将一个或多个值插入到列表头部
  380.      * @param key
  381.      * @param values
  382.      * @return 返回列表的长度
  383.      */
  384.     public Long lLeftPushAll(String key, String... values) {
  385.         return stringRedisTemplate.opsForList().leftPushAll(key, values);
  386.     }
  388.     /**
  389.      * 【List】 将一个或多个值插入到列表头部
  390.      * @param key
  391.      * @param values
  392.      * @return 返回列表的长度
  393.      */
  394.     public Long lLeftPushAll(String key, Collection<String> values) {
  395.         return stringRedisTemplate.opsForList().leftPushAll(key, values);
  396.     }
  398.     /**
  399.      * 【List】 仅当 key 列表存在的时候才添加值到列表头部
  400.      * @param key
  401.      * @param value
  402.      * @return 返回列表的长度
  403.      */
  404.     public Long leftPushIfPresent(String key, String value) {
  405.         return stringRedisTemplate.opsForList().leftPushIfPresent(key, value);
  406.     }
  408.     /**
  409.      * 【List】 将一个值添加到列表尾部
  410.      * @param key
  411.      * @param value
  412.      * @return 返回列表的长度
  413.      */
  414.     public Long lRightPush(String key, String value) {
  415.         return stringRedisTemplate.opsForList().rightPush(key, value);
  416.     }
  418.     /**
  419.      *  【List】 在 key 列表中的指定的值（pivot）的后一位添加指定的值（value），仅当 pivot 存在时有效
  420.      * @param key
  421.      * @param pivot
  422.      * @param value
  423.      * @return 返回列表的长度
  424.      */
  425.     public Long lRightPush(String key, String pivot, String value) {
  426.         return stringRedisTemplate.opsForList().rightPush(key, pivot, value);
  427.     }
  429.     /**
  430.      * 【List】 将一个或多个值插入到列表尾部
  431.      * @param key
  432.      * @param values
  433.      * @return 返回列表的长度
  434.      */
  435.     public Long lRightPushAll(String key, String... values) {
  436.         return stringRedisTemplate.opsForList().rightPushAll(key, values);
  437.     }
  439.     /**
  440.      * 【List】 将一个或多个值插入到列表尾部
  441.      * @param key
  442.      * @param values
  443.      * @return 返回列表的长度
  444.      */
  445.     public Long lRightPushAll(String key, Collection<String> values) {
  446.         return stringRedisTemplate.opsForList().rightPushAll(key, values);
  447.     }
  449.     /**
  450.      * 【List】 仅当 key 列表存在的时候才添加值到列表尾部
  451.      * @param key
  452.      * @param value
  453.      * @return 返回列表的长度
  454.      */
  455.     public Long lRightPushIfPresent(String key, String value) {
  456.         return stringRedisTemplate.opsForList().rightPushIfPresent(key, value);
  457.     }
  459.     /**
  460.      * 【List】 设置 key 列表的index索引上的值
  461.      * @param key
  462.      * @param index 索引
  463.      * @param value
  464.      */
  465.     public void lSet(String key, long index, String value) {
  466.         stringRedisTemplate.opsForList().set(key, index, value);
  467.     }
  469.     /**
  470.      * 【List】 移除并获取列表第一个元素
  471.      * @param key
  472.      * @return
  473.      */
  474.     public String lLeftPop(String key) {
  475.         return stringRedisTemplate.opsForList().leftPop(key);
  476.     }
  478.     /**
  479.      * 【List】 移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
  480.      * @param key
  481.      * @param timeout 时间
  482.      * @param unit 天:TimeUnit.DAYS 小时:TimeUnit.HOURS 分钟:TimeUnit.MINUTES 秒:TimeUnit.SECONDS 毫秒:TimeUnit.MILLISECONDS
  483.      * @return
  484.      */
  485.     public String lLeftPop(String key, long timeout, TimeUnit unit) {
  486.         return stringRedisTemplate.opsForList().leftPop(key, timeout, unit);
  487.     }
  489.     /**
  490.      * 【List】 移除并获取列表最后一个元素
  491.      * @param key
  492.      * @return
  493.      */
  494.     public String lRightPop(String key) {
  495.         return stringRedisTemplate.opsForList().rightPop(key);
  496.     }
  498.     /**
  499.      * 【List】 移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
  500.      * @param key
  501.      * @param timeout 时间
  502.      * @param unit 时间单位, 天:TimeUnit.DAYS 小时:TimeUnit.HOURS 分钟:TimeUnit.MINUTES 秒:TimeUnit.SECONDS 毫秒:TimeUnit.MILLISECONDS
  503.      * @return
  504.      */
  505.     public String lRightPop(String key, long timeout, TimeUnit unit) {
  506.         return stringRedisTemplate.opsForList().rightPop(key, timeout, unit);
  507.     }
  509.     /**
  510.      * 【List】 从 sourcekey 的列表中删除最后一个元素，将其附加到 destinationkey 的列表中并返回其值。
  511.      * @return
  512.      */
  513.     public String lRightPopAndLeftPush(String sourceKey, String destinationKey) {
  514.         return stringRedisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey);
  515.     }
  517.     /**
  518.      * 【List】 从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
  519.      * @param sourceKey
  520.      * @param destinationKey
  521.      * @param timeout
  522.      * @param unit 时间单位, 天:TimeUnit.DAYS 小时:TimeUnit.HOURS 分钟:TimeUnit.MINUTES 秒:TimeUnit.SECONDS 毫秒:TimeUnit.MILLISECONDS
  523.      * @return
  524.      */
  525.     public String lRightPopAndLeftPush(String sourceKey, String destinationKey, long timeout, TimeUnit unit) {
  526.         return stringRedisTemplate.opsForList().rightPopAndLeftPush(sourceKey, destinationKey, timeout, unit);
  527.     }
  529.     /**
  530.      * 【List】 从存储在键中的列表中删除等于值的元素的第一个计数事件。
  531.      * count > 0：从头不开始删除 count 个值等于 value 的元素
  532.      * count < 0：从尾部开始删除 count 个值等于 value 的元素
  533.      * count = 0：删除等于value的所有元素。
  534.      * @param key
  535.      * @param count
  536.      * @param value
  537.      * @return
  538.      */
  539.     public Long lRemove(String key, long count, Object value) {
  540.         return stringRedisTemplate.opsForList().remove(key, count, value);
  541.     }
  543.     /**
  544.      * 【List】 裁剪 list, 范围从索引0开始，都是包含关系
  545.      * @param key
  546.      * @param start
  547.      * @param end
  548.      */
  549.     public void lTrim(String key, long start, long end) {
  550.         stringRedisTemplate.opsForList().trim(key, start, end);
  551.     }
  553.     /**
  554.      * 【List】 获取列表的长度
  555.      * @param key
  556.      * @return
  557.      */
  558.     public Long lSize(String key) {
  559.         return stringRedisTemplate.opsForList().size(key);
  560.     }
  563.     // ==================== Set 常用相关操作 ==================== //
  565.     /**
  566.      * 【Set】 添加元素
  567.      * @param key
  568.      * @param values
  569.      * @return 返回值成功添加元素的个数
  570.      */
  571.     public Long sAdd(String key, String... values) {
  572.         return stringRedisTemplate.opsForSet().add(key, values);
  573.     }
  575.     /**
  576.      * 【Set】 移除元素
  577.      * @param key
  578.      * @param values
  579.      * @return 返回值成功移除元素的个数
  580.      */
  581.     public Long sRemove(String key, Object... values) {
  582.         return stringRedisTemplate.opsForSet().remove(key, values);
  583.     }
  585.     /**
  586.      * 【Set】 移除set集合中的一个随机元素并返回该元素
  587.      * @param key
  588.      * @return 返回被移除的随机元素
  589.      */
  590.     public String sPop(String key) {
  591.         return stringRedisTemplate.opsForSet().pop(key);
  592.     }
  594.     /**
  595.      * 【Set】 将value值从一个集合移动到另一个集合
  596.      * @param key
  597.      * @param value
  598.      * @param destKey
  599.      * @return
  600.      */
  601.     public Boolean sMove(String key, String value, String destKey) {
  602.         return stringRedisTemplate.opsForSet().move(key, value, destKey);
  603.     }
  605.     /**
  606.      * 【Set】 获取集合的大小
  607.      * @param key
  608.      * @return
  609.      */
  610.     public Long sSize(String key) {
  611.         return stringRedisTemplate.opsForSet().size(key);
  612.     }
  614.     /**
  615.      * 【Set】 判断集合是否包含value
  616.      * @param key
  617.      * @param value
  618.      * @return
  619.      */
  620.     public Boolean sIsMember(String key, Object value) {
  621.         return stringRedisTemplate.opsForSet().isMember(key, value);
  622.     }
  624.     /**
  625.      * 【Set】 获取两个集合的交集
  626.      * @param key
  627.      * @param otherKey
  628.      * @return
  629.      */
  630.     public Set<String> sIntersect(String key, String otherKey){
  631.         return stringRedisTemplate.opsForSet().intersect(key, otherKey);
  632.     }
  634.     /**
  635.      * 【Set】 获取key集合与多个集合的交集
  636.      * @param key
  637.      * @param otherKeys
  638.      * @return
  639.      */
  640.     public Set<String> sIntersect(String key, Collection<String> otherKeys) {
  641.         return stringRedisTemplate.opsForSet().intersect(key, otherKeys);
  642.     }
  644.     /**
  645.      * 【Set】key集合与otherKey集合的交集存储到destKey集合中
  646.      * @param key
  647.      * @param otherKey
  648.      * @param destKey
  649.      * @return
  650.      */
  651.     public Long sIntersectAndStore(String key, String otherKey, String destKey) {
  652.         return stringRedisTemplate.opsForSet().intersectAndStore(key, otherKey, destKey);
  653.     }
  655.     /**
  656.      * 【Set】 key集合与多个集合的交集存储到destKey集合中
  657.      * @param key
  658.      * @param otherKeys
  659.      * @param destKey
  660.      * @return
  661.      */
  662.     public Long sIntersectAndStore(String key, Collection<String> otherKeys,String destKey) {
  663.         return stringRedisTemplate.opsForSet().intersectAndStore(key, otherKeys, destKey);
  664.     }
  666.     /**
  667.      * 【Set】 获取两个集合的并集
  668.      * @param key
  669.      * @param otherKeys
  670.      * @return
  671.      */
  672.     public Set<String> sUnion(String key, String otherKeys) {
  673.         return stringRedisTemplate.opsForSet().union(key, otherKeys);
  674.     }
  676.     /**
  677.      * 【Set】 获取key集合与多个集合的并集
  678.      * @param key
  679.      * @param otherKeys
  680.      * @return
  681.      */
  682.     public Set<String> sUnion(String key, Collection<String> otherKeys) {
  683.         return stringRedisTemplate.opsForSet().union(key, otherKeys);
  684.     }
  686.     /**
  687.      * 【Set】 key集合与otherKey集合的并集存储到destKey中
  688.      * @param key
  689.      * @param otherKey
  690.      * @param destKey
  691.      * @return
  692.      */
  693.     public Long sUnionAndStore(String key, String otherKey, String destKey) {
  694.         return stringRedisTemplate.opsForSet().unionAndStore(key, otherKey, destKey);
  695.     }
  697.     /**
  698.      * 【Set】key集合与多个集合的并集存储到destKey中
  699.      * @param key
  700.      * @param otherKeys
  701.      * @param destKey
  702.      * @return
  703.      */
  704.     public Long sUnionAndStore(String key, Collection<String> otherKeys,String destKey) {
  705.         return stringRedisTemplate.opsForSet().unionAndStore(key, otherKeys, destKey);
  706.     }
  708.     /**
  709.      * 【Set】获取两个集合的差集
  710.      * @param key
  711.      * @param otherKey
  712.      * @return
  713.      */
  714.     public Set<String> sDifference(String key, String otherKey) {
  715.         return stringRedisTemplate.opsForSet().difference(key, otherKey);
  716.     }
  718.     /**
  719.      * 【Set】 获取key集合与多个集合的差集
  720.      * @param key
  721.      * @param otherKeys
  722.      * @return
  723.      */
  724.     public Set<String> sDifference(String key, Collection<String> otherKeys) {
  725.         return stringRedisTemplate.opsForSet().difference(key, otherKeys);
  726.     }
  728.     /**
  729.      * 【Set】 key集合与otherKey集合的差集存储到destKey中
  730.      * @param key
  731.      * @param otherKey
  732.      * @param destKey
  733.      * @return
  734.      */
  735.     public Long sDifferenceAndStore(String key, String otherKey, String destKey) {
  736.         return stringRedisTemplate.opsForSet().differenceAndStore(key, otherKey,destKey);
  737.     }
  739.     /**
  740.      * 【Set】 key集合与多个集合的差集存储到destKey中
  741.      * @param key
  742.      * @param otherKeys
  743.      * @param destKey
  744.      * @return
  745.      */
  746.     public Long sDifferenceAndStore(String key, Collection<String> otherKeys,String destKey) {
  747.         return stringRedisTemplate.opsForSet().differenceAndStore(key, otherKeys,destKey);
  748.     }
  750.     /**
  751.      * 【Set】 获取集合所有元素
  752.      * @param key
  753.      * @return
  754.      */
  755.     public Set<String> sMembers(String key) {
  756.         return stringRedisTemplate.opsForSet().members(key);
  757.     }
  759.     /**
  760.      * 【Set】 随机获取集合中的一个元素
  761.      * @param key
  762.      * @return
  763.      */
  764.     public String sRandomMember(String key) {
  765.         return stringRedisTemplate.opsForSet().randomMember(key);
  766.     }
  768.     /**
  769.      * 【Set】 随机获取集合中的一个元素
  770.      * @param key
  771.      * @return
  772.      */
  773.     public List<String> sRandomMembers(String key, long count) {
  774.         return stringRedisTemplate.opsForSet().randomMembers(key, count);
  775.     }
  777.     /**
  778.      * 【Set】 随机获取集合中count个元素并且去除重复的
  779.      * @param key
  780.      * @param count
  781.      * @return
  782.      */
  783.     public Set<String> sDistinctRandomMembers(String key, long count) {
  784.         return stringRedisTemplate.opsForSet().distinctRandomMembers(key, count);
  785.     }
  788.     // ==================== Hash 常用相关操作 ==================== //
  790.     /**
  791.      * 【Hash】 获取存储在哈希表中指定字段的值
  792.      * @param key
  793.      * @param hashKey
  794.      * @return
  795.      */
  796.     public Object hGet(String key, Object hashKey) {
  797.         return stringRedisTemplate.opsForHash().get(key, hashKey);
  798.     }
  800.     /**
  801.      * 【Hash】 获取所有给定字段的值
  802.      * @param key
  803.      * @return
  804.      */
  805.     public Map<Object, Object> hGetAll(String key) {
  806.         return stringRedisTemplate.opsForHash().entries(key);
  807.     }
  809.     /**
  810.      * 【Hash】 获取给定字段的值
  811.      * @param key
  812.      * @param hashKeys
  813.      * @return
  814.      */
  815.     public List<Object> hMultiGet(String key, Collection<Object> hashKeys) {
  816.         return stringRedisTemplate.opsForHash().multiGet(key, hashKeys);
  817.     }
  819.     /**
  820.      * 【Hash】 将value设置到指定的key
  821.      * @param key
  822.      * @param hashKey
  823.      * @param value
  824.      */
  825.     public void hPut(String key, String hashKey, String value) {
  826.         stringRedisTemplate.opsForHash().put(key, hashKey, value);
  827.     }
  829.     /**
  830.      * 【Hash】 将map设置到指定的key
  831.      * @param key
  832.      * @param map
  833.      */
  834.     public void hPutAll(String key, Map<String, String> map) {
  835.         stringRedisTemplate.opsForHash().putAll(key, map);
  836.     }
  838.     /**
  839.      * 【Hash】 仅当hashKey不存在时才设置
  840.      * @return
  841.      */
  842.     public Boolean hPutIfAbsent(String key, String hashKey, String value) {
  843.         return stringRedisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
  844.     }
  846.     /**
  847.      * 【Hash】 删除一个或多个哈希表字段
  848.      * @param key
  849.      * @param hashKeys
  850.      * @return
  851.      */
  852.     public Long hDelete(String key, Object... hashKeys) {
  853.         return stringRedisTemplate.opsForHash().delete(key, hashKeys);
  854.     }
  856.     /**
  857.      * 【Hash】 查看哈希表 key 中，指定的字段是否存在
  858.      * @param key
  859.      * @param hashKey
  860.      * @return
  861.      */
  862.     public Boolean hExists(String key, Object hashKey) {
  863.         return stringRedisTemplate.opsForHash().hasKey(key, hashKey);
  864.     }
  866.     /**
  867.      * 【Hash】 为哈希表 key 中的指定字段的整数值加上增量 increment
  868.      * @param key
  869.      * @param hashKey
  870.      * @param delta
  871.      * @return 返回增量后的数值
  872.      */
  873.     public Long hIncrement(String key, Object hashKey, long delta) {
  874.         return stringRedisTemplate.opsForHash().increment(key, hashKey, delta);
  875.     }
  877.     /**
  878.      * 【Hash】 为哈希表 key 中的指定字段的整数值加上增量 increment
  879.      * @param key
  880.      * @param hashKey
  881.      * @param delta
  882.      * @return 返回增量后的数值
  883.      */
  884.     public Double hIncrement(String key, Object hashKey, double delta) {
  885.         return stringRedisTemplate.opsForHash().increment(key, hashKey, delta);
  886.     }
  888.     /**
  889.      * 【Hash】 获取所有哈希表中的字段
  890.      * @param key
  891.      * @return
  892.      */
  893.     public Set<Object> hKeys(String key) {
  894.         return stringRedisTemplate.opsForHash().keys(key);
  895.     }
  897.     /**
  898.      * 【Hash】 获取哈希表中字段的数量
  899.      * @param key
  900.      * @return
  901.      */
  902.     public Long hSize(String key) {
  903.         return stringRedisTemplate.opsForHash().size(key);
  904.     }
  906.     /**
  907.      * 【Hash】 获取哈希表中所有值
  908.      * @param key
  909.      * @return
  910.      */
  911.     public List<Object> hValues(String key) {
  912.         return stringRedisTemplate.opsForHash().values(key);
  913.     }
  916. }

友情链接

layui
© 2020-2025 www.chenhuazhan.com All Rights Reserved 备案号：桂ICP备17004487号-1 粤公网安备44030002005146