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

使用redis实现手机短信验证功能_redis验证码验证设计

作者：小丑西瓜9 | 2024-04-30 03:14:16

赞

踩

redis验证码验证设计

使用redis实现以下功能
1：手机短信验证，每条验证码有效期为1分钟，
2：1分钟内如果该手机号再次获取验证码，则提示短信已发送，请XX分钟后(剩余过期时间)重新获取3：每个手机号每天最多只能发送3次，24小时后可发送次数重置

1.定义一个PhoneController类

  1. package com.redis.controller;
  2.  
  3. import com.redis.service.PhoneService;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.web.bind.annotation.RequestMapping;
  6. import org.springframework.web.bind.annotation.RestController;
  7.  
  8. @RestController
  9. @RequestMapping("/phone")
  10. public class PhoneController {
  11.     @Autowired
  12.     private PhoneService phoneService;
  13.     //发送验证码
  14.     @RequestMapping("/send")
  15.     public Object send(String phone){
  16.         return phoneService.send(phone);
  17.     }
  18.     //校验验证码
  19.     @RequestMapping("/check")
  20.     public Object check(String phone,String code){
  21.         return phoneService.check(phone,code);
  22.     }
  23. }

2.定义一个PhoneService来做逻辑处理

  1. package com.redis.service;
  2.  
  3. import cn.hutool.core.util.RandomUtil;
  4. import org.springframework.data.redis.core.StringRedisTemplate;
  5. import org.springframework.stereotype.Service;
  6.  
  7. import javax.annotation.Resource;
  8. import java.util.concurrent.TimeUnit;
  9.  
  10. @Service
  11. public class PhoneService {
  12.     //定义一个StringRedisTemplate，方便调用而且不需要再自己定义序列化的代码
  13.     @Resource
  14.     private StringRedisTemplate stringRedisTemplate;
  15.     public Object send(String phone) {
  16.         //用手机号拼接上字符串来作为key值，这是作为发送的次数
  17.         String countKey = phone + "_COUNT";
  18.         //用手机号拼接上字符串来作为key值，来表示你的验证码
  19.         String codeKey = phone + "_CODE";
  20.         try {
  21.             //根据countKey来获取发送的次数
  22.             String countStr = stringRedisTemplate.opsForValue().get(countKey);
  23.             Integer count;
  24.             try {
  25.                 //将String类型的次数来强转为Integer
  26.                 count = Integer.valueOf(countStr);
  27.             }catch (NumberFormatException e){
  28.                 count = 0;
  29.             }
  30.             if(count > 2){
  31.                 System.out.println("24小时内短信发送次数已达3次，不能继续发送！24小时后重置次数");
  32.                 //做判断来表示发送三次，再次发送失败
  33.                 return false;
  34.             }
  35.             //判断codeKey是否存在
  36.             boolean isTtl = stringRedisTemplate.hasKey(codeKey);
  37.             if(isTtl){
  38.                 //如果存在的获取还有多少秒过期
  39.                 long ttlCode = stringRedisTemplate.getExpire(codeKey);
  40.                 System.out.println("验证码在1分钟内保持有效，请于"+ttlCode+"秒之后再次发送");
  41.                 return false;
  42.             }
  43.             //获取6位数的随机数
  44.             //这个地方如果换成手机短信的api接口的话就可以实现手机短信验证的功能
  45.             String code = RandomUtil.randomNumbers(6);
  46.             //保存在随机数中设置过期时间
  47.             stringRedisTemplate.opsForValue().set(codeKey,code,1, TimeUnit.MINUTES);
  48.             //设置过期时间为1天
  49.             long timeOut = 24 * 60 * 60;
  50.             //做一个判断如果不是第一次发送，就要根据countKey来获取他的剩余的过期时间
  51.             if(count!=0){
  52.                 //如果这个地方是短信验证的功能的话就是可以换成根据countKey来获取它是否存在来判断是否验证码过期
  53.                 timeOut = stringRedisTemplate.getExpire(countKey);
  54.             }
  55.             stringRedisTemplate.opsForValue().set(countKey,String.valueOf(count+1),timeOut,TimeUnit.SECONDS);
  56.             System.out.println("短信验证码发送完毕！请注意查收!");
  57.             return true;
  58.         }catch (Exception e){
  59.             stringRedisTemplate.delete(codeKey);
  60.             stringRedisTemplate.delete(countKey);
  61.             return false;
  62.         }
  63.     }
  64.  
  65.     public Object check(String phone, String code) {
  66.         String redisCode = stringRedisTemplate.opsForValue().get(phone + "_CODE");
  67.         return code.equals(redisCode);
  68.     }
  69.  
  70. }

3.在本功能中需要用到的redis工具类

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

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

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

  

闽ICP备14008679号