Chinaunix首页 | 论坛 | 博客

fhadmin的ChinaUnix博客

首页　| 　博文目录　| 　关于我

fhadmin

  • 博客访问： 605019
  • 博文数量： 298
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 3077
  • 用 户 组： 普通用户
  • 注册时间： 2019-06-17 10:57
文章分类

全部博文（298）

文章存档

2022年（96）

2021年（201）

2019年（1）

我的朋友
最近访客
推荐博文
相关博文
java Redis工具类

分类： Java

2022-01-06 12:22:10


点击(此处)折叠或打开


  2. package org.fh.util;

  4. import java.util.List;
  5. import java.util.Map;
  6. import java.util.Set;
  7. import java.util.concurrent.TimeUnit;
  8. import org.springframework.data.redis.core.RedisTemplate;
  9. import org.springframework.stereotype.Component;

  11. /**
  12.  * 说明：Redis工具类
  13.  * 作者：FH Admin
  14.  * from.fhadmin.cn
  15.  */
  16. @Component
  17. public final class RedisUtil {

  19.     private RedisTemplate<String, Object> redisTemplate;

  21.     public RedisUtil(RedisTemplate<String, Object> rt ) {
  22.         this. redisTemplate = rt;
  23.     }

  25.     /**
  26.      * 指定缓存失效时间
  27.      * @param key 键
  28.      * @param time 时间(秒)
  29.      * @return
  30.      */
  31.     public boolean expire(String key, long time) {
  32.         try {
  33.             if (time > 0) {
  34.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  35.             }
  36.             return true;
  37.         } catch (Exception e) {
  38.             e.printStackTrace();
  39.             return false;
  40.         }
  41.     }

  43.     /**
  44.      * 根据key 获取过期时间
  45.      * @param key 键 不能为null
  46.      * @return 时间(秒) 返回0代表为永久有效
  47.      */
  48.     public long getExpire(String key) {
  49.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  50.     }

  52.     /**
  53.      * 判断key是否存在
  54.      * @param key 键
  55.      * @return true 存在 false不存在
  56.      */
  57.     public boolean hasKey(String key) {
  58.         try {
  59.             return redisTemplate.hasKey(key);
  60.         } catch (Exception e) {
  61.             //e.printStackTrace();
  62.             return false;
  63.         }
  64.     }

  66.     /**
  67.      * 删除缓存
  68.      * @param key
  69.      */
  70.     public void del(String key) {
  71.         if (key != null) {
  72.             redisTemplate.delete(key);
  73.         }
  74.     }

  76.     // ============================String=============================

  78.     /**
  79.      * 普通缓存获取
  80.      * @param key 键
  81.      * @return 值
  82.      */
  83.     public Object get(String key) {
  84.         return key == null ? null : redisTemplate.opsForValue().get(key);
  85.     }

  87.     /**
  88.      * 普通缓存放入
  89.      * @param key 键
  90.      * @param value 值
  91.      * @return true成功 false失败
  92.      */
  93.     public boolean set(String key, Object value) {
  94.         try {
  95.             redisTemplate.opsForValue().set(key, value);
  96.             return true;
  97.         } catch (Exception e) {
  98.             //e.printStackTrace();
  99.             return false;
  100.         }
  101.     }

  103.     /**
  104.      * 普通缓存放入并设置时间
  105.      * @param key 键
  106.      * @param value 值
  107.      * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
  108.      * @return true成功 false 失败
  109.      */

  111.     public boolean set(String key, Object value, long time) {
  112.         try {
  113.             if (time > 0) {
  114.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  115.             } else {
  116.                 set(key, value);
  117.             }
  118.             return true;
  119.         } catch (Exception e) {
  120.             e.printStackTrace();
  121.             return false;
  122.         }
  123.     }

  125.     /**
  126.      * 递增
  127.      * @param key 键
  128.      * @param delta 要增加几(大于0)
  129.      * @return
  130.      */

  132.     public long incr(String key, long delta) {
  133.         if (delta < 0) {
  134.             throw new RuntimeException("递增因子必须大于0");
  135.         }
  136.         return redisTemplate.opsForValue().increment(key, delta);
  137.     }

  139.     /**
  140.      * 递减
  141.      * @param key 键
  142.      * @param delta 要减少几(小于0)
  143.      * @return
  144.      */
  145.     public long decr(String key, long delta) {
  146.         if (delta < 0) {
  147.             throw new RuntimeException("递减因子必须大于0");
  148.         }
  149.         return redisTemplate.opsForValue().increment(key, -delta);
  150.     }

  152.     // ================================Map=================================

  154.     /**
  155.      * HashGet
  156.      * @param key 键 不能为null
  157.      * @param item 项 不能为null
  158.      * @return 值
  159.      */
  160.     public Object hget(String key, String item) {
  161.         return redisTemplate.opsForHash().get(key, item);
  162.     }

  164.     /**
  165.      * 获取hashKey对应的所有键值
  166.      * @param key 键
  167.      * @return 对应的多个键值
  168.      */
  169.     public Map<Object, Object> hmget(String key) {
  170.         return redisTemplate.opsForHash().entries(key);
  171.     }

  173.     /**
  174.      * HashSet
  175.      * @param key 键
  176.      * @param map 对应多个键值
  177.      * @return true 成功 false 失败
  178.      */
  179.     public boolean hmset(String key, Map<String, Object> map) {
  180.         try {
  181.             redisTemplate.opsForHash().putAll(key, map);
  182.             return true;
  183.         } catch (Exception e) {
  184.             e.printStackTrace();
  185.             return false;
  186.         }
  187.     }

  189.     /**
  190.      * HashSet 并设置时间
  191.      * @param key 键
  192.      * @param map 对应多个键值
  193.      * @param time 时间(秒)
  194.      * @return true成功 false失败
  195.      */
  196.     public boolean hmset(String key, Map<String, Object> map, long time) {
  197.         try {
  198.             redisTemplate.opsForHash().putAll(key, map);
  199.             if (time > 0) {
  200.                 expire(key, time);
  201.             }
  202.             return true;
  203.         } catch (Exception e) {
  204.             e.printStackTrace();
  205.             return false;
  206.         }
  207.     }

  209.     /**
  210.      * 向一张hash表中放入数据,如果不存在将创建
  211.      * @param key 键
  212.      * @param item 项
  213.      * @param value 值
  214.      * @return true 成功 false失败
  215.      */
  216.     public boolean hset(String key, String item, Object value) {
  217.         try {
  218.             redisTemplate.opsForHash().put(key, item, value);
  219.             return true;
  220.         } catch (Exception e) {
  221.             e.printStackTrace();
  222.             return false;
  223.         }
  224.     }

  226.     /**
  227.      * 向一张hash表中放入数据,如果不存在将创建
  228.      * @param key 键
  229.      * @param item 项
  230.      * @param value 值
  231.      * @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
  232.      * @return true 成功 false失败
  233.      */
  234.     public boolean hset(String key, String item, Object value, long time) {
  235.         try {
  236.             redisTemplate.opsForHash().put(key, item, value);
  237.             if (time > 0) {
  238.                 expire(key, time);
  239.             }
  240.             return true;
  241.         } catch (Exception e) {
  242.             e.printStackTrace();
  243.             return false;
  244.         }
  245.     }

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

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

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

  277.     /**
  278.      * hash递减
  279.      * @param key 键
  280.      * @param item 项
  281.      * @param by 要减少记(小于0)
  282.      * @return
  283.      */
  284.     public double hdecr(String key, String item, double by) {
  285.         return redisTemplate.opsForHash().increment(key, item, -by);
  286.     }

  288.     // ============================set=============================

  290.     /**
  291.      * 根据key获取Set中的所有值
  292.      * @param key 键
  293.      * @return
  294.      */
  295.     public Set<Object> sGet(String key) {
  296.         try {
  297.             return redisTemplate.opsForSet().members(key);
  298.         } catch (Exception e) {
  299.             e.printStackTrace();
  300.             return null;
  301.         }
  302.     }

  304.     /**
  305.      * 根据value从一个set中查询,是否存在
  306.      * @param key 键
  307.      * @param value 值
  308.      * @return true 存在 false不存在
  309.      */
  310.     public boolean sHasKey(String key, Object value) {
  311.         try {
  312.             return redisTemplate.opsForSet().isMember(key, value);
  313.         } catch (Exception e) {
  314.             e.printStackTrace();
  315.             return false;
  316.         }
  317.     }

  319.     /**
  320.      * 将数据放入set缓存
  321.      * @param key 键
  322.      * @param values 值 可以是多个
  323.      * @return 成功个数
  324.      */
  325.     public long sSet(String key, Object... values) {
  326.         try {
  327.             return redisTemplate.opsForSet().add(key, values);
  328.         } catch (Exception e) {
  329.             e.printStackTrace();
  330.             return 0;
  331.         }
  332.     }

  334.     /**
  335.      * 将set数据放入缓存
  336.      * @param key 键
  337.      * @param time 时间(秒)
  338.      * @param values 值 可以是多个
  339.      * @return 成功个数
  340.      */
  341.     public long sSetAndTime(String key, long time, Object... values) {
  342.         try {
  343.             Long count = redisTemplate.opsForSet().add(key, values);
  344.             if (time > 0)
  345.                 expire(key, time);
  346.             return count;
  347.         } catch (Exception e) {
  348.             e.printStackTrace();
  349.             return 0;
  350.         }
  351.     }

  353.     /**
  354.      * 获取set缓存的长度
  355.      * @param key 键
  356.      * @return
  357.      */
  358.     public long sGetSetSize(String key) {
  359.         try {
  360.             return redisTemplate.opsForSet().size(key);
  361.         } catch (Exception e) {
  362.             e.printStackTrace();
  363.             return 0;
  364.         }
  365.     }

  367.     /**
  368.      * 移除值为value的
  369.      * @param key 键
  370.      * @param values 值 可以是多个
  371.      * @return 移除的个数
  372.      */
  373.     public long setRemove(String key, Object... values) {
  374.         try {
  375.             Long count = redisTemplate.opsForSet().remove(key, values);
  376.             return count;
  377.         } catch (Exception e) {
  378.             e.printStackTrace();
  379.             return 0;
  380.         }
  381.     }

  383.     // ===============================list=================================

  385.     /**
  386.      * 获取list缓存的内容
  387.      * @param key 键
  388.      * @param start 开始
  389.      * @param end 结束 0 到 -1代表所有值
  390.      * @return
  391.      */
  392.     public List<Object> lGet(String key, long start, long end) {
  393.         try {
  394.             return redisTemplate.opsForList().range(key, start, end);
  395.         } catch (Exception e) {
  396.             e.printStackTrace();
  397.             return null;
  398.         }
  399.     }

  401.     /**
  402.      * 获取list缓存的长度
  403.      * @param key 键
  404.      * @return
  405.      */
  406.     public long lGetListSize(String key) {
  407.         try {
  408.             return redisTemplate.opsForList().size(key);
  409.         } catch (Exception e) {
  410.             e.printStackTrace();
  411.             return 0;
  412.         }
  413.     }

  415.     /**
  416.      * 通过索引 获取list中的值
  417.      * @param key 键
  418.      * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
  419.      * @return
  420.      */
  421.     public Object lGetIndex(String key, long index) {
  422.         try {
  423.             return redisTemplate.opsForList().index(key, index);
  424.         } catch (Exception e) {
  425.             e.printStackTrace();
  426.             return null;
  427.         }
  428.     }

  430.     /**
  431.      * 将list放入缓存
  432.      * @param key 键
  433.      * @param value 值
  434.      * @param time 时间(秒)
  435.      * @return
  436.      */
  437.     public boolean lSet(String key, Object value) {
  438.         try {
  439.             redisTemplate.opsForList().rightPush(key, value);
  440.             return true;
  441.         } catch (Exception e) {
  442.             e.printStackTrace();
  443.             return false;
  444.         }
  445.     }

  447.     /**
  448.      * 将list放入缓存
  449.      * @param key 键
  450.      * @param value 值
  451.      * @param time 时间(秒)
  452.      * @return
  453.      */
  454.     public boolean lSet(String key, Object value, long time) {
  455.         try {
  456.             redisTemplate.opsForList().rightPush(key, value);
  457.             if (time > 0)
  458.                 expire(key, time);
  459.             return true;
  460.         } catch (Exception e) {
  461.             e.printStackTrace();
  462.             return false;
  463.         }
  464.     }

  466.     /**
  467.      * 将list放入缓存
  468.      * @param key 键
  469.      * @param value 值
  470.      * @param time 时间(秒)
  471.      * @return
  472.      */
  473.     public boolean lSet(String key, List<Object> value) {
  474.         try {
  475.             redisTemplate.opsForList().rightPushAll(key, value);
  476.             return true;
  477.         } catch (Exception e) {
  478.             e.printStackTrace();
  479.             return false;
  480.         }
  481.     }

  483.     /**
  484.      * 将list放入缓存
  485.      * @param key 键
  486.      * @param value 值
  487.      * @param time 时间(秒)
  488.      * @return
  489.      */
  490.     public boolean lSet(String key, List<Object> value, long time) {
  491.         try {
  492.             redisTemplate.opsForList().rightPushAll(key, value);
  493.             if (time > 0)
  494.                 expire(key, time);
  495.             return true;
  496.         } catch (Exception e) {
  497.             e.printStackTrace();
  498.             return false;
  499.         }
  500.     }

  502.     /**
  503.      * 根据索引修改list中的某条数据
  504.      * @param key 键
  505.      * @param index 索引
  506.      * @param value 值
  507.      * @return
  508.      */
  509.     public boolean lUpdateIndex(String key, long index, Object value) {
  510.         try {
  511.             redisTemplate.opsForList().set(key, index, value);
  512.             return true;
  513.         } catch (Exception e) {
  514.             e.printStackTrace();
  515.             return false;
  516.         }
  517.     }

  519.     /**
  520.      * 移除N个值为value
  521.      * @param key 键
  522.      * @param count 移除多少个
  523.      * @param value 值
  524.      * @return 移除的个数
  525.      */
  526.     public long lRemove(String key, long count, Object value) {
  527.         try {
  528.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  529.             return remove;
  530.         } catch (Exception e) {
  531.             e.printStackTrace();
  532.             return 0;
  533.         }
  534.     }

  536. }


阅读(539) | 评论(0) | 转发(0) |
0

上一篇：java 百度手写文字识别接口配置

下一篇：java Freemarker 模版引擎工具类

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6