1. package com.zara.utils.redis;
    3. import org.apache.shiro.util.CollectionUtils;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.data.redis.core.RedisTemplate;
    6. import org.springframework.stereotype.Component;
    8. import java.util.List;
    9. import java.util.Map;
    10. import java.util.Set;
    11. import java.util.concurrent.TimeUnit;
    13. /**
    14.  * @author : [Zara-cat]
    15.  * @version : [v1.0]
    16.  * @className : RedisUtil
    17.  * @description : [redis 工具类，方便使用 redisTemplate 的 api]
    18.  * @createTime : [2021/12/2 13:49]
    19.  * @updateUser : [Zara-cat]
    20.  * @updateTime : [2021/12/2 13:49]
    21.  * @updateRemark : [描述说明本次修改内容]
    22.  */
    23. @Component
    24. /**
    25.  * common
    26.  *      1. boolean expire(String key[键],long time[时间（秒）]) 指定缓存失效时间
    27.  *      2. long getExpire(String key) 根据 key 获取过期时间
    28.  *      3. boolean hasKey(String key) 判断 key 是否存在
    29.  *      4. void del(String... key)  删除缓存 【可以一个或传递多个key】
    30.  * String
    31.  *      5. Object get(String key) 普通缓存获取
    32.  *      6. boolean set(String key, Object value) 普通缓存放入
    33.  *      7. boolean set(String key, Object value, long time) 普通缓存放入并设置时间
    34.  *           时间(秒) time要大于0 如果time小于等于0 将设置无限期
    35.  *      8. long incr(String key, long delta) 递增  参数2：要增加几(大于0)
    36.  *      9. long decr(String key, long delta) 递减  参数2：要减少几(小于0)
    37.  *      10. boolean append(String key,String str) 追加字符 参数2：要追加的字符
    38.  * Map
    39.  *      11. Object hget(String key, String item) HashGet 参数1：键 不能为null 参数2：item 项 不能为null
    40.  *      12. Map<Object, Object> hmget(String key) 获取hashKey对应的所有键值
    41.  *      13. hmset(String key, Map<String, Object> map) HashSet 参数1： 键 参数2: 对应多个键值
    42.  *      14. boolean hmset(String key, Map<String, Object> map, long time) HashSet 并设置时间
    43.  *          参数1：键 参数2：对应多个键值 参数3：时间(秒)
    44.  *      15. boolean hset(String key, String item, Object value)  向一张hash表中放入数据,如果不存在将创建
    45.  *      16. boolean hset(String key, String item, Object value, long time) 向一张hash表中放入数据,如果不存在将创建
    46.  *          time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
    47.  *      17. void hdel(String key, Object... item) 删除hash表中的值 参数2：item 项 可以使多个 不能为null
    48.  *      18. boolean hHasKey(String key, String item) 判断hash表中是否有该项的值
    49.  *      19. double hincr(String key, String item, double by) hash递增 如果不存在,就会创建一个 并把新增后的值返回
    50.  *           参数3：要增加几(大于0)
    51.  *      20. double hdecr(String key, String item, double by)  hash递减 参数3：要减少记(小于0)
    52.  * set
    53.  *      21. Set<Object> sGet(String key) 根据key获取Set中的所有值
    54.  *      22. boolean sHasKey(String key, Object value)  根据value从一个set中查询,是否存在
    55.  *      23. long sSet(String key, Object... values)  将数据放入set缓存
    56.  *      24. long sSetAndTime(String key, long time, Object... values) 将set数据放入缓存
    57.  *          参数2：时间（秒）
    58.  *      25. long sGetSetSize(String key) 获取set缓存的长度
    59.  *      26. long setRemove(String key, Object... values) 移除值为value的
    60.  * list
    61.  *      27. List<Object> lGet(String key, long start, long end) 获取list缓存的内容
    62.  *          参数1：开始 参数2：结束  0到-1代表说有值
    63.  *      28. long lGetListSize(String key) 获取list缓存的长度
    64.  *      29. Object lGetIndex(String key, long index) 通过索引 获取list中的值
    65.  *          参数2：index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
    66.  *      30. boolean lSet(String key, Object value) 将值放入缓存
    67.  *      31. boolean lSet(String key, Object value, long time) 将值放入缓存
    68.  *      32. boolean lSet(String key, List<Object> value)  将list放入缓存
    69.  *      33. boolean lSet(String key, List<Object> value, long time) 将list放入缓存
    70.  *      34. boolean lUpdateIndex(String key, long index, Object value) 根据索引修改list中的某条数据
    71.  *          参数1： 键 参数2：索引 参数3：值
    72.  *      35. long lRemove(String key, long count, Object value) 移除N个值为value
    73.  *          参数1：键 参数2：移除多少个 参数3：值 return：移除的个数
    74.  *
    75.  */
    76. public final class RedisUtil {
    78.     @Autowired
    79.     private RedisTemplate<String,Object> redisTemplate;
    81.     // =============================common============================
    83.     /**
    84.      * 指定缓存失效时间
    85.      * @param key 键
    86.      * @param time 时间(秒)
    87.      * @return 成功/失败
    88.      */
    89.     public boolean expire(String key,long time){
    90.         try {
    91.             if (time > 0){
    92.                 redisTemplate.expire(key,time, TimeUnit.SECONDS);
    93.             }
    94.             return true;
    95.         } catch (Exception e) {
    96.             e.printStackTrace();
    97.             return false;
    98.         }
    99.     }
    101.     /**
    102.      * 根据 key 获取过期时间
    103.      * @param key 键 不能为null
    104.      * @return 时间（秒） 返回 0 代表为永久有效
    105.      */
    106.     public long getExpire(String key){
    107.         return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    108.     }
    110.     /**
    111.      * 判断 key 是否存在
    112.      * @param key 键
    113.      * @return true 存在 false 不存在
    114.      */
    115.     public boolean hasKey(String key){
    116.         try {
    117.             return redisTemplate.hasKey(key);
    118.         } catch (Exception e) {
    119.             e.printStackTrace();
    120.             return false;
    121.         }
    122.     }
    124.     /**
    125.      * 删除缓存
    126.      * @param key 可以传一个值 或多个
    127.      */
    128.     public void del(String... key){
    129.         if (key !=null && key.length > 0){
    130.             if (key.length == 1){
    131.                 redisTemplate.delete(key[0]);
    132.             }else {
    133.                 redisTemplate.delete(CollectionUtils.asList(key));
    134.             }
    135.         }
    136.     }
    137.     // ============================String=============================
    139.     /**
    140.      * 普通缓存获取
    141.      * @param key 键
    142.      * @return 值
    143.      */
    144.     public Object get(String key){
    145.         return key == null ? null : redisTemplate.opsForValue().get(key);
    146.     }
    148.     /**
    149.      * 普通缓存放入
    150.      * @param key 键
    151.      * @param value 值
    152.      * @return true 成功 / false 失败
    153.      */
    154.     public boolean set(String key,Object value){
    155.         try {
    156.             redisTemplate.opsForValue().set(key,value);
    157.             return true;
    158.         } catch (Exception e) {
    159.             e.printStackTrace();
    160.             return false;
    161.         }
    162.     }
    164.     /**
    165.      * 普通缓存放入并设置时间
    166.      * @param key 键
    167.      * @param value 值
    168.      * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
    169.      * @return true 成功 / false 失败
    170.      */
    171.     public boolean set(String key,Object value,long time){
    172.         try {
    173.             if (time > 0){
    174.                 redisTemplate.opsForValue().set(key,value,time,TimeUnit.SECONDS);
    175.             }else {
    176.                 set(key,value);
    177.             }
    178.             return true;
    179.         } catch (Exception e) {
    180.             e.printStackTrace();
    181.             return false;
    182.         }
    183.     }
    185.     /**
    186.      * 递增
    187.      * @param key   键
    188.      * @param delta 要增加几(大于0)
    189.      */
    190.     public long incr(String key, long delta) {
    191.         if (delta < 0) {
    192.             throw new RuntimeException("递增因子必须大于0");
    193.         }
    194.         return redisTemplate.opsForValue().increment(key, delta);
    195.     }
    197.     /**
    198.      * 递减
    199.      * @param key   键
    200.      * @param delta 要减少几(小于0)
    201.      */
    202.     public long decr(String key, long delta) {
    203.         if (delta < 0) {
    204.             throw new RuntimeException("递减因子必须大于0");
    205.         }
    206.         return redisTemplate.opsForValue().decrement(key,delta);
    207.         //return redisTemplate.opsForValue().increment(key, -delta);
    208.     }
    210.     public long strLen(String key){
    211.         return redisTemplate.opsForValue().get(key).toString().length();
    212.     }
    214.     /*
    215.      * 追加字符
    216.      * @param key   键
    217.      * @param str   要追加的字符
    218.      * */
    219.     public boolean append(String key,String str){
    220.         try {
    221.             redisTemplate.opsForValue().append(key,str);
    222.             return true;
    223.         }catch (Exception e){
    224.             return false;
    225.         }
    226.     }
    227.     // ================================Map=================================
    228.     /**
    229.      * HashGet
    230.      * @param key  键 不能为null
    231.      * @param item 项 不能为null
    232.      */
    233.     public Object hget(String key, String item) {
    234.         return redisTemplate.opsForHash().get(key, item);
    235.     }
    237.     /**
    238.      * 获取hashKey对应的所有键值
    239.      * @param key 键
    240.      * @return 对应的多个键值
    241.      */
    242.     public Map<Object, Object> hmget(String key) {
    243.         return redisTemplate.opsForHash().entries(key);
    244.     }
    246.     /**
    247.      * HashSet
    248.      * @param key 键
    249.      * @param map 对应多个键值
    250.      */
    251.     public boolean hmset(String key, Map<String, Object> map) {
    252.         try {
    253.             redisTemplate.opsForHash().putAll(key, map);
    254.             return true;
    255.         } catch (Exception e) {
    256.             e.printStackTrace();
    257.             return false;
    258.         }
    259.     }
    262.     /**
    263.      * HashSet 并设置时间
    264.      * @param key  键
    265.      * @param map  对应多个键值
    266.      * @param time 时间(秒)
    267.      * @return true成功 false失败
    268.      */
    269.     public boolean hmset(String key, Map<String, Object> map, long time) {
    270.         try {
    271.             redisTemplate.opsForHash().putAll(key, map);
    272.             if (time > 0) {
    273.                 expire(key, time);
    274.             }
    275.             return true;
    276.         } catch (Exception e) {
    277.             e.printStackTrace();
    278.             return false;
    279.         }
    280.     }
    283.     /**
    284.      * 向一张hash表中放入数据,如果不存在将创建
    285.      *
    286.      * @param key   键
    287.      * @param item  项
    288.      * @param value 值
    289.      * @return true 成功 false失败
    290.      */
    291.     public boolean hset(String key, String item, Object value) {
    292.         try {
    293.             redisTemplate.opsForHash().put(key, item, value);
    294.             return true;
    295.         } catch (Exception e) {
    296.             e.printStackTrace();
    297.             return false;
    298.         }
    299.     }
    301.     /**
    302.      * 向一张hash表中放入数据,如果不存在将创建
    303.      *
    304.      * @param key   键
    305.      * @param item  项
    306.      * @param value 值
    307.      * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
    308.      * @return true 成功 false失败
    309.      */
    310.     public boolean hset(String key, String item, Object value, long time) {
    311.         try {
    312.             redisTemplate.opsForHash().put(key, item, value);
    313.             if (time > 0) {
    314.                 expire(item, time);
    315.             }
    316.             return true;
    317.         } catch (Exception e) {
    318.             e.printStackTrace();
    319.             return false;
    320.         }
    321.     }
    324.     /**
    325.      * 删除hash表中的值
    326.      *
    327.      * @param key  键 不能为null
    328.      * @param item 项 可以使多个 不能为null
    329.      */
    330.     public void hdel(String key, Object... item) {
    331.         redisTemplate.opsForHash().delete(key, item);
    332.     }
    335.     /**
    336.      * 判断hash表中是否有该项的值
    337.      *
    338.      * @param key  键 不能为null
    339.      * @param item 项 不能为null
    340.      * @return true 存在 false不存在
    341.      */
    342.     public boolean hHasKey(String key, String item) {
    343.         return redisTemplate.opsForHash().hasKey(key, item);
    344.     }
    347.     /**
    348.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
    349.      *
    350.      * @param key  键
    351.      * @param item 项
    352.      * @param by   要增加几(大于0)
    353.      */
    354.     public double hincr(String key, String item, double by) {
    355.         return redisTemplate.opsForHash().increment(key, item, by);
    356.     }
    359.     /**
    360.      * hash递减
    361.      *
    362.      * @param key  键
    363.      * @param item 项
    364.      * @param by   要减少记(小于0)
    365.      */
    366.     public double hdecr(String key, String item, double by) {
    367.         return redisTemplate.opsForHash().increment(key, item, -by);
    368.     }
    371.     // ============================set=============================
    373.     /**
    374.      * 根据key获取Set中的所有值
    375.      * @param key 键
    376.      */
    377.     public Set<Object> sGet(String key) {
    378.         try {
    379.             return redisTemplate.opsForSet().members(key);
    380.         } catch (Exception e) {
    381.             e.printStackTrace();
    382.             return null;
    383.         }
    384.     }
    387.     /**
    388.      * 根据value从一个set中查询,是否存在
    389.      *
    390.      * @param key   键
    391.      * @param value 值
    392.      * @return true 存在 false不存在
    393.      */
    394.     public boolean sHasKey(String key, Object value) {
    395.         try {
    396.             return redisTemplate.opsForSet().isMember(key, value);
    397.         } catch (Exception e) {
    398.             e.printStackTrace();
    399.             return false;
    400.         }
    401.     }
    404.     /**
    405.      * 将数据放入set缓存
    406.      *
    407.      * @param key    键
    408.      * @param values 值 可以是多个
    409.      * @return 成功个数
    410.      */
    411.     public long sSet(String key, Object... values) {
    412.         try {
    413.             return redisTemplate.opsForSet().add(key, values);
    414.         } catch (Exception e) {
    415.             e.printStackTrace();
    416.             return 0;
    417.         }
    418.     }
    421.     /**
    422.      * 将set数据放入缓存
    423.      *
    424.      * @param key    键
    425.      * @param time   时间(秒)
    426.      * @param values 值 可以是多个
    427.      * @return 成功个数
    428.      */
    429.     public long sSetAndTime(String key, long time, Object... values) {
    430.         try {
    431.             Long count = redisTemplate.opsForSet().add(key, values);
    432.             if (time > 0)
    433.                 expire(key, time);
    434.             return count;
    435.         } catch (Exception e) {
    436.             e.printStackTrace();
    437.             return 0;
    438.         }
    439.     }
    442.     /**
    443.      * 获取set缓存的长度
    444.      *
    445.      * @param key 键
    446.      */
    447.     public long sGetSetSize(String key) {
    448.         try {
    449.             return redisTemplate.opsForSet().size(key);
    450.         } catch (Exception e) {
    451.             e.printStackTrace();
    452.             return 0;
    453.         }
    454.     }
    457.     /**
    458.      * 移除值为value的
    459.      *
    460.      * @param key    键
    461.      * @param values 值 可以是多个
    462.      * @return 移除的个数
    463.      */
    465.     public long setRemove(String key, Object... values) {
    466.         try {
    467.             Long count = redisTemplate.opsForSet().remove(key, values);
    468.             return count;
    469.         } catch (Exception e) {
    470.             e.printStackTrace();
    471.             return 0;
    472.         }
    473.     }
    475.     // ===============================list=================================
    477.     /**
    478.      * 获取list缓存的内容
    479.      *
    480.      * @param key   键
    481.      * @param start 开始
    482.      * @param end   结束 0 到 -1代表所有值
    483.      */
    484.     public List<Object> lGet(String key, long start, long end) {
    485.         try {
    486.             return redisTemplate.opsForList().range(key, start, end);
    487.         } catch (Exception e) {
    488.             e.printStackTrace();
    489.             return null;
    490.         }
    491.     }
    494.     /**
    495.      * 获取list缓存的长度
    496.      *
    497.      * @param key 键
    498.      */
    499.     public long lGetListSize(String key) {
    500.         try {
    501.             return redisTemplate.opsForList().size(key);
    502.         } catch (Exception e) {
    503.             e.printStackTrace();
    504.             return 0;
    505.         }
    506.     }
    509.     /**
    510.      * 通过索引 获取list中的值
    511.      *
    512.      * @param key   键
    513.      * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
    514.      */
    515.     public Object lGetIndex(String key, long index) {
    516.         try {
    517.             return redisTemplate.opsForList().index(key, index);
    518.         } catch (Exception e) {
    519.             e.printStackTrace();
    520.             return null;
    521.         }
    522.     }
    525.     /**
    526.      * 将list放入缓存
    527.      *
    528.      * @param key   键
    529.      * @param value 值
    530.      */
    531.     public boolean lSet(String key, Object value) {
    532.         try {
    533.             redisTemplate.opsForList().rightPush(key, value);
    534.             return true;
    535.         } catch (Exception e) {
    536.             e.printStackTrace();
    537.             return false;
    538.         }
    539.     }
    542.     /**
    543.      * 将list放入缓存
    544.      * @param key   键
    545.      * @param value 值
    546.      * @param time  时间(秒)
    547.      */
    548.     public boolean lSet(String key, Object value, long time) {
    549.         try {
    550.             redisTemplate.opsForList().rightPush(key, value);
    551.             if (time > 0)
    552.                 expire(key, time);
    553.             return true;
    554.         } catch (Exception e) {
    555.             e.printStackTrace();
    556.             return false;
    557.         }
    559.     }
    562.     /**
    563.      * 将list放入缓存
    564.      *
    565.      * @param key   键
    566.      * @param value 值
    567.      * @return
    568.      */
    569.     public boolean lSet(String key, List<Object> value) {
    570.         try {
    571.             redisTemplate.opsForList().rightPushAll(key, value);
    572.             return true;
    573.         } catch (Exception e) {
    574.             e.printStackTrace();
    575.             return false;
    576.         }
    578.     }
    581.     /**
    582.      * 将list放入缓存
    583.      *
    584.      * @param key   键
    585.      * @param value 值
    586.      * @param time  时间(秒)
    587.      * @return
    588.      */
    589.     public boolean lSet(String key, List<Object> value, long time) {
    590.         try {
    591.             redisTemplate.opsForList().rightPushAll(key, value);
    592.             if (time > 0)
    593.                 expire(key, time);
    594.             return true;
    595.         } catch (Exception e) {
    596.             e.printStackTrace();
    597.             return false;
    598.         }
    599.     }
    602.     /**
    603.      * 根据索引修改list中的某条数据
    604.      *
    605.      * @param key   键
    606.      * @param index 索引
    607.      * @param value 值
    608.      * @return
    609.      */
    611.     public boolean lUpdateIndex(String key, long index, Object value) {
    612.         try {
    613.             redisTemplate.opsForList().set(key, index, value);
    614.             return true;
    615.         } catch (Exception e) {
    616.             e.printStackTrace();
    617.             return false;
    618.         }
    619.     }
    622.     /**
    623.      * 移除N个值为value
    624.      *
    625.      * @param key   键
    626.      * @param count 移除多少个
    627.      * @param value 值
    628.      * @return 移除的个数
    629.      */
    631.     public long lRemove(String key, long count, Object value) {
    632.         try {
    633.             Long remove = redisTemplate.opsForList().remove(key, count, value);
    634.             return remove;
    635.         } catch (Exception e) {
    636.             e.printStackTrace();
    637.             return 0;
    638.         }
    640.     }
    642. }