Chinaunix首页 | 论坛 | 博客
  • 博客访问: 320272
  • 博文数量: 287
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 2985
  • 用 户 组: 普通用户
  • 注册时间: 2019-06-17 10:57
文章分类

全部博文(287)

文章存档

2022年(85)

2021年(201)

2019年(1)

我的朋友

分类: Java

2022-01-06 12:22:10


点击(此处)折叠或打开


  1. package org.fh.util;

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

  8. /**
  9.  * 说明:Redis工具类
  10.  * 作者:FH Admin
  11.  * from.fhadmin.cn
  12.  */
  13. @Component
  14. public final class RedisUtil {

  15.     private RedisTemplate<String, Object> redisTemplate;

  16.     public RedisUtil(RedisTemplate<String, Object> rt ) {
  17.         this. redisTemplate = rt;
  18.     }

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

  36.     /**
  37.      * 根据key 获取过期时间
  38.      * @param key 键 不能为null
  39.      * @return 时间() 返回0代表为永久有效
  40.      */
  41.     public long getExpire(String key) {
  42.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
  43.     }

  44.     /**
  45.      * 判断key是否存在
  46.      * @param key 键
  47.      * @return true 存在 false不存在
  48.      */
  49.     public boolean hasKey(String key) {
  50.         try {
  51.             return redisTemplate.hasKey(key);
  52.         } catch (Exception e) {
  53.             //e.printStackTrace();
  54.             return false;
  55.         }
  56.     }

  57.     /**
  58.      * 删除缓存
  59.      * @param key
  60.      */
  61.     public void del(String key) {
  62.         if (key != null) {
  63.             redisTemplate.delete(key);
  64.         }
  65.     }

  66.     // ============================String=============================

  67.     /**
  68.      * 普通缓存获取
  69.      * @param key 键
  70.      * @return 值
  71.      */
  72.     public Object get(String key) {
  73.         return key == null ? null : redisTemplate.opsForValue().get(key);
  74.     }

  75.     /**
  76.      * 普通缓存放入
  77.      * @param key 键
  78.      * @param value 值
  79.      * @return true成功 false失败
  80.      */
  81.     public boolean set(String key, Object value) {
  82.         try {
  83.             redisTemplate.opsForValue().set(key, value);
  84.             return true;
  85.         } catch (Exception e) {
  86.             //e.printStackTrace();
  87.             return false;
  88.         }
  89.     }

  90.     /**
  91.      * 普通缓存放入并设置时间
  92.      * @param key 键
  93.      * @param value 值
  94.      * @param time 时间() time要大于0 如果time小于等于0 将设置无限期
  95.      * @return true成功 false 失败
  96.      */

  97.     public boolean set(String key, Object value, long time) {
  98.         try {
  99.             if (time > 0) {
  100.                 redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
  101.             } else {
  102.                 set(key, value);
  103.             }
  104.             return true;
  105.         } catch (Exception e) {
  106.             e.printStackTrace();
  107.             return false;
  108.         }
  109.     }

  110.     /**
  111.      * 递增
  112.      * @param key 键
  113.      * @param delta 要增加几(大于0)
  114.      * @return
  115.      */

  116.     public long incr(String key, long delta) {
  117.         if (delta < 0) {
  118.             throw new RuntimeException("递增因子必须大于0");
  119.         }
  120.         return redisTemplate.opsForValue().increment(key, delta);
  121.     }

  122.     /**
  123.      * 递减
  124.      * @param key 键
  125.      * @param delta 要减少几(小于0)
  126.      * @return
  127.      */
  128.     public long decr(String key, long delta) {
  129.         if (delta < 0) {
  130.             throw new RuntimeException("递减因子必须大于0");
  131.         }
  132.         return redisTemplate.opsForValue().increment(key, -delta);
  133.     }

  134.     // ================================Map=================================

  135.     /**
  136.      * HashGet
  137.      * @param key 键 不能为null
  138.      * @param item 项 不能为null
  139.      * @return 值
  140.      */
  141.     public Object hget(String key, String item) {
  142.         return redisTemplate.opsForHash().get(key, item);
  143.     }

  144.     /**
  145.      * 获取hashKey对应的所有键值
  146.      * @param key 键
  147.      * @return 对应的多个键值
  148.      */
  149.     public Map<Object, Object> hmget(String key) {
  150.         return redisTemplate.opsForHash().entries(key);
  151.     }

  152.     /**
  153.      * HashSet
  154.      * @param key 键
  155.      * @param map 对应多个键值
  156.      * @return true 成功 false 失败
  157.      */
  158.     public boolean hmset(String key, Map<String, Object> map) {
  159.         try {
  160.             redisTemplate.opsForHash().putAll(key, map);
  161.             return true;
  162.         } catch (Exception e) {
  163.             e.printStackTrace();
  164.             return false;
  165.         }
  166.     }

  167.     /**
  168.      * HashSet 并设置时间
  169.      * @param key 键
  170.      * @param map 对应多个键值
  171.      * @param time 时间()
  172.      * @return true成功 false失败
  173.      */
  174.     public boolean hmset(String key, Map<String, Object> map, long time) {
  175.         try {
  176.             redisTemplate.opsForHash().putAll(key, map);
  177.             if (time > 0) {
  178.                 expire(key, time);
  179.             }
  180.             return true;
  181.         } catch (Exception e) {
  182.             e.printStackTrace();
  183.             return false;
  184.         }
  185.     }

  186.     /**
  187.      * 向一张hash表中放入数据,如果不存在将创建
  188.      * @param key 键
  189.      * @param item 项
  190.      * @param value 值
  191.      * @return true 成功 false失败
  192.      */
  193.     public boolean hset(String key, String item, Object value) {
  194.         try {
  195.             redisTemplate.opsForHash().put(key, item, value);
  196.             return true;
  197.         } catch (Exception e) {
  198.             e.printStackTrace();
  199.             return false;
  200.         }
  201.     }

  202.     /**
  203.      * 向一张hash表中放入数据,如果不存在将创建
  204.      * @param key 键
  205.      * @param item 项
  206.      * @param value 值
  207.      * @param time 时间() 注意:如果已存在的hash表有时间,这里将会替换原有的时间
  208.      * @return true 成功 false失败
  209.      */
  210.     public boolean hset(String key, String item, Object value, long time) {
  211.         try {
  212.             redisTemplate.opsForHash().put(key, item, value);
  213.             if (time > 0) {
  214.                 expire(key, time);
  215.             }
  216.             return true;
  217.         } catch (Exception e) {
  218.             e.printStackTrace();
  219.             return false;
  220.         }
  221.     }

  222.     /**
  223.      * 删除hash表中的值
  224.      * @param key 键 不能为null
  225.      * @param item 项 可以使多个 不能为null
  226.      */
  227.     public void hdel(String key, Object... item) {
  228.         redisTemplate.opsForHash().delete(key, item);
  229.     }

  230.     /**
  231.      * 判断hash表中是否有该项的值
  232.      * @param key 键 不能为null
  233.      * @param item 项 不能为null
  234.      * @return true 存在 false不存在
  235.      */
  236.     public boolean hHasKey(String key, String item) {
  237.         return redisTemplate.opsForHash().hasKey(key, item);
  238.     }

  239.     /**
  240.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
  241.      * @param key 键
  242.      * @param item 项
  243.      * @param by 要增加几(大于0)
  244.      * @return
  245.      */
  246.     public double hincr(String key, String item, double by) {
  247.         return redisTemplate.opsForHash().increment(key, item, by);
  248.     }

  249.     /**
  250.      * hash递减
  251.      * @param key 键
  252.      * @param item 项
  253.      * @param by 要减少记(小于0)
  254.      * @return
  255.      */
  256.     public double hdecr(String key, String item, double by) {
  257.         return redisTemplate.opsForHash().increment(key, item, -by);
  258.     }

  259.     // ============================set=============================

  260.     /**
  261.      * 根据key获取Set中的所有值
  262.      * @param key 键
  263.      * @return
  264.      */
  265.     public Set<Object> sGet(String key) {
  266.         try {
  267.             return redisTemplate.opsForSet().members(key);
  268.         } catch (Exception e) {
  269.             e.printStackTrace();
  270.             return null;
  271.         }
  272.     }

  273.     /**
  274.      * 根据value从一个set中查询,是否存在
  275.      * @param key 键
  276.      * @param value 值
  277.      * @return true 存在 false不存在
  278.      */
  279.     public boolean sHasKey(String key, Object value) {
  280.         try {
  281.             return redisTemplate.opsForSet().isMember(key, value);
  282.         } catch (Exception e) {
  283.             e.printStackTrace();
  284.             return false;
  285.         }
  286.     }

  287.     /**
  288.      * 将数据放入set缓存
  289.      * @param key 键
  290.      * @param values 值 可以是多个
  291.      * @return 成功个数
  292.      */
  293.     public long sSet(String key, Object... values) {
  294.         try {
  295.             return redisTemplate.opsForSet().add(key, values);
  296.         } catch (Exception e) {
  297.             e.printStackTrace();
  298.             return 0;
  299.         }
  300.     }

  301.     /**
  302.      * 将set数据放入缓存
  303.      * @param key 键
  304.      * @param time 时间()
  305.      * @param values 值 可以是多个
  306.      * @return 成功个数
  307.      */
  308.     public long sSetAndTime(String key, long time, Object... values) {
  309.         try {
  310.             Long count = redisTemplate.opsForSet().add(key, values);
  311.             if (time > 0)
  312.                 expire(key, time);
  313.             return count;
  314.         } catch (Exception e) {
  315.             e.printStackTrace();
  316.             return 0;
  317.         }
  318.     }

  319.     /**
  320.      * 获取set缓存的长度
  321.      * @param key 键
  322.      * @return
  323.      */
  324.     public long sGetSetSize(String key) {
  325.         try {
  326.             return redisTemplate.opsForSet().size(key);
  327.         } catch (Exception e) {
  328.             e.printStackTrace();
  329.             return 0;
  330.         }
  331.     }

  332.     /**
  333.      * 移除值为value的
  334.      * @param key 键
  335.      * @param values 值 可以是多个
  336.      * @return 移除的个数
  337.      */
  338.     public long setRemove(String key, Object... values) {
  339.         try {
  340.             Long count = redisTemplate.opsForSet().remove(key, values);
  341.             return count;
  342.         } catch (Exception e) {
  343.             e.printStackTrace();
  344.             return 0;
  345.         }
  346.     }

  347.     // ===============================list=================================

  348.     /**
  349.      * 获取list缓存的内容
  350.      * @param key 键
  351.      * @param start 开始
  352.      * @param end 结束 0 到 -1代表所有值
  353.      * @return
  354.      */
  355.     public List<Object> lGet(String key, long start, long end) {
  356.         try {
  357.             return redisTemplate.opsForList().range(key, start, end);
  358.         } catch (Exception e) {
  359.             e.printStackTrace();
  360.             return null;
  361.         }
  362.     }

  363.     /**
  364.      * 获取list缓存的长度
  365.      * @param key 键
  366.      * @return
  367.      */
  368.     public long lGetListSize(String key) {
  369.         try {
  370.             return redisTemplate.opsForList().size(key);
  371.         } catch (Exception e) {
  372.             e.printStackTrace();
  373.             return 0;
  374.         }
  375.     }

  376.     /**
  377.      * 通过索引 获取list中的值
  378.      * @param key 键
  379.      * @param index 索引 index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
  380.      * @return
  381.      */
  382.     public Object lGetIndex(String key, long index) {
  383.         try {
  384.             return redisTemplate.opsForList().index(key, index);
  385.         } catch (Exception e) {
  386.             e.printStackTrace();
  387.             return null;
  388.         }
  389.     }

  390.     /**
  391.      * 将list放入缓存
  392.      * @param key 键
  393.      * @param value 值
  394.      * @param time 时间()
  395.      * @return
  396.      */
  397.     public boolean lSet(String key, Object value) {
  398.         try {
  399.             redisTemplate.opsForList().rightPush(key, value);
  400.             return true;
  401.         } catch (Exception e) {
  402.             e.printStackTrace();
  403.             return false;
  404.         }
  405.     }

  406.     /**
  407.      * 将list放入缓存
  408.      * @param key 键
  409.      * @param value 值
  410.      * @param time 时间()
  411.      * @return
  412.      */
  413.     public boolean lSet(String key, Object value, long time) {
  414.         try {
  415.             redisTemplate.opsForList().rightPush(key, value);
  416.             if (time > 0)
  417.                 expire(key, time);
  418.             return true;
  419.         } catch (Exception e) {
  420.             e.printStackTrace();
  421.             return false;
  422.         }
  423.     }

  424.     /**
  425.      * 将list放入缓存
  426.      * @param key 键
  427.      * @param value 值
  428.      * @param time 时间()
  429.      * @return
  430.      */
  431.     public boolean lSet(String key, List<Object> value) {
  432.         try {
  433.             redisTemplate.opsForList().rightPushAll(key, value);
  434.             return true;
  435.         } catch (Exception e) {
  436.             e.printStackTrace();
  437.             return false;
  438.         }
  439.     }

  440.     /**
  441.      * 将list放入缓存
  442.      * @param key 键
  443.      * @param value 值
  444.      * @param time 时间()
  445.      * @return
  446.      */
  447.     public boolean lSet(String key, List<Object> value, long time) {
  448.         try {
  449.             redisTemplate.opsForList().rightPushAll(key, value);
  450.             if (time > 0)
  451.                 expire(key, time);
  452.             return true;
  453.         } catch (Exception e) {
  454.             e.printStackTrace();
  455.             return false;
  456.         }
  457.     }

  458.     /**
  459.      * 根据索引修改list中的某条数据
  460.      * @param key 键
  461.      * @param index 索引
  462.      * @param value 值
  463.      * @return
  464.      */
  465.     public boolean lUpdateIndex(String key, long index, Object value) {
  466.         try {
  467.             redisTemplate.opsForList().set(key, index, value);
  468.             return true;
  469.         } catch (Exception e) {
  470.             e.printStackTrace();
  471.             return false;
  472.         }
  473.     }

  474.     /**
  475.      * 移除N个值为value
  476.      * @param key 键
  477.      * @param count 移除多少个
  478.      * @param value 值
  479.      * @return 移除的个数
  480.      */
  481.     public long lRemove(String key, long count, Object value) {
  482.         try {
  483.             Long remove = redisTemplate.opsForList().remove(key, count, value);
  484.             return remove;
  485.         } catch (Exception e) {
  486.             e.printStackTrace();
  487.             return 0;
  488.         }
  489.     }

  490. }


阅读(167) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~