devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Redis工具类:redisTemplate_redistemplate 工具类

作者：Cpp五条 | 2024-03-15 11:37:16

赞

踩

redistemplate 工具类
  1. import org.springframework.data.redis.connection.DataType;
  2. import org.springframework.data.redis.core.Cursor;
  3. import org.springframework.data.redis.core.ScanOptions;
  4. import org.springframework.data.redis.core.StringRedisTemplate;
  5. import org.springframework.data.redis.core.ZSetOperations.TypedTuple;
  6.  
  7. import java.util.Collection;
  8. import java.util.Date;
  9. import java.util.List;
  10. import java.util.Map;
  11. import java.util.Map.Entry;
  12. import java.util.Set;
  13. import java.util.concurrent.TimeUnit;
  14.  
  15. /**
  16.  * Redis工具类*/
  17. public class RedisUtil {
  18.     private StringRedisTemplate redisTemplate;
  19.  
  20.     public void setRedisTemplate(StringRedisTemplate redisTemplate) {
  21.         this.redisTemplate = redisTemplate;
  22.     }
  23.  
  24.     public StringRedisTemplate getRedisTemplate() {
  25.         return this.redisTemplate;
  26.     }
  27.  
  28.     /** -------------------key相关操作--------------------- */
  29.  
  30.     /**
  31.      * 删除key
  32.      * 
  33.      * @param key
  34.      */
  35.     public void delete(String key) {
  36.         redisTemplate.delete(key);
  37.     }
  38.  
  39.     /**
  40.      * 批量删除key
  41.      * 
  42.      * @param keys
  43.      */
  44.     public void delete(Collection<String> keys) {
  45.         redisTemplate.delete(keys);
  46.     }
  47.  
  48.     /**
  49.      * 序列化key
  50.      * 
  51.      * @param key
  52.      * @return
  53.      */
  54.     public byte[] dump(String key) {
  55.         return redisTemplate.dump(key);
  56.     }
  57.  
  58.     /**
  59.      * 是否存在key
  60.      * 
  61.      * @param key
  62.      * @return
  63.      */
  64.     public Boolean hasKey(String key) {
  65.         return redisTemplate.hasKey(key);
  66.     }
  67.  
  68.     /**
  69.      * 设置过期时间
  70.      * 
  71.      * @param key
  72.      * @param timeout
  73.      * @param unit
  74.      * @return
  75.      */
  76.     public Boolean expire(String key, long timeout, TimeUnit unit) {
  77.         return redisTemplate.expire(key, timeout, unit);
  78.     }
  79.     注意:TimeUnit: 常用的颗粒度  
  80.         TimeUnit.DAYS          //天
  81. 		TimeUnit.HOURS         //小时
  82.     /**
  83.      * 设置过期时间
  84.      * 
  85.      * @param key
  86.      * @param date
  87.      * @return
  88.      */
  89.     public Boolean expireAt(String key, Date date) {
  90.         return redisTemplate.expireAt(key, date);
  91.     }
  92.  
  93.     /**
  94.      * 查找匹配的key
  95.      * 
  96.      * @param pattern
  97.      * @return
  98.      */
  99.     public Set<String> keys(String pattern) {
  100.         return redisTemplate.keys(pattern);
  101.     }
  102.  
  103.     /**
  104.      * 将当前数据库的 key 移动到给定的数据库 db 当中
  105.      * 
  106.      * @param key
  107.      * @param dbIndex
  108.      * @return
  109.      */
  110.     public Boolean move(String key, int dbIndex) {
  111.         return redisTemplate.move(key, dbIndex);
  112.     }
  113.  
  114.     /**
  115.      * 移除 key 的过期时间，key 将持久保持
  116.      * 
  117.      * @param key
  118.      * @return
  119.      */
  120.     public Boolean persist(String key) {
  121.         return redisTemplate.persist(key);
  122.     }
  123.  
  124.     /**
  125.      * 返回 key 的剩余的过期时间
  126.      * 
  127.      * @param key
  128.      * @param unit
  129.      * @return
  130.      */
  131.     public Long getExpire(String key, TimeUnit unit) {
  132.         return redisTemplate.getExpire(key, unit);
  133.     }
  134.  
  135.     /**
  136.      * 返回 key 的剩余的过期时间
  137.      * 
  138.      * @param key
  139.      * @return
  140.      */
  141.     public Long getExpire(String key) {
  142.         return redisTemplate.getExpire(key);
  143.     }
  144.  
  145.     /**
  146.      * 从当前数据库中随机返回一个 key
  147.      * 
  148.      * @return
  149.      */
  150.     public String randomKey() {
  151.         return redisTemplate.randomKey();
  152.     }
  153.  
  154.     /**
  155.      * 修改 key 的名称
  156.      * 
  157.      * @param oldKey
  158.      * @param newKey
  159.      */
  160.     public void rename(String oldKey, String newKey) {
  161.         redisTemplate.rename(oldKey, newKey);
  162.     }
  163.  
  164.     /**
  165.      * 仅当 newkey 不存在时，将 oldKey 改名为 newkey
  166.      * 
  167.      * @param oldKey
  168.      * @param newKey
  169.      * @return
  170.      */
  171.     public Boolean renameIfAbsent(String oldKey, String newKey) {
  172.         return redisTemplate.renameIfAbsent(oldKey, newKey);
  173.     }
  174.  
  175.     /**
  176.      * 返回 key 所储存的值的类型
  177.      * 
  178.      * @param key
  179.      * @return
  180.      */
  181.     public DataType type(String key) {
  182.         return redisTemplate.type(key);
  183.     }
  184.  
  185.     /** -------------------string相关操作--------------------- */
  186.  
  187.     /**
  188.      * 设置指定 key 的值
  189.      * @param key
  190.      * @param value
  191.      */
  192.     public void set(String key, String value) {
  193.         redisTemplate.opsForValue().set(key, value);
  194.     }
  195.  
  196.     /**
  197.      * 获取指定 key 的值
  198.      * @param key
  199.      * @return
  200.      */
  201.     public String get(String key) {
  202.         return redisTemplate.opsForValue().get(key);
  203.     }
  204.  
  205.     /**
  206.      * 返回 key 中字符串值的子字符
  207.      * @param key
  208.      * @param start
  209.      * @param end
  210.      * @return
  211.      */
  212.     public String getRange(String key, long start, long end) {
  213.         return redisTemplate.opsForValue().get(key, start, end);
  214.     }
  215.  
  216.     /**
  217.      * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)
  218.      * 
  219.      * @param key
  220.      * @param value
  221.      * @return
  222.      */
  223.     public String getAndSet(String key, String value) {
  224.         return redisTemplate.opsForValue().getAndSet(key, value);
  225.     }
  226.  
  227.     /**
  228.      * 对 key 所储存的字符串值，获取指定偏移量上的位(bit)
  229.      * 
  230.      * @param key
  231.      * @param offset
  232.      * @return
  233.      */
  234.     public Boolean getBit(String key, long offset) {
  235.         return redisTemplate.opsForValue().getBit(key, offset);
  236.     }
  237.  
  238.     /**
  239.      * 批量获取
  240.      * 
  241.      * @param keys
  242.      * @return
  243.      */
  244.     public List<String> multiGet(Collection<String> keys) {
  245.         return redisTemplate.opsForValue().multiGet(keys);
  246.     }
  247.  
  248.     /**
  249.      * 设置ASCII码, 字符串'a'的ASCII码是97, 转为二进制是'01100001', 此方法是将二进制第offset位值变为value
  250.      * 
  251.      * @param key 位置
  252.      * @param value
  253.      *            值,true为1, false为0
  254.      * @return
  255.      */
  256.     public boolean setBit(String key, long offset, boolean value) {
  257.         return redisTemplate.opsForValue().setBit(key, offset, value);
  258.     }
  259.  
  260.     /**
  261.      * 将值 value 关联到 key ，并将 key 的过期时间设为 timeout
  262.      * 
  263.      * @param key
  264.      * @param value
  265.      * @param timeout
  266.      *            过期时间
  267.      * @param unit
  268.      *            时间单位, 天:TimeUnit.DAYS 小时:TimeUnit.HOURS 分钟:TimeUnit.MINUTES
  269.      *            秒:TimeUnit.SECONDS 毫秒:TimeUnit.MILLISECONDS
  270.      */
  271.     public void setEx(String key, String value, long timeout, TimeUnit unit) {
  272.         redisTemplate.opsForValue().set(key, value, timeout, unit);
  273.     }
  274.  
  275.     /**
  276.      * 只有在 key 不存在时设置 key 的值
  277.      * 
  278.      * @param key
  279.      * @param value
  280.      * @return 之前已经存在返回false,不存在返回true
  281.      */
  282.     public boolean setIfAbsent(String key, String value) {
  283.         return redisTemplate.opsForValue().setIfAbsent(key, value);
  284.     }
  285.  
  286.     /**
  287.      * 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始
  288.      * 
  289.      * @param key
  290.      * @param value
  291.      * @param offset
  292.      *            从指定位置开始覆写
  293.      */
  294.     public void setRange(String key, String value, long offset) {
  295.         redisTemplate.opsForValue().set(key, value, offset);
  296.     }
  297.  
  298.     /**
  299.      * 获取字符串的长度
  300.      * 
  301.      * @param key
  302.      * @return
  303.      */
  304.     public Long size(String key) {
  305.         return redisTemplate.opsForValue().size(key);
  306.     }
  307.  
  308.     /**
  309.      * 批量添加
  310.      * 
  311.      * @param maps
  312.      */
  313.     public void multiSet(Map<String, String> maps) {
  314.         redisTemplate.opsForValue().multiSet(maps);
  315.     }
  316.  
  317.     /**
  318.      * 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在
  319.      * 
  320.      * @param maps
  321.      * @return 之前已经存在返回false,不存在返回true
  322.      */
  323.     public boolean multiSetIfAbsent(Map<String, String> maps) {
  324.         return redisTemplate.opsForValue().multiSetIfAbsent(maps);
  325.     }
  326.  
  327.     /**
  328.      * 增加(自增长), 负数则为自减
  329.      * 
  330.      * @param key
  331.      * @return
  332.      */
  333.     public Long incrBy(String key, long increment) {
  334.         return redisTemplate.opsForValue().increment(key, increment);
  335.     }
  336.  
  337.     /**
  338.      * 
  339.      * @param key
  340.      * @return
  341.      */
  342.     public Double incrByFloat(String key, double increment) {
  343.         return redisTemplate.opsForValue().increment(key, increment);
  344.     }
  345.  
  346.     /**
  347.      * 追加到末尾
  348.      * 
  349.      * @param key
  350.      * @param value
  351.      * @return
  352.      */
  353.     public Integer append(String key, String value) {
  354.         return redisTemplate.opsForValue().append(key, value);
  355.     }
  356.  
  357.     /** -------------------hash相关操作------------------------- */
  358.  
  359.     /**
  360.      * 获取存储在哈希表中指定字段的值
  361.      * 
  362.      * @param key
  363.      * @param field
  364.      * @return
  365.      */
  366.     public Object hGet(String key, String field) {
  367.         return redisTemplate.opsForHash().get(key, field);
  368.     }
  369.  
  370.     /**
  371.      * 获取所有给定字段的值
  372.      * 
  373.      * @param key
  374.      * @return
  375.      */
  376.     public Map<Object, Object> hGetAll(String key) {
  377.         return redisTemplate.opsForHash().entries(key);
  378.     }
  379.  
  380.     /**
  381.      * 获取所有给定字段的值
  382.      * 
  383.      * @param key
  384.      * @param fields
  385.      * @return
  386.      */
  387.     public List<Object> hMultiGet(String key, Collection<Object> fields) {
  388.         return redisTemplate.opsForHash().multiGet(key, fields);
  389.     }
  390.  
  391.     public void hPut(String key, String hashKey, String value) {
  392.         redisTemplate.opsForHash().put(key, hashKey, value);
  393.     }
  394.  
  395.     public void hPutAll(String key, Map<String, String> maps) {
  396.         redisTemplate.opsForHash().putAll(key, maps);
  397.     }
  398.  
  399.     /**
  400.      * 仅当hashKey不存在时才设置
  401.      * 
  402.      * @param key
  403.      * @param hashKey
  404.      * @param value
  405.      * @return
  406.      */
  407.     public Boolean hPutIfAbsent(String key, String hashKey, String value) {
  408.         return redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
  409.     }
  410.  
  411.     /**
  412.      * 删除一个或多个哈希表字段
  413.      * 
  414.      * @param key
  415.      * @param fields
  416.      * @return
  417.      */
  418.     public Long hDelete(String key, Object... fields) {
  419.         return redisTemplate.opsForHash().delete(key, fields);
  420.     }
  421.  
  422.     /**
  423.      * 查看哈希表 key 中，指定的字段是否存在
  424.      * 
  425.      * @param key
  426.      * @param field
  427.      * @return
  428.      */
  429.     public boolean hExists(String key, String field) {
  430.         return redisTemplate.opsForHash().hasKey(key, field);
  431.     }
  432.  
  433.     /**
  434.      * 为哈希表 key 中的指定字段的整数值加上增量 increment
  435.      * 
  436.      * @param key
  437.      * @param field
  438.      * @param increment
  439.      * @return
  440.      */
  441.     public Long hIncrBy(String key, Object field, long increment) {
  442.         return redisTemplate.opsForHash().increment(key, field, increment);
  443.     }
  444.  
  445.     /**
  446.      * 为哈希表 key 中的指定字段的整数值加上增量 increment
  447.      * 
  448.      * @param key
  449.      * @param field
  450.      * @param delta
  451.      * @return
  452.      */
  453.     public Double hIncrByFloat(String key, Object field, double delta) {
  454.         return redisTemplate.opsForHash().increment(key, field, delta);
  455.     }
  456.  
  457.     /**
  458.      * 获取所有哈希表中的字段
  459.      * 
  460.      * @param key
  461.      * @return
  462.      */
  463.     public Set<Object> hKeys(String key) {
  464.         return redisTemplate.opsForHash().keys(key);
  465.     }
  466.  
  467.     /**
  468.      * 获取哈希表中字段的数量
  469.      * 
  470.      * @param key
  471.      * @return
  472.      */
  473.     public Long hSize(String key) {
  474.         return redisTemplate.opsForHash().size(key);
  475.     }
  476.  
  477.     /**
  478.      * 获取哈希表中所有值
  479.      * 
  480.      * @param key
  481.      * @return
  482.      */
  483.     public List<Object> hValues(String key) {
  484.         return redisTemplate.opsForHash().values(key);
  485.     }
  486.  
  487.     /**
  488.      * 迭代哈希表中的键值对
  489.      * 
  490.      * @param key
  491.      * @param options
  492.      * @return
  493.      */
  494.     public Cursor<Entry<Object, Object>> hScan(String key, ScanOptions options) {
  495.         return redisTemplate.opsForHash().scan(key, options);
  496.     }
  497.  
  498.     /** ------------------------list相关操作---------------------------- */
  499.  
  500.     /**
  501.      * 通过索引获取列表中的元素
  502.      * 
  503.      * @param key
  504.      * @param index
  505.      * @return
  506.      */
  507.     public String lIndex(String key, long index) {
  508.         return redisTemplate.opsForList().index(key, index);
  509.     }
  510.  
  511.     /**
  512.      * 获取列表指定范围内的元素
  513.      * 
  514.      * @param key
  515.      * @param start
  516.      *            开始位置, 0是开始位置
  517.      * @param end
  518.      *            结束位置, -1返回所有
  519.      * @return
  520.      */
  521.     public List<String> lRange(String key, long start, long end) {
  522.         return redisTemplate.opsForList().range(key, start, end);
  523.     }
  524.  
  525.     /**
  526.      * 存储在list头部
  527.      * 
  528.      * @param key
  529.      * @param value
  530.      * @return
  531.      */
  532.     public Long lLeftPush(String key, String value) {
  533.         return redisTemplate.opsForList().leftPush(key, value);
  534.     }
  535.  
  536.     /**
  537.      * 
  538.      * @param key
  539.      * @param value
  540.      * @return
  541.      */
  542.     public Long lLeftPushAll(String key, String... value) {
  543.         return redisTemplate.opsForList().leftPushAll(key, value);
  544.     }
  545.  
  546.     /**
  547.      * 
  548.      * @param key
  549.      * @param value
  550.      * @return
  551.      */
  552.     public Long lLeftPushAll(String key, Collection<String> value) {
  553.         return redisTemplate.opsForList().leftPushAll(key, value);
  554.     }
  555.  
  556.     /**
  557.      * 当list存在的时候才加入
  558.      * 
  559.      * @param key
  560.      * @param value
  561.      * @return
  562.      */
  563.     public Long lLeftPushIfPresent(String key, String value) {
  564.         return redisTemplate.opsForList().leftPushIfPresent(key, value);
  565.     }
  566.  
  567.     /**
  568.      * 如果pivot存在,再pivot前面添加
  569.      * 
  570.      * @param key
  571.      * @param pivot
  572.      * @param value
  573.      * @return
  574.      */
  575.     public Long lLeftPush(String key, String pivot, String value) {
  576.         return redisTemplate.opsForList().leftPush(key, pivot, value);
  577.     }
  578.  
  579.     /**
  580.      * 
  581.      * @param key
  582.      * @param value
  583.      * @return
  584.      */
  585.     public Long lRightPush(String key, String value) {
  586.         return redisTemplate.opsForList().rightPush(key, value);
  587.     }
  588.  
  589.     /**
  590.      * 
  591.      * @param key
  592.      * @param value
  593.      * @return
  594.      */
  595.     public Long lRightPushAll(String key, String... value) {
  596.         return redisTemplate.opsForList().rightPushAll(key, value);
  597.     }
  598.  
  599.     /**
  600.      * 
  601.      * @param key
  602.      * @param value
  603.      * @return
  604.      */
  605.     public Long lRightPushAll(String key, Collection<String> value) {
  606.         return redisTemplate.opsForList().rightPushAll(key, value);
  607.     }
  608.  
  609.     /**
  610.      * 为已存在的列表添加值
  611.      * 
  612.      * @param key
  613.      * @param value
  614.      * @return
  615.      */
  616.     public Long lRightPushIfPresent(String key, String value) {
  617.         return redisTemplate.opsForList().rightPushIfPresent(key, value);
  618.     }
  619.  
  620.     /**
  621.      * 在pivot元素的右边添加值
  622.      * 
  623.      * @param key
  624.      * @param pivot
  625.      * @param value
  626.      * @return
  627.      */
  628.     public Long lRightPush(String key, String pivot, String value) {
  629.         return redisTemplate.opsForList().rightPush(key, pivot, value);
  630.     }
  631.  
  632.     /**
  633.      * 通过索引设置列表元素的值
  634.      * 
  635.      * @param key
  636.      * @param index
  637.      *            位置
  638.      * @param value
  639.      */
  640.     public void lSet(String key, long index, String value) {
  641.         redisTemplate.opsForList().set(key, index, value);
  642.     }
  643.  
  644.     /**
  645.      * 移出并获取列表的第一个元素
  646.      * 
  647.      * @param key
  648.      * @return 删除的元素
  649.      */
  650.     public String lLeftPop(String key) {
  651.         return redisTemplate.opsForList().leftPop(key);
  652.     }
  653.  
  654.     /**
  655.      * 移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
  656.      * 
  657.      * @param key
  658.      * @param timeout
  659.      *            等待时间
  660.      * @param unit
  661.      *            时间单位
  662.      * @return
  663.      */
  664.     public String lBLeftPop(String key, long timeout, TimeUnit unit) {
  665.         return redisTemplate.opsForList().leftPop(key, timeout, unit);
  666.     }
  667.  
  668.     /**
  669.      * 移除并获取列表最后一个元素
  670.      * 
  671.      * @param key
  672.      * @return 删除的元素
  673.      */
  674.     public String lRightPop(String key) {
  675.         return redisTemplate.opsForList().rightPop(key);
  676.     }
  677.  
  678.     /**
  679.      * 移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
  680.      * 
  681.      * @param key
  682.      * @param timeout
  683.      *            等待时间
  684.      * @param unit
  685.      *            时间单位
  686.      * @return
  687.      */
  688.     public String lBRightPop(String key, long timeout, TimeUnit unit) {
  689.         return redisTemplate.opsForList().rightPop(key, timeout, unit);
  690.     }
  691.  
  692.     /**
  693.      * 移除列表的最后一个元素，并将该元素添加到另一个列表并返回
  694.      * 
  695.      * @param sourceKey
  696.      * @param destinationKey
  697.      * @return
  698.      */
  699.     public String lRightPopAndLeftPush(String sourceKey, String destinationKey) {
  700.         return redisTemplate.opsForList().rightPopAndLeftPush(sourceKey,
  701.                 destinationKey);
  702.     }
  703.  
  704.     /**
  705.      * 从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
  706.      * 
  707.      * @param sourceKey
  708.      * @param destinationKey
  709.      * @param timeout
  710.      * @param unit
  711.      * @return
  712.      */
  713.     public String lBRightPopAndLeftPush(String sourceKey, String destinationKey,
  714.             long timeout, TimeUnit unit) {
  715.         return redisTemplate.opsForList().rightPopAndLeftPush(sourceKey,
  716.                 destinationKey, timeout, unit);
  717.     }
  718.  
  719.     /**
  720.      * 删除集合中值等于value得元素
  721.      * 
  722.      * @param key
  723.      * @param index
  724.      *            index=0, 删除所有值等于value的元素; index>0, 从头部开始删除第一个值等于value的元素;
  725.      *            index<0, 从尾部开始删除第一个值等于value的元素;
  726.      * @param value
  727.      * @return
  728.      */
  729.     public Long lRemove(String key, long index, String value) {
  730.         return redisTemplate.opsForList().remove(key, index, value);
  731.     }
  732.  
  733.     /**
  734.      * 裁剪list
  735.      * 
  736.      * @param key
  737.      * @param start
  738.      * @param end
  739.      */
  740.     public void lTrim(String key, long start, long end) {
  741.         redisTemplate.opsForList().trim(key, start, end);
  742.     }
  743.  
  744.     /**
  745.      * 获取列表长度
  746.      * 
  747.      * @param key
  748.      * @return
  749.      */
  750.     public Long lLen(String key) {
  751.         return redisTemplate.opsForList().size(key);
  752.     }
  753.  
  754.     /** --------------------set相关操作-------------------------- */
  755.  
  756.     /**
  757.      * set添加元素
  758.      * 
  759.      * @param key
  760.      * @param values
  761.      * @return
  762.      */
  763.     public Long sAdd(String key, String... values) {
  764.         return redisTemplate.opsForSet().add(key, values);
  765.     }
  766.  
  767.     /**
  768.      * set移除元素
  769.      * 
  770.      * @param key
  771.      * @param values
  772.      * @return
  773.      */
  774.     public Long sRemove(String key, Object... values) {
  775.         return redisTemplate.opsForSet().remove(key, values);
  776.     }
  777.  
  778.     /**
  779.      * 移除并返回集合的一个随机元素
  780.      * 
  781.      * @param key
  782.      * @return
  783.      */
  784.     public String sPop(String key) {
  785.         return redisTemplate.opsForSet().pop(key);
  786.     }
  787.  
  788.     /**
  789.      * 将元素value从一个集合移到另一个集合
  790.      * 
  791.      * @param key
  792.      * @param value
  793.      * @param destKey
  794.      * @return
  795.      */
  796.     public Boolean sMove(String key, String value, String destKey) {
  797.         return redisTemplate.opsForSet().move(key, value, destKey);
  798.     }
  799.  
  800.     /**
  801.      * 获取集合的大小
  802.      * 
  803.      * @param key
  804.      * @return
  805.      */
  806.     public Long sSize(String key) {
  807.         return redisTemplate.opsForSet().size(key);
  808.     }
  809.  
  810.     /**
  811.      * 判断集合是否包含value
  812.      * 
  813.      * @param key
  814.      * @param value
  815.      * @return
  816.      */
  817.     public Boolean sIsMember(String key, Object value) {
  818.         return redisTemplate.opsForSet().isMember(key, value);
  819.     }
  820.  
  821.     /**
  822.      * 获取两个集合的交集
  823.      * 
  824.      * @param key
  825.      * @param otherKey
  826.      * @return
  827.      */
  828.     public Set<String> sIntersect(String key, String otherKey) {
  829.         return redisTemplate.opsForSet().intersect(key, otherKey);
  830.     }
  831.  
  832.     /**
  833.      * 获取key集合与多个集合的交集
  834.      * 
  835.      * @param key
  836.      * @param otherKeys
  837.      * @return
  838.      */
  839.     public Set<String> sIntersect(String key, Collection<String> otherKeys) {
  840.         return redisTemplate.opsForSet().intersect(key, otherKeys);
  841.     }
  842.  
  843.     /**
  844.      * key集合与otherKey集合的交集存储到destKey集合中
  845.      * 
  846.      * @param key
  847.      * @param otherKey
  848.      * @param destKey
  849.      * @return
  850.      */
  851.     public Long sIntersectAndStore(String key, String otherKey, String destKey) {
  852.         return redisTemplate.opsForSet().intersectAndStore(key, otherKey,
  853.                 destKey);
  854.     }
  855.  
  856.     /**
  857.      * key集合与多个集合的交集存储到destKey集合中
  858.      * 
  859.      * @param key
  860.      * @param otherKeys
  861.      * @param destKey
  862.      * @return
  863.      */
  864.     public Long sIntersectAndStore(String key, Collection<String> otherKeys,
  865.             String destKey) {
  866.         return redisTemplate.opsForSet().intersectAndStore(key, otherKeys,
  867.                 destKey);
  868.     }
  869.  
  870.     /**
  871.      * 获取两个集合的并集
  872.      * 
  873.      * @param key
  874.      * @param otherKeys
  875.      * @return
  876.      */
  877.     public Set<String> sUnion(String key, String otherKeys) {
  878.         return redisTemplate.opsForSet().union(key, otherKeys);
  879.     }
  880.  
  881.     /**
  882.      * 获取key集合与多个集合的并集
  883.      * 
  884.      * @param key
  885.      * @param otherKeys
  886.      * @return
  887.      */
  888.     public Set<String> sUnion(String key, Collection<String> otherKeys) {
  889.         return redisTemplate.opsForSet().union(key, otherKeys);
  890.     }
  891.  
  892.     /**
  893.      * key集合与otherKey集合的并集存储到destKey中
  894.      * 
  895.      * @param key
  896.      * @param otherKey
  897.      * @param destKey
  898.      * @return
  899.      */
  900.     public Long sUnionAndStore(String key, String otherKey, String destKey) {
  901.         return redisTemplate.opsForSet().unionAndStore(key, otherKey, destKey);
  902.     }
  903.  
  904.     /**
  905.      * key集合与多个集合的并集存储到destKey中
  906.      * 
  907.      * @param key
  908.      * @param otherKeys
  909.      * @param destKey
  910.      * @return
  911.      */
  912.     public Long sUnionAndStore(String key, Collection<String> otherKeys,
  913.             String destKey) {
  914.         return redisTemplate.opsForSet().unionAndStore(key, otherKeys, destKey);
  915.     }
  916.  
  917.     /**
  918.      * 获取两个集合的差集
  919.      * 
  920.      * @param key
  921.      * @param otherKey
  922.      * @return
  923.      */
  924.     public Set<String> sDifference(String key, String otherKey) {
  925.         return redisTemplate.opsForSet().difference(key, otherKey);
  926.     }
  927.  
  928.     /**
  929.      * 获取key集合与多个集合的差集
  930.      * 
  931.      * @param key
  932.      * @param otherKeys
  933.      * @return
  934.      */
  935.     public Set<String> sDifference(String key, Collection<String> otherKeys) {
  936.         return redisTemplate.opsForSet().difference(key, otherKeys);
  937.     }
  938.  
  939.     /**
  940.      * key集合与otherKey集合的差集存储到destKey中
  941.      * 
  942.      * @param key
  943.      * @param otherKey
  944.      * @param destKey
  945.      * @return
  946.      */
  947.     public Long sDifference(String key, String otherKey, String destKey) {
  948.         return redisTemplate.opsForSet().differenceAndStore(key, otherKey,
  949.                 destKey);
  950.     }
  951.  
  952.     /**
  953.      * key集合与多个集合的差集存储到destKey中
  954.      * 
  955.      * @param key
  956.      * @param otherKeys
  957.      * @param destKey
  958.      * @return
  959.      */
  960.     public Long sDifference(String key, Collection<String> otherKeys,
  961.             String destKey) {
  962.         return redisTemplate.opsForSet().differenceAndStore(key, otherKeys,
  963.                 destKey);
  964.     }
  965.  
  966.     /**
  967.      * 获取集合所有元素
  968.      * 
  969.      * @param key
  970.      * @return
  971.      */
  972.     public Set<String> setMembers(String key) {
  973.         return redisTemplate.opsForSet().members(key);
  974.     }
  975.  
  976.     /**
  977.      * 随机获取集合中的一个元素
  978.      * 
  979.      * @param key
  980.      * @return
  981.      */
  982.     public String sRandomMember(String key) {
  983.         return redisTemplate.opsForSet().randomMember(key);
  984.     }
  985.  
  986.     /**
  987.      * 随机获取集合中count个元素
  988.      * 
  989.      * @param key
  990.      * @param count
  991.      * @return
  992.      */
  993.     public List<String> sRandomMembers(String key, long count) {
  994.         return redisTemplate.opsForSet().randomMembers(key, count);
  995.     }
  996.  
  997.     /**
  998.      * 随机获取集合中count个元素并且去除重复的
  999.      * 
  1000.      * @param key
  1001.      * @param count
  1002.      * @return
  1003.      */
  1004.     public Set<String> sDistinctRandomMembers(String key, long count) {
  1005.         return redisTemplate.opsForSet().distinctRandomMembers(key, count);
  1006.     }
  1007.  
  1008.     /**
  1009.      * 
  1010.      * @param key
  1011.      * @param options
  1012.      * @return
  1013.      */
  1014.     public Cursor<String> sScan(String key, ScanOptions options) {
  1015.         return redisTemplate.opsForSet().scan(key, options);
  1016.     }
  1017.  
  1018.     /**------------------zSet相关操作--------------------------------*/
  1019.     
  1020.     /**
  1021.      * 添加元素,有序集合是按照元素的score值由小到大排列
  1022.      * 
  1023.      * @param key
  1024.      * @param value
  1025.      * @param score
  1026.      * @return
  1027.      */
  1028.     public Boolean zAdd(String key, String value, double score) {
  1029.         return redisTemplate.opsForZSet().add(key, value, score);
  1030.     }
  1031.  
  1032.     /**
  1033.      * 
  1034.      * @param key
  1035.      * @param values
  1036.      * @return
  1037.      */
  1038.     public Long zAdd(String key, Set<TypedTuple<String>> values) {
  1039.         return redisTemplate.opsForZSet().add(key, values);
  1040.     }
  1041.  
  1042.     /**
  1043.      * 
  1044.      * @param key
  1045.      * @param values
  1046.      * @return
  1047.      */
  1048.     public Long zRemove(String key, Object... values) {
  1049.         return redisTemplate.opsForZSet().remove(key, values);
  1050.     }
  1051.  
  1052.     /**
  1053.      * 增加元素的score值，并返回增加后的值
  1054.      * 
  1055.      * @param key
  1056.      * @param value
  1057.      * @param delta
  1058.      * @return
  1059.      */
  1060.     public Double zIncrementScore(String key, String value, double delta) {
  1061.         return redisTemplate.opsForZSet().incrementScore(key, value, delta);
  1062.     }
  1063.  
  1064.     /**
  1065.      * 返回元素在集合的排名,有序集合是按照元素的score值由小到大排列
  1066.      * 
  1067.      * @param key
  1068.      * @param value
  1069.      * @return 0表示第一位
  1070.      */
  1071.     public Long zRank(String key, Object value) {
  1072.         return redisTemplate.opsForZSet().rank(key, value);
  1073.     }
  1074.  
  1075.     /**
  1076.      * 返回元素在集合的排名,按元素的score值由大到小排列
  1077.      * 
  1078.      * @param key
  1079.      * @param value
  1080.      * @return
  1081.      */
  1082.     public Long zReverseRank(String key, Object value) {
  1083.         return redisTemplate.opsForZSet().reverseRank(key, value);
  1084.     }
  1085.  
  1086.     /**
  1087.      * 获取集合的元素, 从小到大排序
  1088.      * 
  1089.      * @param key
  1090.      * @param start
  1091.      *            开始位置
  1092.      * @param end
  1093.      *            结束位置, -1查询所有
  1094.      * @return
  1095.      */
  1096.     public Set<String> zRange(String key, long start, long end) {
  1097.         return redisTemplate.opsForZSet().range(key, start, end);
  1098.     }
  1099.  
  1100.     /**
  1101.      * 获取集合元素, 并且把score值也获取
  1102.      * 
  1103.      * @param key
  1104.      * @param start
  1105.      * @param end
  1106.      * @return
  1107.      */
  1108.     public Set<TypedTuple<String>> zRangeWithScores(String key, long start,
  1109.             long end) {
  1110.         return redisTemplate.opsForZSet().rangeWithScores(key, start, end);
  1111.     }
  1112.  
  1113.     /**
  1114.      * 根据Score值查询集合元素
  1115.      * 
  1116.      * @param key
  1117.      * @param min
  1118.      *            最小值
  1119.      * @param max
  1120.      *            最大值
  1121.      * @return
  1122.      */
  1123.     public Set<String> zRangeByScore(String key, double min, double max) {
  1124.         return redisTemplate.opsForZSet().rangeByScore(key, min, max);
  1125.     }
  1126.  
  1127.     /**
  1128.      * 根据Score值查询集合元素, 从小到大排序
  1129.      * 
  1130.      * @param key
  1131.      * @param min
  1132.      *            最小值
  1133.      * @param max
  1134.      *            最大值
  1135.      * @return
  1136.      */
  1137.     public Set<TypedTuple<String>> zRangeByScoreWithScores(String key,
  1138.             double min, double max) {
  1139.         return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);
  1140.     }
  1141.  
  1142.     /**
  1143.      * 
  1144.      * @param key
  1145.      * @param min
  1146.      * @param max
  1147.      * @param start
  1148.      * @param end
  1149.      * @return
  1150.      */
  1151.     public Set<TypedTuple<String>> zRangeByScoreWithScores(String key,
  1152.             double min, double max, long start, long end) {
  1153.         return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max,
  1154.                 start, end);
  1155.     }
  1156.  
  1157.     /**
  1158.      * 获取集合的元素, 从大到小排序
  1159.      * 
  1160.      * @param key
  1161.      * @param start
  1162.      * @param end
  1163.      * @return
  1164.      */
  1165.     public Set<String> zReverseRange(String key, long start, long end) {
  1166.         return redisTemplate.opsForZSet().reverseRange(key, start, end);
  1167.     }
  1168.  
  1169.     /**
  1170.      * 获取集合的元素, 从大到小排序, 并返回score值
  1171.      * 
  1172.      * @param key
  1173.      * @param start
  1174.      * @param end
  1175.      * @return
  1176.      */
  1177.     public Set<TypedTuple<String>> zReverseRangeWithScores(String key,
  1178.             long start, long end) {
  1179.         return redisTemplate.opsForZSet().reverseRangeWithScores(key, start,
  1180.                 end);
  1181.     }
  1182.  
  1183.     /**
  1184.      * 根据Score值查询集合元素, 从大到小排序
  1185.      * 
  1186.      * @param key
  1187.      * @param min
  1188.      * @param max
  1189.      * @return
  1190.      */
  1191.     public Set<String> zReverseRangeByScore(String key, double min,
  1192.             double max) {
  1193.         return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max);
  1194.     }
  1195.  
  1196.     /**
  1197.      * 根据Score值查询集合元素, 从大到小排序
  1198.      * 
  1199.      * @param key
  1200.      * @param min
  1201.      * @param max
  1202.      * @return
  1203.      */
  1204.     public Set<TypedTuple<String>> zReverseRangeByScoreWithScores(
  1205.             String key, double min, double max) {
  1206.         return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key,
  1207.                 min, max);
  1208.     }
  1209.  
  1210.     /**
  1211.      * 
  1212.      * @param key
  1213.      * @param min
  1214.      * @param max
  1215.      * @param start
  1216.      * @param end
  1217.      * @return
  1218.      */
  1219.     public Set<String> zReverseRangeByScore(String key, double min,
  1220.             double max, long start, long end) {
  1221.         return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max,
  1222.                 start, end);
  1223.     }
  1224.  
  1225.     /**
  1226.      * 根据score值获取集合元素数量
  1227.      * 
  1228.      * @param key
  1229.      * @param min
  1230.      * @param max
  1231.      * @return
  1232.      */
  1233.     public Long zCount(String key, double min, double max) {
  1234.         return redisTemplate.opsForZSet().count(key, min, max);
  1235.     }
  1236.  
  1237.     /**
  1238.      * 获取集合大小
  1239.      * 
  1240.      * @param key
  1241.      * @return
  1242.      */
  1243.     public Long zSize(String key) {
  1244.         return redisTemplate.opsForZSet().size(key);
  1245.     }
  1246.  
  1247.     /**
  1248.      * 获取集合大小
  1249.      * 
  1250.      * @param key
  1251.      * @return
  1252.      */
  1253.     public Long zZCard(String key) {
  1254.         return redisTemplate.opsForZSet().zCard(key);
  1255.     }
  1256.  
  1257.     /**
  1258.      * 获取集合中value元素的score值
  1259.      * 
  1260.      * @param key
  1261.      * @param value
  1262.      * @return
  1263.      */
  1264.     public Double zScore(String key, Object value) {
  1265.         return redisTemplate.opsForZSet().score(key, value);
  1266.     }
  1267.  
  1268.     /**
  1269.      * 移除指定索引位置的成员
  1270.      * 
  1271.      * @param key
  1272.      * @param start
  1273.      * @param end
  1274.      * @return
  1275.      */
  1276.     public Long zRemoveRange(String key, long start, long end) {
  1277.         return redisTemplate.opsForZSet().removeRange(key, start, end);
  1278.     }
  1279.  
  1280.     /**
  1281.      * 根据指定的score值的范围来移除成员
  1282.      * 
  1283.      * @param key
  1284.      * @param min
  1285.      * @param max
  1286.      * @return
  1287.      */
  1288.     public Long zRemoveRangeByScore(String key, double min, double max) {
  1289.         return redisTemplate.opsForZSet().removeRangeByScore(key, min, max);
  1290.     }
  1291.  
  1292.     /**
  1293.      * 获取key和otherKey的并集并存储在destKey中
  1294.      * 
  1295.      * @param key
  1296.      * @param otherKey
  1297.      * @param destKey
  1298.      * @return
  1299.      */
  1300.     public Long zUnionAndStore(String key, String otherKey, String destKey) {
  1301.         return redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey);
  1302.     }
  1303.  
  1304.     /**
  1305.      * 
  1306.      * @param key
  1307.      * @param otherKeys
  1308.      * @param destKey
  1309.      * @return
  1310.      */
  1311.     public Long zUnionAndStore(String key, Collection<String> otherKeys,
  1312.             String destKey) {
  1313.         return redisTemplate.opsForZSet()
  1314.                 .unionAndStore(key, otherKeys, destKey);
  1315.     }
  1316.  
  1317.     /**
  1318.      * 交集
  1319.      * 
  1320.      * @param key
  1321.      * @param otherKey
  1322.      * @param destKey
  1323.      * @return
  1324.      */
  1325.     public Long zIntersectAndStore(String key, String otherKey,
  1326.             String destKey) {
  1327.         return redisTemplate.opsForZSet().intersectAndStore(key, otherKey,
  1328.                 destKey);
  1329.     }
  1330.  
  1331.     /**
  1332.      * 交集
  1333.      * 
  1334.      * @param key
  1335.      * @param otherKeys
  1336.      * @param destKey
  1337.      * @return
  1338.      */
  1339.     public Long zIntersectAndStore(String key, Collection<String> otherKeys,
  1340.             String destKey) {
  1341.         return redisTemplate.opsForZSet().intersectAndStore(key, otherKeys,
  1342.                 destKey);
  1343.     }
  1344.  
  1345.     /**
  1346.      * 
  1347.      * @param key
  1348.      * @param options
  1349.      * @return
  1350.      */
  1351.     public Cursor<TypedTuple<String>> zScan(String key, ScanOptions options) {
  1352.         return redisTemplate.opsForZSet().scan(key, options);
  1353.     }
  1354. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/240472
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号