redis 工具类

redis 工具类

1. /**
2. * Redis 工具类
3. */
4. @Component
5. public class RedisUtil {
7.     @Resource
8.     private RedisTemplate<String, Object> redisTemplate;
10.     public RedisUtil(RedisTemplate<String, Object> redisTemplate) {
11.         this.redisTemplate = redisTemplate;
12.     }
14.     /**
15.      * 指定缓存失效时间
16.      *
17.      * @param key  键
18.      * @param time 时间(秒)
19.      * @return
20.      */
21.     public boolean expire(String key, long time) {
22.         try {
23.             if (time > 0) {
24.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
25.             }
26.             return true;
27.         } catch (Exception e) {
28.             e.printStackTrace();
29.             return false;
30.         }
31.     }
33.     /**
34.      * 根据key 获取过期时间
35.      *
36.      * @param key 键 不能为null
37.      * @return 时间(秒) 返回0代表为永久有效
38.      */
39.     public long getExpire(String key) {
40.         return redisTemplate.getExpire(key, TimeUnit.SECONDS);
41.     }
43.     /**
44.      * 判断key是否存在
45.      *
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.     }
58.     /**
59.      * 删除缓存
60.      *
61.      * @param key 可以传一个值 或多个
62.      */
63.     @SuppressWarnings("unchecked")
64.     public void del(String... key) {
65.         if (key != null && key.length > 0) {
66.             if (key.length == 1) {
67.                 redisTemplate.delete(key[0]);
68.             } else {
69.                 redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
70.             }
71.         }
72.     }
74.     //============================String=============================
76.     /**
77.      * 普通缓存获取
78.      *
79.      * @param key 键
80.      * @return 值
81.      */
82.     public Object get(String key) {
83.         return key == null ? null : redisTemplate.opsForValue().get(key);
84.     }
86.     /**
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.      *
106.      * @param key   键
107.      * @param value 值
108.      * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
109.      * @return true成功 false 失败
110.      */
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               锁住的key
128.      * @param lockExpireMils    锁住的时长。如果超时未解锁，视为加锁线程死亡，其他线程可夺取锁
129.      * @return
130.      */
131.     public boolean setNx(String key, Long lockExpireMils) {
132.         return (boolean) redisTemplate.execute((RedisCallback) connection -> {
133.             //获取锁
134.             return connection.setNX(key.getBytes(), String.valueOf(System.currentTimeMillis() + lockExpireMils + 1).getBytes());
135.         });
136.     }
138.     /**
139.      * 递增
140.      *
141.      * @param key   键
142.      * @param delta 要增加几(大于0)
143.      * @return
144.      */
145.     public long incr(String key, long delta) {
146.         if (delta < 0) {
147.             throw new RuntimeException("递增因子必须大于0");
148.         }
149.         return redisTemplate.opsForValue().increment(key, delta);
150.     }
152.     /**
153.      * 递减
154.      *
155.      * @param key   键
156.      * @param delta 要减少几(小于0)
157.      * @return
158.      */
159.     public long decr(String key, long delta) {
160.         if (delta < 0) {
161.             throw new RuntimeException("递减因子必须大于0");
162.         }
163.         return redisTemplate.opsForValue().increment(key, -delta);
164.     }
166.     //================================Map=================================
168.     /**
169.      * HashGet
170.      *
171.      * @param key  键 不能为null
172.      * @param item 项 不能为null
173.      * @return 值
174.      */
175.     public Object hget(String key, String item) {
176.         return redisTemplate.opsForHash().get(key, item);
177.     }
179.     /**
180.      * 获取hashKey对应的所有键值
181.      *
182.      * @param key 键
183.      * @return 对应的多个键值
184.      */
185.     public Map<Object, Object> hmget(String key) {
186.         return redisTemplate.opsForHash().entries(key);
187.     }
189.     /**
190.      * HashSet
191.      *
192.      * @param key 键
193.      * @param map 对应多个键值
194.      * @return true 成功 false 失败
195.      */
196.     public boolean hmset(String key, Map<String, Object> map) {
197.         try {
198.             redisTemplate.opsForHash().putAll(key, map);
199.             return true;
200.         } catch (Exception e) {
201.             e.printStackTrace();
202.             return false;
203.         }
204.     }
206.     /**
207.      * HashSet 并设置时间
208.      *
209.      * @param key  键
210.      * @param map  对应多个键值
211.      * @param time 时间(秒)
212.      * @return true成功 false失败
213.      */
214.     public boolean hmset(String key, Map<String, Object> map, long time) {
215.         try {
216.             redisTemplate.opsForHash().putAll(key, map);
217.             if (time > 0) {
218.                 expire(key, time);
219.             }
220.             return true;
221.         } catch (Exception e) {
222.             e.printStackTrace();
223.             return false;
224.         }
225.     }
227.     /**
228.      * 向一张hash表中放入数据,如果不存在将创建
229.      *
230.      * @param key   键
231.      * @param item  项
232.      * @param value 值
233.      * @return true 成功 false失败
234.      */
235.     public boolean hset(String key, String item, Object value) {
236.         try {
237.             redisTemplate.opsForHash().put(key, item, value);
238.             return true;
239.         } catch (Exception e) {
240.             e.printStackTrace();
241.             return false;
242.         }
243.     }
245.     /**
246.      * 向一张hash表中放入数据,如果不存在将创建
247.      *
248.      * @param key   键
249.      * @param item  项
250.      * @param value 值
251.      * @param time  时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
252.      * @return true 成功 false失败
253.      */
254.     public boolean hset(String key, String item, Object value, long time) {
255.         try {
256.             redisTemplate.opsForHash().put(key, item, value);
257.             if (time > 0) {
258.                 expire(key, time);
259.             }
260.             return true;
261.         } catch (Exception e) {
262.             e.printStackTrace();
263.             return false;
264.         }
265.     }
267.     /**
268.      * 删除hash表中的值
269.      *
270.      * @param key  键 不能为null
271.      * @param item 项 可以使多个 不能为null
272.      */
273.     public void hdel(String key, Object... item) {
274.         redisTemplate.opsForHash().delete(key, item);
275.     }
277.     /**
278.      * 判断hash表中是否有该项的值
279.      *
280.      * @param key  键 不能为null
281.      * @param item 项 不能为null
282.      * @return true 存在 false不存在
283.      */
284.     public boolean hHasKey(String key, String item) {
285.         return redisTemplate.opsForHash().hasKey(key, item);
286.     }
288.     /**
289.      * hash递增 如果不存在,就会创建一个 并把新增后的值返回
290.      *
291.      * @param key  键
292.      * @param item 项
293.      * @param by   要增加几(大于0)
294.      * @return
295.      */
296.     public double hincr(String key, String item, double by) {
297.         return redisTemplate.opsForHash().increment(key, item, by);
298.     }
300.     /**
301.      * hash递减
302.      *
303.      * @param key  键
304.      * @param item 项
305.      * @param by   要减少记(小于0)
306.      * @return
307.      */
308.     public double hdecr(String key, String item, double by) {
309.         return redisTemplate.opsForHash().increment(key, item, -by);
310.     }
312.     //============================set=============================
314.     /**
315.      * 根据key获取Set中的所有值
316.      *
317.      * @param key 键
318.      * @return
319.      */
320.     public Set<Object> sGet(String key) {
321.         try {
322.             return redisTemplate.opsForSet().members(key);
323.         } catch (Exception e) {
324.             e.printStackTrace();
325.             return null;
326.         }
327.     }
329.     /**
330.      * 根据value从一个set中查询,是否存在
331.      *
332.      * @param key   键
333.      * @param value 值
334.      * @return true 存在 false不存在
335.      */
336.     public boolean sHasKey(String key, Object value) {
337.         try {
338.             return redisTemplate.opsForSet().isMember(key, value);
339.         } catch (Exception e) {
340.             e.printStackTrace();
341.             return false;
342.         }
343.     }
345.     /**
346.      * 将数据放入set缓存
347.      *
348.      * @param key    键
349.      * @param values 值 可以是多个
350.      * @return 成功个数
351.      */
352.     public long sSet(String key, Object... values) {
353.         try {
354.             return redisTemplate.opsForSet().add(key, values);
355.         } catch (Exception e) {
356.             e.printStackTrace();
357.             return 0;
358.         }
359.     }
361.     /**
362.      * 将set数据放入缓存
363.      *
364.      * @param key    键
365.      * @param time   时间(秒)
366.      * @param values 值 可以是多个
367.      * @return 成功个数
368.      */
369.     public long sSetAndTime(String key, long time, Object... values) {
370.         try {
371.             Long count = redisTemplate.opsForSet().add(key, values);
372.             if (time > 0) {
373.                 expire(key, time);
374.             }
375.             return count;
376.         } catch (Exception e) {
377.             e.printStackTrace();
378.             return 0;
379.         }
380.     }
382.     /**
383.      * 获取set缓存的长度
384.      *
385.      * @param key 键
386.      * @return
387.      */
388.     public long sGetSetSize(String key) {
389.         try {
390.             return redisTemplate.opsForSet().size(key);
391.         } catch (Exception e) {
392.             e.printStackTrace();
393.             return 0;
394.         }
395.     }
397.     /**
398.      * 移除值为value的
399.      *
400.      * @param key    键
401.      * @param values 值 可以是多个
402.      * @return 移除的个数
403.      */
404.     public long setRemove(String key, Object... values) {
405.         try {
406.             Long count = redisTemplate.opsForSet().remove(key, values);
407.             return count;
408.         } catch (Exception e) {
409.             e.printStackTrace();
410.             return 0;
411.         }
412.     }
413.     //===============================list=================================
415.     /**
416.      * 获取list缓存的内容
417.      *
418.      * @param key   键
419.      * @param start 开始
420.      * @param end   结束  0 到 -1代表所有值
421.      * @return
422.      */
423.     public List<Object> lGet(String key, long start, long end) {
424.         try {
425.             return redisTemplate.opsForList().range(key, start, end);
426.         } catch (Exception e) {
427.             e.printStackTrace();
428.             return null;
429.         }
430.     }
432.     /**
433.      * 获取list缓存的长度
434.      *
435.      * @param key 键
436.      * @return
437.      */
438.     public long lGetListSize(String key) {
439.         try {
440.             return redisTemplate.opsForList().size(key);
441.         } catch (Exception e) {
442.             e.printStackTrace();
443.             return 0;
444.         }
445.     }
447.     /**
448.      * 通过索引 获取list中的值
449.      *
450.      * @param key   键
451.      * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
452.      * @return
453.      */
454.     public Object lGetIndex(String key, long index) {
455.         try {
456.             return redisTemplate.opsForList().index(key, index);
457.         } catch (Exception e) {
458.             e.printStackTrace();
459.             return null;
460.         }
461.     }
463.     /**
464.      * 将list放入缓存
465.      *
466.      * @param key   键
467.      * @param value 值
468.      * @return
469.      */
470.     public boolean lSet(String key, Object value) {
471.         try {
472.             redisTemplate.opsForList().rightPush(key, value);
473.             return true;
474.         } catch (Exception e) {
475.             e.printStackTrace();
476.             return false;
477.         }
478.     }
480.     /**
481.      * 将list放入缓存
482.      *
483.      * @param key   键
484.      * @param value 值
485.      * @param time  时间(秒)
486.      * @return
487.      */
488.     public boolean lSet(String key, Object value, long time) {
489.         try {
490.             redisTemplate.opsForList().rightPush(key, value);
491.             if (time > 0) {
492.                 expire(key, time);
493.             }
494.             return true;
495.         } catch (Exception e) {
496.             e.printStackTrace();
497.             return false;
498.         }
499.     }
501.     /**
502.      * 将list放入缓存
503.      *
504.      * @param key   键
505.      * @param value 值
506.      * @return
507.      */
508.     public boolean lSet(String key, List<Object> value) {
509.         try {
510.             redisTemplate.opsForList().rightPushAll(key, value);
511.             return true;
512.         } catch (Exception e) {
513.             e.printStackTrace();
514.             return false;
515.         }
516.     }
518.     /**
519.      * 将list放入缓存
520.      *
521.      * @param key   键
522.      * @param value 值
523.      * @param time  时间(秒)
524.      * @return
525.      */
526.     public boolean lSet(String key, List<Object> value, long time) {
527.         try {
528.             redisTemplate.opsForList().rightPushAll(key, value);
529.             if (time > 0) {
530.                 expire(key, time);
531.             }
532.             return true;
533.         } catch (Exception e) {
534.             e.printStackTrace();
535.             return false;
536.         }
537.     }
539.     /**
540.      * 根据索引修改list中的某条数据
541.      *
542.      * @param key   键
543.      * @param index 索引
544.      * @param value 值
545.      * @return
546.      */
547.     public boolean lUpdateIndex(String key, long index, Object value) {
548.         try {
549.             redisTemplate.opsForList().set(key, index, value);
550.             return true;
551.         } catch (Exception e) {
552.             e.printStackTrace();
553.             return false;
554.         }
555.     }
557.     /**
558.      * 移除N个值为value
559.      *
560.      * @param key   键
561.      * @param count 移除多少个
562.      * @param value 值
563.      * @return 移除的个数
564.      */
565.     public long lRemove(String key, long count, Object value) {
566.         try {
567.             Long remove = redisTemplate.opsForList().remove(key, count, value);
568.             return remove;
569.         } catch (Exception e) {
570.             e.printStackTrace();
571.             return 0;
572.         }
573.     }
575.     /**
576.      * 模糊查询获取key值
577.      *
578.      * @param pattern
579.      * @return
580.      */
581.     public Set keys(String pattern) {
582.         return redisTemplate.keys(pattern);
583.     }
585.     /**
586.      * 使用Redis的消息队列
587.      *
588.      * @param channel
589.      * @param message 消息内容
590.      */
591.     public void convertAndSend(String channel, Object message) {
592.         redisTemplate.convertAndSend(channel, message);
593.     }
596.     //=========BoundListOperations 用法 start============
598.     /**
599.      * 将数据添加到Redis的list中（从右边添加）
600.      *
601.      * @param listKey
602.      * @param timeout 有效时间
603.      * @param unit    时间类型
604.      * @param values  待添加的数据
605.      */
606.     public void addToListRight(String listKey, long timeout, TimeUnit unit, Object... values) {
607.         //绑定操作
608.         BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
609.         //插入数据
610.         boundValueOperations.rightPushAll(values);
611.         //设置过期时间
612.         boundValueOperations.expire(timeout, unit);
613.     }
615.     /**
616.      * 根据起始结束序号遍历Redis中的list
617.      *
618.      * @param listKey
619.      * @param start   起始序号
620.      * @param end     结束序号
621.      * @return
622.      */
623.     public List<Object> rangeList(String listKey, long start, long end) {
624.         //绑定操作
625.         BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
626.         //查询数据
627.         return boundValueOperations.range(start, end);
628.     }
630.     /**
631.      * 弹出右边的值 --- 并且移除这个值
632.      *
633.      * @param listKey
634.      */
635.     public Object rightPop(String listKey) {
636.         //绑定操作
637.         BoundListOperations<String, Object> boundValueOperations = redisTemplate.boundListOps(listKey);
638.         return boundValueOperations.rightPop();
639.     }
641.     //=========BoundListOperations 用法 End============
643. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！