Springboot整合异步定时任务

我不是女神ヾ 2022-04-12 04:17 481阅读 0赞

一、开启异步与定时任务

  1. import org.mybatis.spring.annotation.MapperScan;
  2. import org.springframework.boot.SpringApplication;
  3. import org.springframework.boot.autoconfigure.SpringBootApplication;
  4. import org.springframework.boot.context.properties.EnableConfigurationProperties;
  5. import org.springframework.scheduling.annotation.EnableAsync;
  6. import org.springframework.scheduling.annotation.EnableScheduling;
  8. /**
  9.  * 启动控制类
  10.  * 开启缓存
  11.  * @author nick
  12.  */
  13. @SpringBootApplication
  14. @EnableConfigurationProperties
  15. @EnableAsync  //开启异步注解功能
  16. @EnableScheduling //开启基于注解的定时任务
  17. public class Application {
  18.     public static void main(String[] args) {
  19.         SpringApplication.run(Application.class, args);
  20.     }
  21. }

二、在@Service层进行异步与定时操作

  1. import org.springframework.scheduling.annotation.Async;
  2. import org.springframework.scheduling.annotation.Scheduled;
  3. import org.springframework.stereotype.Service;
  5. @Service
  6. public class ExportExcelService {
  7.     /**
  8.      * Spring这是一个异步方法
  9.      */
  10.     @Async
  11.     @Scheduled(cron = "0/4 * * * * MON-SAT")  //每4秒执行一次
  12.     public void hello(){
  13.         System.out.println("处理数据中...");
  14.         System.err.println("========="+System.currentTimeMillis());
  16.     }
  17. }

三、推荐一个redisUtils工具类很全

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

《参考:https://github.com/whvcse/RedisUtil》

发表评论

表情：
评论列表 （有 0 条评论，481人围观）

还没有评论，来说两句吧...

相关阅读